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 //===----------------------------------------------------------------------===//
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/CXXInheritance.h"
19 #include "clang/AST/ExprCXX.h"
20 #include "clang/AST/ExprObjC.h"
21 #include "clang/AST/TypeLoc.h"
22 #include "clang/Basic/PartialDiagnostic.h"
23 #include "clang/Basic/TargetInfo.h"
24 #include "clang/Lex/Preprocessor.h"
25 #include "clang/Parse/DeclSpec.h"
26 #include "clang/Parse/Template.h"
27 #include "llvm/ADT/STLExtras.h"
28 using namespace clang;
30 Action::TypeTy *Sema::getDestructorName(SourceLocation TildeLoc,
32 SourceLocation NameLoc,
33 Scope *S, CXXScopeSpec &SS,
34 TypeTy *ObjectTypePtr,
35 bool EnteringContext) {
36 // Determine where to perform name lookup.
38 // FIXME: This area of the standard is very messy, and the current
39 // wording is rather unclear about which scopes we search for the
40 // destructor name; see core issues 399 and 555. Issue 399 in
41 // particular shows where the current description of destructor name
42 // lookup is completely out of line with existing practice, e.g.,
43 // this appears to be ill-formed:
46 // template <typename T> struct S {
51 // void f(N::S<int>* s) {
52 // s->N::S<int>::~S();
55 // See also PR6358 and PR6359.
56 // For this reason, we're currently only doing the C++03 version of this
57 // code; the C++0x version has to wait until we get a proper spec.
59 DeclContext *LookupCtx = 0;
60 bool isDependent = false;
61 bool LookInScope = false;
63 // If we have an object type, it's because we are in a
64 // pseudo-destructor-expression or a member access expression, and
65 // we know what type we're looking for.
67 SearchType = GetTypeFromParser(ObjectTypePtr);
70 NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep();
72 bool AlreadySearched = false;
73 bool LookAtPrefix = true;
74 // C++ [basic.lookup.qual]p6:
75 // If a pseudo-destructor-name (5.2.4) contains a nested-name-specifier,
76 // the type-names are looked up as types in the scope designated by the
77 // nested-name-specifier. In a qualified-id of the form:
79 // ::[opt] nested-name-specifier ̃ class-name
81 // where the nested-name-specifier designates a namespace scope, and in
82 // a qualified-id of the form:
84 // ::opt nested-name-specifier class-name :: ̃ class-name
86 // the class-names are looked up as types in the scope designated by
87 // the nested-name-specifier.
89 // Here, we check the first case (completely) and determine whether the
90 // code below is permitted to look at the prefix of the
91 // nested-name-specifier.
92 DeclContext *DC = computeDeclContext(SS, EnteringContext);
93 if (DC && DC->isFileContext()) {
94 AlreadySearched = true;
97 } else if (DC && isa<CXXRecordDecl>(DC))
100 // The second case from the C++03 rules quoted further above.
101 NestedNameSpecifier *Prefix = 0;
102 if (AlreadySearched) {
103 // Nothing left to do.
104 } else if (LookAtPrefix && (Prefix = NNS->getPrefix())) {
105 CXXScopeSpec PrefixSS;
106 PrefixSS.setScopeRep(Prefix);
107 LookupCtx = computeDeclContext(PrefixSS, EnteringContext);
108 isDependent = isDependentScopeSpecifier(PrefixSS);
109 } else if (ObjectTypePtr) {
110 LookupCtx = computeDeclContext(SearchType);
111 isDependent = SearchType->isDependentType();
113 LookupCtx = computeDeclContext(SS, EnteringContext);
114 isDependent = LookupCtx && LookupCtx->isDependentContext();
118 } else if (ObjectTypePtr) {
119 // C++ [basic.lookup.classref]p3:
120 // If the unqualified-id is ~type-name, the type-name is looked up
121 // in the context of the entire postfix-expression. If the type T
122 // of the object expression is of a class type C, the type-name is
123 // also looked up in the scope of class C. At least one of the
124 // lookups shall find a name that refers to (possibly
126 LookupCtx = computeDeclContext(SearchType);
127 isDependent = SearchType->isDependentType();
128 assert((isDependent || !SearchType->isIncompleteType()) &&
129 "Caller should have completed object type");
133 // Perform lookup into the current scope (only).
137 LookupResult Found(*this, &II, NameLoc, LookupOrdinaryName);
138 for (unsigned Step = 0; Step != 2; ++Step) {
139 // Look for the name first in the computed lookup context (if we
140 // have one) and, if that fails to find a match, in the sope (if
141 // we're allowed to look there).
143 if (Step == 0 && LookupCtx)
144 LookupQualifiedName(Found, LookupCtx);
145 else if (Step == 1 && LookInScope && S)
146 LookupName(Found, S);
150 // FIXME: Should we be suppressing ambiguities here?
151 if (Found.isAmbiguous())
154 if (TypeDecl *Type = Found.getAsSingle<TypeDecl>()) {
155 QualType T = Context.getTypeDeclType(Type);
157 if (SearchType.isNull() || SearchType->isDependentType() ||
158 Context.hasSameUnqualifiedType(T, SearchType)) {
159 // We found our type!
161 return T.getAsOpaquePtr();
165 // If the name that we found is a class template name, and it is
166 // the same name as the template name in the last part of the
167 // nested-name-specifier (if present) or the object type, then
168 // this is the destructor for that class.
169 // FIXME: This is a workaround until we get real drafting for core
170 // issue 399, for which there isn't even an obvious direction.
171 if (ClassTemplateDecl *Template = Found.getAsSingle<ClassTemplateDecl>()) {
172 QualType MemberOfType;
174 if (DeclContext *Ctx = computeDeclContext(SS, EnteringContext)) {
175 // Figure out the type of the context, if it has one.
176 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx))
177 MemberOfType = Context.getTypeDeclType(Record);
180 if (MemberOfType.isNull())
181 MemberOfType = SearchType;
183 if (MemberOfType.isNull())
186 // We're referring into a class template specialization. If the
187 // class template we found is the same as the template being
188 // specialized, we found what we are looking for.
189 if (const RecordType *Record = MemberOfType->getAs<RecordType>()) {
190 if (ClassTemplateSpecializationDecl *Spec
191 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
192 if (Spec->getSpecializedTemplate()->getCanonicalDecl() ==
193 Template->getCanonicalDecl())
194 return MemberOfType.getAsOpaquePtr();
200 // We're referring to an unresolved class template
201 // specialization. Determine whether we class template we found
202 // is the same as the template being specialized or, if we don't
203 // know which template is being specialized, that it at least
204 // has the same name.
205 if (const TemplateSpecializationType *SpecType
206 = MemberOfType->getAs<TemplateSpecializationType>()) {
207 TemplateName SpecName = SpecType->getTemplateName();
209 // The class template we found is the same template being
211 if (TemplateDecl *SpecTemplate = SpecName.getAsTemplateDecl()) {
212 if (SpecTemplate->getCanonicalDecl() == Template->getCanonicalDecl())
213 return MemberOfType.getAsOpaquePtr();
218 // The class template we found has the same name as the
219 // (dependent) template name being specialized.
220 if (DependentTemplateName *DepTemplate
221 = SpecName.getAsDependentTemplateName()) {
222 if (DepTemplate->isIdentifier() &&
223 DepTemplate->getIdentifier() == Template->getIdentifier())
224 return MemberOfType.getAsOpaquePtr();
233 // We didn't find our type, but that's okay: it's dependent
235 NestedNameSpecifier *NNS = 0;
238 NNS = (NestedNameSpecifier *)SS.getScopeRep();
239 Range = SourceRange(SS.getRange().getBegin(), NameLoc);
241 NNS = NestedNameSpecifier::Create(Context, &II);
242 Range = SourceRange(NameLoc);
245 return CheckTypenameType(ETK_None, NNS, II, SourceLocation(),
246 Range, NameLoc).getAsOpaquePtr();
250 Diag(NameLoc, diag::err_ident_in_pseudo_dtor_not_a_type)
253 Diag(NameLoc, diag::err_destructor_class_name);
258 /// \brief Build a C++ typeid expression with a type operand.
259 Sema::OwningExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
260 SourceLocation TypeidLoc,
261 TypeSourceInfo *Operand,
262 SourceLocation RParenLoc) {
263 // C++ [expr.typeid]p4:
264 // The top-level cv-qualifiers of the lvalue expression or the type-id
265 // that is the operand of typeid are always ignored.
266 // If the type of the type-id is a class type or a reference to a class
267 // type, the class shall be completely-defined.
270 = Context.getUnqualifiedArrayType(Operand->getType().getNonReferenceType(),
272 if (T->getAs<RecordType>() &&
273 RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
276 return Owned(new (Context) CXXTypeidExpr(TypeInfoType.withConst(),
278 SourceRange(TypeidLoc, RParenLoc)));
281 /// \brief Build a C++ typeid expression with an expression operand.
282 Sema::OwningExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
283 SourceLocation TypeidLoc,
285 SourceLocation RParenLoc) {
286 bool isUnevaluatedOperand = true;
287 Expr *E = static_cast<Expr *>(Operand.get());
288 if (E && !E->isTypeDependent()) {
289 QualType T = E->getType();
290 if (const RecordType *RecordT = T->getAs<RecordType>()) {
291 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
292 // C++ [expr.typeid]p3:
293 // [...] If the type of the expression is a class type, the class
294 // shall be completely-defined.
295 if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
298 // C++ [expr.typeid]p3:
299 // When typeid is applied to an expression other than an lvalue of a
300 // polymorphic class type [...] [the] expression is an unevaluated
302 if (RecordD->isPolymorphic() && E->isLvalue(Context) == Expr::LV_Valid) {
303 isUnevaluatedOperand = false;
305 // We require a vtable to query the type at run time.
306 MarkVTableUsed(TypeidLoc, RecordD);
310 // C++ [expr.typeid]p4:
311 // [...] If the type of the type-id is a reference to a possibly
312 // cv-qualified type, the result of the typeid expression refers to a
313 // std::type_info object representing the cv-unqualified referenced
316 QualType UnqualT = Context.getUnqualifiedArrayType(T, Quals);
317 if (!Context.hasSameType(T, UnqualT)) {
319 ImpCastExprToType(E, UnqualT, CastExpr::CK_NoOp, E->isLvalue(Context));
325 // If this is an unevaluated operand, clear out the set of
326 // declaration references we have been computing and eliminate any
327 // temporaries introduced in its computation.
328 if (isUnevaluatedOperand)
329 ExprEvalContexts.back().Context = Unevaluated;
331 return Owned(new (Context) CXXTypeidExpr(TypeInfoType.withConst(),
332 Operand.takeAs<Expr>(),
333 SourceRange(TypeidLoc, RParenLoc)));
336 /// ActOnCXXTypeidOfType - Parse typeid( type-id ) or typeid (expression);
337 Action::OwningExprResult
338 Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc,
339 bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
340 // Find the std::type_info type.
342 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
344 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info");
345 LookupResult R(*this, TypeInfoII, SourceLocation(), LookupTagName);
346 LookupQualifiedName(R, StdNamespace);
347 RecordDecl *TypeInfoRecordDecl = R.getAsSingle<RecordDecl>();
348 if (!TypeInfoRecordDecl)
349 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
351 QualType TypeInfoType = Context.getTypeDeclType(TypeInfoRecordDecl);
354 // The operand is a type; handle it as such.
355 TypeSourceInfo *TInfo = 0;
356 QualType T = GetTypeFromParser(TyOrExpr, &TInfo);
361 TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
363 return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc);
366 // The operand is an expression.
367 return BuildCXXTypeId(TypeInfoType, OpLoc, Owned((Expr*)TyOrExpr), RParenLoc);
370 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
371 Action::OwningExprResult
372 Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {
373 assert((Kind == tok::kw_true || Kind == tok::kw_false) &&
374 "Unknown C++ Boolean value!");
375 return Owned(new (Context) CXXBoolLiteralExpr(Kind == tok::kw_true,
376 Context.BoolTy, OpLoc));
379 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
380 Action::OwningExprResult
381 Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc) {
382 return Owned(new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc));
385 /// ActOnCXXThrow - Parse throw expressions.
386 Action::OwningExprResult
387 Sema::ActOnCXXThrow(SourceLocation OpLoc, ExprArg E) {
388 Expr *Ex = E.takeAs<Expr>();
389 if (Ex && !Ex->isTypeDependent() && CheckCXXThrowOperand(OpLoc, Ex))
391 return Owned(new (Context) CXXThrowExpr(Ex, Context.VoidTy, OpLoc));
394 /// CheckCXXThrowOperand - Validate the operand of a throw.
395 bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E) {
396 // C++ [except.throw]p3:
397 // A throw-expression initializes a temporary object, called the exception
398 // object, the type of which is determined by removing any top-level
399 // cv-qualifiers from the static type of the operand of throw and adjusting
400 // the type from "array of T" or "function returning T" to "pointer to T"
401 // or "pointer to function returning T", [...]
402 if (E->getType().hasQualifiers())
403 ImpCastExprToType(E, E->getType().getUnqualifiedType(), CastExpr::CK_NoOp,
404 E->isLvalue(Context) == Expr::LV_Valid);
406 DefaultFunctionArrayConversion(E);
408 // If the type of the exception would be an incomplete type or a pointer
409 // to an incomplete type other than (cv) void the program is ill-formed.
410 QualType Ty = E->getType();
411 bool isPointer = false;
412 if (const PointerType* Ptr = Ty->getAs<PointerType>()) {
413 Ty = Ptr->getPointeeType();
416 if (!isPointer || !Ty->isVoidType()) {
417 if (RequireCompleteType(ThrowLoc, Ty,
418 PDiag(isPointer ? diag::err_throw_incomplete_ptr
419 : diag::err_throw_incomplete)
420 << E->getSourceRange()))
423 if (RequireNonAbstractType(ThrowLoc, E->getType(),
424 PDiag(diag::err_throw_abstract_type)
425 << E->getSourceRange()))
429 // Initialize the exception result. This implicitly weeds out
430 // abstract types or types with inaccessible copy constructors.
431 // FIXME: Determine whether we can elide this copy per C++0x [class.copy]p34.
432 InitializedEntity Entity =
433 InitializedEntity::InitializeException(ThrowLoc, E->getType(),
435 OwningExprResult Res = PerformCopyInitialization(Entity,
440 E = Res.takeAs<Expr>();
442 // If the exception has class type, we need additional handling.
443 const RecordType *RecordTy = Ty->getAs<RecordType>();
446 CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
448 // If we are throwing a polymorphic class type or pointer thereof,
449 // exception handling will make use of the vtable.
450 MarkVTableUsed(ThrowLoc, RD);
452 // If the class has a non-trivial destructor, we must be able to call it.
453 if (RD->hasTrivialDestructor())
456 CXXDestructorDecl *Destructor
457 = const_cast<CXXDestructorDecl*>(LookupDestructor(RD));
461 MarkDeclarationReferenced(E->getExprLoc(), Destructor);
462 CheckDestructorAccess(E->getExprLoc(), Destructor,
463 PDiag(diag::err_access_dtor_exception) << Ty);
467 Action::OwningExprResult Sema::ActOnCXXThis(SourceLocation ThisLoc) {
468 /// C++ 9.3.2: In the body of a non-static member function, the keyword this
469 /// is a non-lvalue expression whose value is the address of the object for
470 /// which the function is called.
472 DeclContext *DC = getFunctionLevelDeclContext();
473 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC))
474 if (MD->isInstance())
475 return Owned(new (Context) CXXThisExpr(ThisLoc,
476 MD->getThisType(Context),
477 /*isImplicit=*/false));
479 return ExprError(Diag(ThisLoc, diag::err_invalid_this_use));
482 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
483 /// Can be interpreted either as function-style casting ("int(x)")
484 /// or class type construction ("ClassType(x,y,z)")
485 /// or creation of a value-initialized type ("int()").
486 Action::OwningExprResult
487 Sema::ActOnCXXTypeConstructExpr(SourceRange TypeRange, TypeTy *TypeRep,
488 SourceLocation LParenLoc,
490 SourceLocation *CommaLocs,
491 SourceLocation RParenLoc) {
495 TypeSourceInfo *TInfo;
496 QualType Ty = GetTypeFromParser(TypeRep, &TInfo);
498 TInfo = Context.getTrivialTypeSourceInfo(Ty, SourceLocation());
499 unsigned NumExprs = exprs.size();
500 Expr **Exprs = (Expr**)exprs.get();
501 SourceLocation TyBeginLoc = TypeRange.getBegin();
502 SourceRange FullRange = SourceRange(TyBeginLoc, RParenLoc);
504 if (Ty->isDependentType() ||
505 CallExpr::hasAnyTypeDependentArguments(Exprs, NumExprs)) {
508 return Owned(CXXUnresolvedConstructExpr::Create(Context,
509 TypeRange.getBegin(), Ty,
515 if (Ty->isArrayType())
516 return ExprError(Diag(TyBeginLoc,
517 diag::err_value_init_for_array_type) << FullRange);
518 if (!Ty->isVoidType() &&
519 RequireCompleteType(TyBeginLoc, Ty,
520 PDiag(diag::err_invalid_incomplete_type_use)
524 if (RequireNonAbstractType(TyBeginLoc, Ty,
525 diag::err_allocation_of_abstract_type))
529 // C++ [expr.type.conv]p1:
530 // If the expression list is a single expression, the type conversion
531 // expression is equivalent (in definedness, and if defined in meaning) to the
532 // corresponding cast expression.
535 CastExpr::CastKind Kind = CastExpr::CK_Unknown;
536 CXXBaseSpecifierArray BasePath;
537 if (CheckCastTypes(TypeRange, Ty, Exprs[0], Kind, BasePath,
538 /*FunctionalStyle=*/true))
543 return Owned(new (Context) CXXFunctionalCastExpr(
544 Ty.getNonLValueExprType(Context),
545 TInfo, TyBeginLoc, Kind,
550 if (Ty->isRecordType()) {
551 InitializedEntity Entity = InitializedEntity::InitializeTemporary(Ty);
552 InitializationKind Kind
553 = NumExprs ? InitializationKind::CreateDirect(TypeRange.getBegin(),
554 LParenLoc, RParenLoc)
555 : InitializationKind::CreateValue(TypeRange.getBegin(),
556 LParenLoc, RParenLoc);
557 InitializationSequence InitSeq(*this, Entity, Kind, Exprs, NumExprs);
558 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
561 // FIXME: Improve AST representation?
565 // C++ [expr.type.conv]p1:
566 // If the expression list specifies more than a single value, the type shall
567 // be a class with a suitably declared constructor.
570 return ExprError(Diag(CommaLocs[0],
571 diag::err_builtin_func_cast_more_than_one_arg)
574 assert(NumExprs == 0 && "Expected 0 expressions");
575 // C++ [expr.type.conv]p2:
576 // The expression T(), where T is a simple-type-specifier for a non-array
577 // complete object type or the (possibly cv-qualified) void type, creates an
578 // rvalue of the specified type, which is value-initialized.
581 return Owned(new (Context) CXXScalarValueInitExpr(Ty, TyBeginLoc, RParenLoc));
585 /// ActOnCXXNew - Parsed a C++ 'new' expression (C++ 5.3.4), as in e.g.:
586 /// @code new (memory) int[size][4] @endcode
588 /// @code ::new Foo(23, "hello") @endcode
589 /// For the interpretation of this heap of arguments, consult the base version.
590 Action::OwningExprResult
591 Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
592 SourceLocation PlacementLParen, MultiExprArg PlacementArgs,
593 SourceLocation PlacementRParen, SourceRange TypeIdParens,
594 Declarator &D, SourceLocation ConstructorLParen,
595 MultiExprArg ConstructorArgs,
596 SourceLocation ConstructorRParen) {
598 // If the specified type is an array, unwrap it and save the expression.
599 if (D.getNumTypeObjects() > 0 &&
600 D.getTypeObject(0).Kind == DeclaratorChunk::Array) {
601 DeclaratorChunk &Chunk = D.getTypeObject(0);
602 if (Chunk.Arr.hasStatic)
603 return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new)
604 << D.getSourceRange());
605 if (!Chunk.Arr.NumElts)
606 return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size)
607 << D.getSourceRange());
609 ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts);
610 D.DropFirstTypeObject();
613 // Every dimension shall be of constant size.
615 for (unsigned I = 0, N = D.getNumTypeObjects(); I < N; ++I) {
616 if (D.getTypeObject(I).Kind != DeclaratorChunk::Array)
619 DeclaratorChunk::ArrayTypeInfo &Array = D.getTypeObject(I).Arr;
620 if (Expr *NumElts = (Expr *)Array.NumElts) {
621 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent() &&
622 !NumElts->isIntegerConstantExpr(Context)) {
623 Diag(D.getTypeObject(I).Loc, diag::err_new_array_nonconst)
624 << NumElts->getSourceRange();
631 //FIXME: Store TypeSourceInfo in CXXNew expression.
632 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, /*Scope=*/0);
633 QualType AllocType = TInfo->getType();
634 if (D.isInvalidType())
637 SourceRange R = TInfo->getTypeLoc().getSourceRange();
638 return BuildCXXNew(StartLoc, UseGlobal,
644 D.getSourceRange().getBegin(),
648 move(ConstructorArgs),
652 Sema::OwningExprResult
653 Sema::BuildCXXNew(SourceLocation StartLoc, bool UseGlobal,
654 SourceLocation PlacementLParen,
655 MultiExprArg PlacementArgs,
656 SourceLocation PlacementRParen,
657 SourceRange TypeIdParens,
659 SourceLocation TypeLoc,
660 SourceRange TypeRange,
662 SourceLocation ConstructorLParen,
663 MultiExprArg ConstructorArgs,
664 SourceLocation ConstructorRParen) {
665 if (CheckAllocatedType(AllocType, TypeLoc, TypeRange))
668 // Per C++0x [expr.new]p5, the type being constructed may be a
669 // typedef of an array type.
670 if (!ArraySizeE.get()) {
671 if (const ConstantArrayType *Array
672 = Context.getAsConstantArrayType(AllocType)) {
673 ArraySizeE = Owned(new (Context) IntegerLiteral(Array->getSize(),
674 Context.getSizeType(),
675 TypeRange.getEnd()));
676 AllocType = Array->getElementType();
680 QualType ResultType = Context.getPointerType(AllocType);
682 // C++ 5.3.4p6: "The expression in a direct-new-declarator shall have integral
683 // or enumeration type with a non-negative value."
684 Expr *ArraySize = (Expr *)ArraySizeE.get();
685 if (ArraySize && !ArraySize->isTypeDependent()) {
687 QualType SizeType = ArraySize->getType();
689 OwningExprResult ConvertedSize
690 = ConvertToIntegralOrEnumerationType(StartLoc, move(ArraySizeE),
691 PDiag(diag::err_array_size_not_integral),
692 PDiag(diag::err_array_size_incomplete_type)
693 << ArraySize->getSourceRange(),
694 PDiag(diag::err_array_size_explicit_conversion),
695 PDiag(diag::note_array_size_conversion),
696 PDiag(diag::err_array_size_ambiguous_conversion),
697 PDiag(diag::note_array_size_conversion),
698 PDiag(getLangOptions().CPlusPlus0x? 0
699 : diag::ext_array_size_conversion));
700 if (ConvertedSize.isInvalid())
703 ArraySize = ConvertedSize.takeAs<Expr>();
704 ArraySizeE = Owned(ArraySize);
705 SizeType = ArraySize->getType();
706 if (!SizeType->isIntegralOrEnumerationType())
709 // Let's see if this is a constant < 0. If so, we reject it out of hand.
710 // We don't care about special rules, so we tell the machinery it's not
711 // evaluated - it gives us a result in more cases.
712 if (!ArraySize->isValueDependent()) {
714 if (ArraySize->isIntegerConstantExpr(Value, Context, 0, false)) {
715 if (Value < llvm::APSInt(
716 llvm::APInt::getNullValue(Value.getBitWidth()),
718 return ExprError(Diag(ArraySize->getSourceRange().getBegin(),
719 diag::err_typecheck_negative_array_size)
720 << ArraySize->getSourceRange());
721 } else if (TypeIdParens.isValid()) {
722 // Can't have dynamic array size when the type-id is in parentheses.
723 Diag(ArraySize->getLocStart(), diag::ext_new_paren_array_nonconst)
724 << ArraySize->getSourceRange()
725 << FixItHint::CreateRemoval(TypeIdParens.getBegin())
726 << FixItHint::CreateRemoval(TypeIdParens.getEnd());
728 TypeIdParens = SourceRange();
732 ImpCastExprToType(ArraySize, Context.getSizeType(),
733 CastExpr::CK_IntegralCast);
736 FunctionDecl *OperatorNew = 0;
737 FunctionDecl *OperatorDelete = 0;
738 Expr **PlaceArgs = (Expr**)PlacementArgs.get();
739 unsigned NumPlaceArgs = PlacementArgs.size();
741 if (!AllocType->isDependentType() &&
742 !Expr::hasAnyTypeDependentArguments(PlaceArgs, NumPlaceArgs) &&
743 FindAllocationFunctions(StartLoc,
744 SourceRange(PlacementLParen, PlacementRParen),
745 UseGlobal, AllocType, ArraySize, PlaceArgs,
746 NumPlaceArgs, OperatorNew, OperatorDelete))
748 llvm::SmallVector<Expr *, 8> AllPlaceArgs;
750 // Add default arguments, if any.
751 const FunctionProtoType *Proto =
752 OperatorNew->getType()->getAs<FunctionProtoType>();
753 VariadicCallType CallType =
754 Proto->isVariadic() ? VariadicFunction : VariadicDoesNotApply;
756 if (GatherArgumentsForCall(PlacementLParen, OperatorNew,
757 Proto, 1, PlaceArgs, NumPlaceArgs,
758 AllPlaceArgs, CallType))
761 NumPlaceArgs = AllPlaceArgs.size();
762 if (NumPlaceArgs > 0)
763 PlaceArgs = &AllPlaceArgs[0];
766 bool Init = ConstructorLParen.isValid();
767 // --- Choosing a constructor ---
768 CXXConstructorDecl *Constructor = 0;
769 Expr **ConsArgs = (Expr**)ConstructorArgs.get();
770 unsigned NumConsArgs = ConstructorArgs.size();
771 ASTOwningVector<&ActionBase::DeleteExpr> ConvertedConstructorArgs(*this);
773 // Array 'new' can't have any initializers.
774 if (NumConsArgs && (ResultType->isArrayType() || ArraySize)) {
775 SourceRange InitRange(ConsArgs[0]->getLocStart(),
776 ConsArgs[NumConsArgs - 1]->getLocEnd());
778 Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
782 if (!AllocType->isDependentType() &&
783 !Expr::hasAnyTypeDependentArguments(ConsArgs, NumConsArgs)) {
784 // C++0x [expr.new]p15:
785 // A new-expression that creates an object of type T initializes that
786 // object as follows:
787 InitializationKind Kind
788 // - If the new-initializer is omitted, the object is default-
789 // initialized (8.5); if no initialization is performed,
790 // the object has indeterminate value
791 = !Init? InitializationKind::CreateDefault(TypeLoc)
792 // - Otherwise, the new-initializer is interpreted according to the
793 // initialization rules of 8.5 for direct-initialization.
794 : InitializationKind::CreateDirect(TypeLoc,
798 InitializedEntity Entity
799 = InitializedEntity::InitializeNew(StartLoc, AllocType);
800 InitializationSequence InitSeq(*this, Entity, Kind, ConsArgs, NumConsArgs);
801 OwningExprResult FullInit = InitSeq.Perform(*this, Entity, Kind,
802 move(ConstructorArgs));
803 if (FullInit.isInvalid())
806 // FullInit is our initializer; walk through it to determine if it's a
807 // constructor call, which CXXNewExpr handles directly.
808 if (Expr *FullInitExpr = (Expr *)FullInit.get()) {
809 if (CXXBindTemporaryExpr *Binder
810 = dyn_cast<CXXBindTemporaryExpr>(FullInitExpr))
811 FullInitExpr = Binder->getSubExpr();
812 if (CXXConstructExpr *Construct
813 = dyn_cast<CXXConstructExpr>(FullInitExpr)) {
814 Constructor = Construct->getConstructor();
815 for (CXXConstructExpr::arg_iterator A = Construct->arg_begin(),
816 AEnd = Construct->arg_end();
818 ConvertedConstructorArgs.push_back(A->Retain());
820 // Take the converted initializer.
821 ConvertedConstructorArgs.push_back(FullInit.release());
824 // No initialization required.
827 // Take the converted arguments and use them for the new expression.
828 NumConsArgs = ConvertedConstructorArgs.size();
829 ConsArgs = (Expr **)ConvertedConstructorArgs.take();
832 // Mark the new and delete operators as referenced.
834 MarkDeclarationReferenced(StartLoc, OperatorNew);
836 MarkDeclarationReferenced(StartLoc, OperatorDelete);
838 // FIXME: Also check that the destructor is accessible. (C++ 5.3.4p16)
840 PlacementArgs.release();
841 ConstructorArgs.release();
842 ArraySizeE.release();
844 // FIXME: The TypeSourceInfo should also be included in CXXNewExpr.
845 return Owned(new (Context) CXXNewExpr(Context, UseGlobal, OperatorNew,
846 PlaceArgs, NumPlaceArgs, TypeIdParens,
847 ArraySize, Constructor, Init,
848 ConsArgs, NumConsArgs, OperatorDelete,
849 ResultType, StartLoc,
850 Init ? ConstructorRParen :
851 TypeRange.getEnd()));
854 /// CheckAllocatedType - Checks that a type is suitable as the allocated type
855 /// in a new-expression.
856 /// dimension off and stores the size expression in ArraySize.
857 bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc,
859 // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an
860 // abstract class type or array thereof.
861 if (AllocType->isFunctionType())
862 return Diag(Loc, diag::err_bad_new_type)
863 << AllocType << 0 << R;
864 else if (AllocType->isReferenceType())
865 return Diag(Loc, diag::err_bad_new_type)
866 << AllocType << 1 << R;
867 else if (!AllocType->isDependentType() &&
868 RequireCompleteType(Loc, AllocType,
869 PDiag(diag::err_new_incomplete_type)
872 else if (RequireNonAbstractType(Loc, AllocType,
873 diag::err_allocation_of_abstract_type))
879 /// \brief Determine whether the given function is a non-placement
880 /// deallocation function.
881 static bool isNonPlacementDeallocationFunction(FunctionDecl *FD) {
882 if (FD->isInvalidDecl())
885 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
886 return Method->isUsualDeallocationFunction();
888 return ((FD->getOverloadedOperator() == OO_Delete ||
889 FD->getOverloadedOperator() == OO_Array_Delete) &&
890 FD->getNumParams() == 1);
893 /// FindAllocationFunctions - Finds the overloads of operator new and delete
894 /// that are appropriate for the allocation.
895 bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
896 bool UseGlobal, QualType AllocType,
897 bool IsArray, Expr **PlaceArgs,
898 unsigned NumPlaceArgs,
899 FunctionDecl *&OperatorNew,
900 FunctionDecl *&OperatorDelete) {
901 // --- Choosing an allocation function ---
902 // C++ 5.3.4p8 - 14 & 18
903 // 1) If UseGlobal is true, only look in the global scope. Else, also look
904 // in the scope of the allocated class.
905 // 2) If an array size is given, look for operator new[], else look for
907 // 3) The first argument is always size_t. Append the arguments from the
910 llvm::SmallVector<Expr*, 8> AllocArgs(1 + NumPlaceArgs);
911 // We don't care about the actual value of this argument.
912 // FIXME: Should the Sema create the expression and embed it in the syntax
913 // tree? Or should the consumer just recalculate the value?
914 IntegerLiteral Size(llvm::APInt::getNullValue(
915 Context.Target.getPointerWidth(0)),
916 Context.getSizeType(),
918 AllocArgs[0] = &Size;
919 std::copy(PlaceArgs, PlaceArgs + NumPlaceArgs, AllocArgs.begin() + 1);
922 // If the allocated type is a non-array type, the allocation
923 // function’s name is operator new and the deallocation function’s
924 // name is operator delete. If the allocated type is an array
925 // type, the allocation function’s name is operator new[] and the
926 // deallocation function’s name is operator delete[].
927 DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName(
928 IsArray ? OO_Array_New : OO_New);
929 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
930 IsArray ? OO_Array_Delete : OO_Delete);
932 if (AllocType->isRecordType() && !UseGlobal) {
933 CXXRecordDecl *Record
934 = cast<CXXRecordDecl>(AllocType->getAs<RecordType>()->getDecl());
935 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0],
936 AllocArgs.size(), Record, /*AllowMissing=*/true,
941 // Didn't find a member overload. Look for a global one.
942 DeclareGlobalNewDelete();
943 DeclContext *TUDecl = Context.getTranslationUnitDecl();
944 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0],
945 AllocArgs.size(), TUDecl, /*AllowMissing=*/false,
950 // We don't need an operator delete if we're running under
952 if (!getLangOptions().Exceptions) {
957 // FindAllocationOverload can change the passed in arguments, so we need to
959 if (NumPlaceArgs > 0)
960 std::copy(&AllocArgs[1], AllocArgs.end(), PlaceArgs);
962 // C++ [expr.new]p19:
964 // If the new-expression begins with a unary :: operator, the
965 // deallocation function’s name is looked up in the global
966 // scope. Otherwise, if the allocated type is a class type T or an
967 // array thereof, the deallocation function’s name is looked up in
968 // the scope of T. If this lookup fails to find the name, or if
969 // the allocated type is not a class type or array thereof, the
970 // deallocation function’s name is looked up in the global scope.
971 LookupResult FoundDelete(*this, DeleteName, StartLoc, LookupOrdinaryName);
972 if (AllocType->isRecordType() && !UseGlobal) {
974 = cast<CXXRecordDecl>(AllocType->getAs<RecordType>()->getDecl());
975 LookupQualifiedName(FoundDelete, RD);
977 if (FoundDelete.isAmbiguous())
978 return true; // FIXME: clean up expressions?
980 if (FoundDelete.empty()) {
981 DeclareGlobalNewDelete();
982 LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl());
985 FoundDelete.suppressDiagnostics();
987 llvm::SmallVector<std::pair<DeclAccessPair,FunctionDecl*>, 2> Matches;
989 if (NumPlaceArgs > 0) {
990 // C++ [expr.new]p20:
991 // A declaration of a placement deallocation function matches the
992 // declaration of a placement allocation function if it has the
993 // same number of parameters and, after parameter transformations
994 // (8.3.5), all parameter types except the first are
997 // To perform this comparison, we compute the function type that
998 // the deallocation function should have, and use that type both
999 // for template argument deduction and for comparison purposes.
1000 QualType ExpectedFunctionType;
1002 const FunctionProtoType *Proto
1003 = OperatorNew->getType()->getAs<FunctionProtoType>();
1004 llvm::SmallVector<QualType, 4> ArgTypes;
1005 ArgTypes.push_back(Context.VoidPtrTy);
1006 for (unsigned I = 1, N = Proto->getNumArgs(); I < N; ++I)
1007 ArgTypes.push_back(Proto->getArgType(I));
1009 ExpectedFunctionType
1010 = Context.getFunctionType(Context.VoidTy, ArgTypes.data(),
1012 Proto->isVariadic(),
1013 0, false, false, 0, 0,
1014 FunctionType::ExtInfo());
1017 for (LookupResult::iterator D = FoundDelete.begin(),
1018 DEnd = FoundDelete.end();
1020 FunctionDecl *Fn = 0;
1021 if (FunctionTemplateDecl *FnTmpl
1022 = dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) {
1023 // Perform template argument deduction to try to match the
1024 // expected function type.
1025 TemplateDeductionInfo Info(Context, StartLoc);
1026 if (DeduceTemplateArguments(FnTmpl, 0, ExpectedFunctionType, Fn, Info))
1029 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl());
1031 if (Context.hasSameType(Fn->getType(), ExpectedFunctionType))
1032 Matches.push_back(std::make_pair(D.getPair(), Fn));
1035 // C++ [expr.new]p20:
1036 // [...] Any non-placement deallocation function matches a
1037 // non-placement allocation function. [...]
1038 for (LookupResult::iterator D = FoundDelete.begin(),
1039 DEnd = FoundDelete.end();
1041 if (FunctionDecl *Fn = dyn_cast<FunctionDecl>((*D)->getUnderlyingDecl()))
1042 if (isNonPlacementDeallocationFunction(Fn))
1043 Matches.push_back(std::make_pair(D.getPair(), Fn));
1047 // C++ [expr.new]p20:
1048 // [...] If the lookup finds a single matching deallocation
1049 // function, that function will be called; otherwise, no
1050 // deallocation function will be called.
1051 if (Matches.size() == 1) {
1052 OperatorDelete = Matches[0].second;
1054 // C++0x [expr.new]p20:
1055 // If the lookup finds the two-parameter form of a usual
1056 // deallocation function (3.7.4.2) and that function, considered
1057 // as a placement deallocation function, would have been
1058 // selected as a match for the allocation function, the program
1060 if (NumPlaceArgs && getLangOptions().CPlusPlus0x &&
1061 isNonPlacementDeallocationFunction(OperatorDelete)) {
1062 Diag(StartLoc, diag::err_placement_new_non_placement_delete)
1063 << SourceRange(PlaceArgs[0]->getLocStart(),
1064 PlaceArgs[NumPlaceArgs - 1]->getLocEnd());
1065 Diag(OperatorDelete->getLocation(), diag::note_previous_decl)
1068 CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(),
1076 /// FindAllocationOverload - Find an fitting overload for the allocation
1077 /// function in the specified scope.
1078 bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
1079 DeclarationName Name, Expr** Args,
1080 unsigned NumArgs, DeclContext *Ctx,
1081 bool AllowMissing, FunctionDecl *&Operator) {
1082 LookupResult R(*this, Name, StartLoc, LookupOrdinaryName);
1083 LookupQualifiedName(R, Ctx);
1087 return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
1091 if (R.isAmbiguous())
1094 R.suppressDiagnostics();
1096 OverloadCandidateSet Candidates(StartLoc);
1097 for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end();
1098 Alloc != AllocEnd; ++Alloc) {
1099 // Even member operator new/delete are implicitly treated as
1100 // static, so don't use AddMemberCandidate.
1101 NamedDecl *D = (*Alloc)->getUnderlyingDecl();
1103 if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
1104 AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(),
1105 /*ExplicitTemplateArgs=*/0, Args, NumArgs,
1107 /*SuppressUserConversions=*/false);
1111 FunctionDecl *Fn = cast<FunctionDecl>(D);
1112 AddOverloadCandidate(Fn, Alloc.getPair(), Args, NumArgs, Candidates,
1113 /*SuppressUserConversions=*/false);
1116 // Do the resolution.
1117 OverloadCandidateSet::iterator Best;
1118 switch(BestViableFunction(Candidates, StartLoc, Best)) {
1121 FunctionDecl *FnDecl = Best->Function;
1122 // The first argument is size_t, and the first parameter must be size_t,
1123 // too. This is checked on declaration and can be assumed. (It can't be
1124 // asserted on, though, since invalid decls are left in there.)
1125 // Watch out for variadic allocator function.
1126 unsigned NumArgsInFnDecl = FnDecl->getNumParams();
1127 for (unsigned i = 0; (i < NumArgs && i < NumArgsInFnDecl); ++i) {
1128 OwningExprResult Result
1129 = PerformCopyInitialization(InitializedEntity::InitializeParameter(
1130 FnDecl->getParamDecl(i)),
1132 Owned(Args[i]->Retain()));
1133 if (Result.isInvalid())
1136 Args[i] = Result.takeAs<Expr>();
1139 CheckAllocationAccess(StartLoc, Range, R.getNamingClass(), Best->FoundDecl);
1143 case OR_No_Viable_Function:
1144 Diag(StartLoc, diag::err_ovl_no_viable_function_in_call)
1146 PrintOverloadCandidates(Candidates, OCD_AllCandidates, Args, NumArgs);
1150 Diag(StartLoc, diag::err_ovl_ambiguous_call)
1152 PrintOverloadCandidates(Candidates, OCD_ViableCandidates, Args, NumArgs);
1156 Diag(StartLoc, diag::err_ovl_deleted_call)
1157 << Best->Function->isDeleted()
1159 PrintOverloadCandidates(Candidates, OCD_AllCandidates, Args, NumArgs);
1162 assert(false && "Unreachable, bad result from BestViableFunction");
1167 /// DeclareGlobalNewDelete - Declare the global forms of operator new and
1168 /// delete. These are:
1170 /// void* operator new(std::size_t) throw(std::bad_alloc);
1171 /// void* operator new[](std::size_t) throw(std::bad_alloc);
1172 /// void operator delete(void *) throw();
1173 /// void operator delete[](void *) throw();
1175 /// Note that the placement and nothrow forms of new are *not* implicitly
1176 /// declared. Their use requires including \<new\>.
1177 void Sema::DeclareGlobalNewDelete() {
1178 if (GlobalNewDeleteDeclared)
1181 // C++ [basic.std.dynamic]p2:
1182 // [...] The following allocation and deallocation functions (18.4) are
1183 // implicitly declared in global scope in each translation unit of a
1186 // void* operator new(std::size_t) throw(std::bad_alloc);
1187 // void* operator new[](std::size_t) throw(std::bad_alloc);
1188 // void operator delete(void*) throw();
1189 // void operator delete[](void*) throw();
1191 // These implicit declarations introduce only the function names operator
1192 // new, operator new[], operator delete, operator delete[].
1194 // Here, we need to refer to std::bad_alloc, so we will implicitly declare
1195 // "std" or "bad_alloc" as necessary to form the exception specification.
1196 // However, we do not make these implicit declarations visible to name
1199 // The "std::bad_alloc" class has not yet been declared, so build it
1201 StdBadAlloc = CXXRecordDecl::Create(Context, TTK_Class,
1204 &PP.getIdentifierTable().get("bad_alloc"),
1205 SourceLocation(), 0);
1206 StdBadAlloc->setImplicit(true);
1209 GlobalNewDeleteDeclared = true;
1211 QualType VoidPtr = Context.getPointerType(Context.VoidTy);
1212 QualType SizeT = Context.getSizeType();
1213 bool AssumeSaneOperatorNew = getLangOptions().AssumeSaneOperatorNew;
1215 DeclareGlobalAllocationFunction(
1216 Context.DeclarationNames.getCXXOperatorName(OO_New),
1217 VoidPtr, SizeT, AssumeSaneOperatorNew);
1218 DeclareGlobalAllocationFunction(
1219 Context.DeclarationNames.getCXXOperatorName(OO_Array_New),
1220 VoidPtr, SizeT, AssumeSaneOperatorNew);
1221 DeclareGlobalAllocationFunction(
1222 Context.DeclarationNames.getCXXOperatorName(OO_Delete),
1223 Context.VoidTy, VoidPtr);
1224 DeclareGlobalAllocationFunction(
1225 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete),
1226 Context.VoidTy, VoidPtr);
1229 /// DeclareGlobalAllocationFunction - Declares a single implicit global
1230 /// allocation function if it doesn't already exist.
1231 void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
1232 QualType Return, QualType Argument,
1233 bool AddMallocAttr) {
1234 DeclContext *GlobalCtx = Context.getTranslationUnitDecl();
1236 // Check if this function is already declared.
1238 DeclContext::lookup_iterator Alloc, AllocEnd;
1239 for (llvm::tie(Alloc, AllocEnd) = GlobalCtx->lookup(Name);
1240 Alloc != AllocEnd; ++Alloc) {
1241 // Only look at non-template functions, as it is the predefined,
1242 // non-templated allocation function we are trying to declare here.
1243 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) {
1244 QualType InitialParamType =
1245 Context.getCanonicalType(
1246 Func->getParamDecl(0)->getType().getUnqualifiedType());
1247 // FIXME: Do we need to check for default arguments here?
1248 if (Func->getNumParams() == 1 && InitialParamType == Argument)
1254 QualType BadAllocType;
1255 bool HasBadAllocExceptionSpec
1256 = (Name.getCXXOverloadedOperator() == OO_New ||
1257 Name.getCXXOverloadedOperator() == OO_Array_New);
1258 if (HasBadAllocExceptionSpec) {
1259 assert(StdBadAlloc && "Must have std::bad_alloc declared");
1260 BadAllocType = Context.getTypeDeclType(StdBadAlloc);
1263 QualType FnType = Context.getFunctionType(Return, &Argument, 1, false, 0,
1265 HasBadAllocExceptionSpec? 1 : 0,
1267 FunctionType::ExtInfo());
1268 FunctionDecl *Alloc =
1269 FunctionDecl::Create(Context, GlobalCtx, SourceLocation(), Name,
1270 FnType, /*TInfo=*/0, FunctionDecl::None,
1271 FunctionDecl::None, false, true);
1272 Alloc->setImplicit();
1275 Alloc->addAttr(::new (Context) MallocAttr());
1277 ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(),
1278 0, Argument, /*TInfo=*/0,
1281 Alloc->setParams(&Param, 1);
1283 // FIXME: Also add this declaration to the IdentifierResolver, but
1284 // make sure it is at the end of the chain to coincide with the
1286 ((DeclContext *)TUScope->getEntity())->addDecl(Alloc);
1289 bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
1290 DeclarationName Name,
1291 FunctionDecl* &Operator) {
1292 LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName);
1293 // Try to find operator delete/operator delete[] in class scope.
1294 LookupQualifiedName(Found, RD);
1296 if (Found.isAmbiguous())
1299 Found.suppressDiagnostics();
1301 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
1303 if (CXXMethodDecl *Delete = dyn_cast<CXXMethodDecl>(*F))
1304 if (Delete->isUsualDeallocationFunction()) {
1306 CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(),
1312 // We did find operator delete/operator delete[] declarations, but
1313 // none of them were suitable.
1314 if (!Found.empty()) {
1315 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found)
1318 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end();
1320 Diag((*F)->getLocation(), diag::note_member_declared_here)
1327 // Look for a global declaration.
1328 DeclareGlobalNewDelete();
1329 DeclContext *TUDecl = Context.getTranslationUnitDecl();
1331 CXXNullPtrLiteralExpr Null(Context.VoidPtrTy, SourceLocation());
1332 Expr* DeallocArgs[1];
1333 DeallocArgs[0] = &Null;
1334 if (FindAllocationOverload(StartLoc, SourceRange(), Name,
1335 DeallocArgs, 1, TUDecl, /*AllowMissing=*/false,
1339 assert(Operator && "Did not find a deallocation function!");
1343 /// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
1344 /// @code ::delete ptr; @endcode
1346 /// @code delete [] ptr; @endcode
1347 Action::OwningExprResult
1348 Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
1349 bool ArrayForm, ExprArg Operand) {
1350 // C++ [expr.delete]p1:
1351 // The operand shall have a pointer type, or a class type having a single
1352 // conversion function to a pointer type. The result has type void.
1354 // DR599 amends "pointer type" to "pointer to object type" in both cases.
1356 FunctionDecl *OperatorDelete = 0;
1358 Expr *Ex = (Expr *)Operand.get();
1359 if (!Ex->isTypeDependent()) {
1360 QualType Type = Ex->getType();
1362 if (const RecordType *Record = Type->getAs<RecordType>()) {
1363 llvm::SmallVector<CXXConversionDecl*, 4> ObjectPtrConversions;
1365 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
1366 const UnresolvedSetImpl *Conversions = RD->getVisibleConversionFunctions();
1367 for (UnresolvedSetImpl::iterator I = Conversions->begin(),
1368 E = Conversions->end(); I != E; ++I) {
1369 NamedDecl *D = I.getDecl();
1370 if (isa<UsingShadowDecl>(D))
1371 D = cast<UsingShadowDecl>(D)->getTargetDecl();
1373 // Skip over templated conversion functions; they aren't considered.
1374 if (isa<FunctionTemplateDecl>(D))
1377 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
1379 QualType ConvType = Conv->getConversionType().getNonReferenceType();
1380 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
1381 if (ConvPtrType->getPointeeType()->isObjectType())
1382 ObjectPtrConversions.push_back(Conv);
1384 if (ObjectPtrConversions.size() == 1) {
1385 // We have a single conversion to a pointer-to-object type. Perform
1387 // TODO: don't redo the conversion calculation.
1389 if (!PerformImplicitConversion(Ex,
1390 ObjectPtrConversions.front()->getConversionType(),
1392 Operand = Owned(Ex);
1393 Type = Ex->getType();
1396 else if (ObjectPtrConversions.size() > 1) {
1397 Diag(StartLoc, diag::err_ambiguous_delete_operand)
1398 << Type << Ex->getSourceRange();
1399 for (unsigned i= 0; i < ObjectPtrConversions.size(); i++)
1400 NoteOverloadCandidate(ObjectPtrConversions[i]);
1405 if (!Type->isPointerType())
1406 return ExprError(Diag(StartLoc, diag::err_delete_operand)
1407 << Type << Ex->getSourceRange());
1409 QualType Pointee = Type->getAs<PointerType>()->getPointeeType();
1410 if (Pointee->isVoidType() && !isSFINAEContext()) {
1411 // The C++ standard bans deleting a pointer to a non-object type, which
1412 // effectively bans deletion of "void*". However, most compilers support
1413 // this, so we treat it as a warning unless we're in a SFINAE context.
1414 Diag(StartLoc, diag::ext_delete_void_ptr_operand)
1415 << Type << Ex->getSourceRange();
1416 } else if (Pointee->isFunctionType() || Pointee->isVoidType())
1417 return ExprError(Diag(StartLoc, diag::err_delete_operand)
1418 << Type << Ex->getSourceRange());
1419 else if (!Pointee->isDependentType() &&
1420 RequireCompleteType(StartLoc, Pointee,
1421 PDiag(diag::warn_delete_incomplete)
1422 << Ex->getSourceRange()))
1425 // C++ [expr.delete]p2:
1426 // [Note: a pointer to a const type can be the operand of a
1427 // delete-expression; it is not necessary to cast away the constness
1428 // (5.2.11) of the pointer expression before it is used as the operand
1429 // of the delete-expression. ]
1430 ImpCastExprToType(Ex, Context.getPointerType(Context.VoidTy),
1433 // Update the operand.
1435 Operand = ExprArg(*this, Ex);
1437 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
1438 ArrayForm ? OO_Array_Delete : OO_Delete);
1440 if (const RecordType *RT = Pointee->getAs<RecordType>()) {
1441 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1444 FindDeallocationFunction(StartLoc, RD, DeleteName, OperatorDelete))
1447 if (!RD->hasTrivialDestructor())
1448 if (const CXXDestructorDecl *Dtor = LookupDestructor(RD))
1449 MarkDeclarationReferenced(StartLoc,
1450 const_cast<CXXDestructorDecl*>(Dtor));
1453 if (!OperatorDelete) {
1454 // Look for a global declaration.
1455 DeclareGlobalNewDelete();
1456 DeclContext *TUDecl = Context.getTranslationUnitDecl();
1457 if (FindAllocationOverload(StartLoc, SourceRange(), DeleteName,
1458 &Ex, 1, TUDecl, /*AllowMissing=*/false,
1463 MarkDeclarationReferenced(StartLoc, OperatorDelete);
1465 // FIXME: Check access and ambiguity of operator delete and destructor.
1469 return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm,
1470 OperatorDelete, Ex, StartLoc));
1473 /// \brief Check the use of the given variable as a C++ condition in an if,
1474 /// while, do-while, or switch statement.
1475 Action::OwningExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar,
1476 SourceLocation StmtLoc,
1477 bool ConvertToBoolean) {
1478 QualType T = ConditionVar->getType();
1480 // C++ [stmt.select]p2:
1481 // The declarator shall not specify a function or an array.
1482 if (T->isFunctionType())
1483 return ExprError(Diag(ConditionVar->getLocation(),
1484 diag::err_invalid_use_of_function_type)
1485 << ConditionVar->getSourceRange());
1486 else if (T->isArrayType())
1487 return ExprError(Diag(ConditionVar->getLocation(),
1488 diag::err_invalid_use_of_array_type)
1489 << ConditionVar->getSourceRange());
1491 Expr *Condition = DeclRefExpr::Create(Context, 0, SourceRange(), ConditionVar,
1492 ConditionVar->getLocation(),
1493 ConditionVar->getType().getNonReferenceType());
1494 if (ConvertToBoolean && CheckBooleanCondition(Condition, StmtLoc)) {
1495 Condition->Destroy(Context);
1499 return Owned(Condition);
1502 /// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid.
1503 bool Sema::CheckCXXBooleanCondition(Expr *&CondExpr) {
1505 // The value of a condition that is an initialized declaration in a statement
1506 // other than a switch statement is the value of the declared variable
1507 // implicitly converted to type bool. If that conversion is ill-formed, the
1508 // program is ill-formed.
1509 // The value of a condition that is an expression is the value of the
1510 // expression, implicitly converted to bool.
1512 return PerformContextuallyConvertToBool(CondExpr);
1515 /// Helper function to determine whether this is the (deprecated) C++
1516 /// conversion from a string literal to a pointer to non-const char or
1517 /// non-const wchar_t (for narrow and wide string literals,
1520 Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) {
1521 // Look inside the implicit cast, if it exists.
1522 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From))
1523 From = Cast->getSubExpr();
1525 // A string literal (2.13.4) that is not a wide string literal can
1526 // be converted to an rvalue of type "pointer to char"; a wide
1527 // string literal can be converted to an rvalue of type "pointer
1528 // to wchar_t" (C++ 4.2p2).
1529 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From->IgnoreParens()))
1530 if (const PointerType *ToPtrType = ToType->getAs<PointerType>())
1531 if (const BuiltinType *ToPointeeType
1532 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) {
1533 // This conversion is considered only when there is an
1534 // explicit appropriate pointer target type (C++ 4.2p2).
1535 if (!ToPtrType->getPointeeType().hasQualifiers() &&
1536 ((StrLit->isWide() && ToPointeeType->isWideCharType()) ||
1537 (!StrLit->isWide() &&
1538 (ToPointeeType->getKind() == BuiltinType::Char_U ||
1539 ToPointeeType->getKind() == BuiltinType::Char_S))))
1546 static Sema::OwningExprResult BuildCXXCastArgument(Sema &S,
1547 SourceLocation CastLoc,
1549 CastExpr::CastKind Kind,
1550 CXXMethodDecl *Method,
1551 Sema::ExprArg Arg) {
1552 Expr *From = Arg.takeAs<Expr>();
1555 default: assert(0 && "Unhandled cast kind!");
1556 case CastExpr::CK_ConstructorConversion: {
1557 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(S);
1559 if (S.CompleteConstructorCall(cast<CXXConstructorDecl>(Method),
1560 Sema::MultiExprArg(S, (void **)&From, 1),
1561 CastLoc, ConstructorArgs))
1562 return S.ExprError();
1564 Sema::OwningExprResult Result =
1565 S.BuildCXXConstructExpr(CastLoc, Ty, cast<CXXConstructorDecl>(Method),
1566 move_arg(ConstructorArgs));
1567 if (Result.isInvalid())
1568 return S.ExprError();
1570 return S.MaybeBindToTemporary(Result.takeAs<Expr>());
1573 case CastExpr::CK_UserDefinedConversion: {
1574 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!");
1576 // Create an implicit call expr that calls it.
1577 // FIXME: pass the FoundDecl for the user-defined conversion here
1578 CXXMemberCallExpr *CE = S.BuildCXXMemberCallExpr(From, Method, Method);
1579 return S.MaybeBindToTemporary(CE);
1584 /// PerformImplicitConversion - Perform an implicit conversion of the
1585 /// expression From to the type ToType using the pre-computed implicit
1586 /// conversion sequence ICS. Returns true if there was an error, false
1587 /// otherwise. The expression From is replaced with the converted
1588 /// expression. Action is the kind of conversion we're performing,
1589 /// used in the error message.
1591 Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
1592 const ImplicitConversionSequence &ICS,
1593 AssignmentAction Action, bool IgnoreBaseAccess) {
1594 switch (ICS.getKind()) {
1595 case ImplicitConversionSequence::StandardConversion:
1596 if (PerformImplicitConversion(From, ToType, ICS.Standard, Action,
1601 case ImplicitConversionSequence::UserDefinedConversion: {
1603 FunctionDecl *FD = ICS.UserDefined.ConversionFunction;
1604 CastExpr::CastKind CastKind = CastExpr::CK_Unknown;
1605 QualType BeforeToType;
1606 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) {
1607 CastKind = CastExpr::CK_UserDefinedConversion;
1609 // If the user-defined conversion is specified by a conversion function,
1610 // the initial standard conversion sequence converts the source type to
1611 // the implicit object parameter of the conversion function.
1612 BeforeToType = Context.getTagDeclType(Conv->getParent());
1613 } else if (const CXXConstructorDecl *Ctor =
1614 dyn_cast<CXXConstructorDecl>(FD)) {
1615 CastKind = CastExpr::CK_ConstructorConversion;
1616 // Do no conversion if dealing with ... for the first conversion.
1617 if (!ICS.UserDefined.EllipsisConversion) {
1618 // If the user-defined conversion is specified by a constructor, the
1619 // initial standard conversion sequence converts the source type to the
1620 // type required by the argument of the constructor
1621 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType();
1625 assert(0 && "Unknown conversion function kind!");
1626 // Whatch out for elipsis conversion.
1627 if (!ICS.UserDefined.EllipsisConversion) {
1628 if (PerformImplicitConversion(From, BeforeToType,
1629 ICS.UserDefined.Before, AA_Converting,
1634 OwningExprResult CastArg
1635 = BuildCXXCastArgument(*this,
1636 From->getLocStart(),
1637 ToType.getNonReferenceType(),
1638 CastKind, cast<CXXMethodDecl>(FD),
1641 if (CastArg.isInvalid())
1644 From = CastArg.takeAs<Expr>();
1646 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After,
1647 AA_Converting, IgnoreBaseAccess);
1650 case ImplicitConversionSequence::AmbiguousConversion:
1651 DiagnoseAmbiguousConversion(ICS, From->getExprLoc(),
1652 PDiag(diag::err_typecheck_ambiguous_condition)
1653 << From->getSourceRange());
1656 case ImplicitConversionSequence::EllipsisConversion:
1657 assert(false && "Cannot perform an ellipsis conversion");
1660 case ImplicitConversionSequence::BadConversion:
1664 // Everything went well.
1668 /// PerformImplicitConversion - Perform an implicit conversion of the
1669 /// expression From to the type ToType by following the standard
1670 /// conversion sequence SCS. Returns true if there was an error, false
1671 /// otherwise. The expression From is replaced with the converted
1672 /// expression. Flavor is the context in which we're performing this
1673 /// conversion, for use in error messages.
1675 Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
1676 const StandardConversionSequence& SCS,
1677 AssignmentAction Action, bool IgnoreBaseAccess) {
1678 // Overall FIXME: we are recomputing too many types here and doing far too
1679 // much extra work. What this means is that we need to keep track of more
1680 // information that is computed when we try the implicit conversion initially,
1681 // so that we don't need to recompute anything here.
1682 QualType FromType = From->getType();
1684 if (SCS.CopyConstructor) {
1685 // FIXME: When can ToType be a reference type?
1686 assert(!ToType->isReferenceType());
1687 if (SCS.Second == ICK_Derived_To_Base) {
1688 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
1689 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor),
1690 MultiExprArg(*this, (void **)&From, 1),
1691 /*FIXME:ConstructLoc*/SourceLocation(),
1694 OwningExprResult FromResult =
1695 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(),
1696 ToType, SCS.CopyConstructor,
1697 move_arg(ConstructorArgs));
1698 if (FromResult.isInvalid())
1700 From = FromResult.takeAs<Expr>();
1703 OwningExprResult FromResult =
1704 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(),
1705 ToType, SCS.CopyConstructor,
1706 MultiExprArg(*this, (void**)&From, 1));
1708 if (FromResult.isInvalid())
1711 From = FromResult.takeAs<Expr>();
1715 // Resolve overloaded function references.
1716 if (Context.hasSameType(FromType, Context.OverloadTy)) {
1717 DeclAccessPair Found;
1718 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType,
1723 if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin()))
1726 From = FixOverloadedFunctionReference(From, Found, Fn);
1727 FromType = From->getType();
1730 // Perform the first implicit conversion.
1731 switch (SCS.First) {
1733 case ICK_Lvalue_To_Rvalue:
1737 case ICK_Array_To_Pointer:
1738 FromType = Context.getArrayDecayedType(FromType);
1739 ImpCastExprToType(From, FromType, CastExpr::CK_ArrayToPointerDecay);
1742 case ICK_Function_To_Pointer:
1743 FromType = Context.getPointerType(FromType);
1744 ImpCastExprToType(From, FromType, CastExpr::CK_FunctionToPointerDecay);
1748 assert(false && "Improper first standard conversion");
1752 // Perform the second implicit conversion
1753 switch (SCS.Second) {
1755 // If both sides are functions (or pointers/references to them), there could
1756 // be incompatible exception declarations.
1757 if (CheckExceptionSpecCompatibility(From, ToType))
1759 // Nothing else to do.
1762 case ICK_NoReturn_Adjustment:
1763 // If both sides are functions (or pointers/references to them), there could
1764 // be incompatible exception declarations.
1765 if (CheckExceptionSpecCompatibility(From, ToType))
1768 ImpCastExprToType(From, Context.getNoReturnType(From->getType(), false),
1772 case ICK_Integral_Promotion:
1773 case ICK_Integral_Conversion:
1774 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralCast);
1777 case ICK_Floating_Promotion:
1778 case ICK_Floating_Conversion:
1779 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingCast);
1782 case ICK_Complex_Promotion:
1783 case ICK_Complex_Conversion:
1784 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown);
1787 case ICK_Floating_Integral:
1788 if (ToType->isRealFloatingType())
1789 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralToFloating);
1791 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingToIntegral);
1794 case ICK_Compatible_Conversion:
1795 ImpCastExprToType(From, ToType, CastExpr::CK_NoOp);
1798 case ICK_Pointer_Conversion: {
1799 if (SCS.IncompatibleObjC) {
1800 // Diagnose incompatible Objective-C conversions
1801 Diag(From->getSourceRange().getBegin(),
1802 diag::ext_typecheck_convert_incompatible_pointer)
1803 << From->getType() << ToType << Action
1804 << From->getSourceRange();
1808 CastExpr::CastKind Kind = CastExpr::CK_Unknown;
1809 CXXBaseSpecifierArray BasePath;
1810 if (CheckPointerConversion(From, ToType, Kind, BasePath, IgnoreBaseAccess))
1812 ImpCastExprToType(From, ToType, Kind, /*isLvalue=*/false, BasePath);
1816 case ICK_Pointer_Member: {
1817 CastExpr::CastKind Kind = CastExpr::CK_Unknown;
1818 CXXBaseSpecifierArray BasePath;
1819 if (CheckMemberPointerConversion(From, ToType, Kind, BasePath,
1822 if (CheckExceptionSpecCompatibility(From, ToType))
1824 ImpCastExprToType(From, ToType, Kind, /*isLvalue=*/false, BasePath);
1827 case ICK_Boolean_Conversion: {
1828 CastExpr::CastKind Kind = CastExpr::CK_Unknown;
1829 if (FromType->isMemberPointerType())
1830 Kind = CastExpr::CK_MemberPointerToBoolean;
1832 ImpCastExprToType(From, Context.BoolTy, Kind);
1836 case ICK_Derived_To_Base: {
1837 CXXBaseSpecifierArray BasePath;
1838 if (CheckDerivedToBaseConversion(From->getType(),
1839 ToType.getNonReferenceType(),
1840 From->getLocStart(),
1841 From->getSourceRange(),
1846 ImpCastExprToType(From, ToType.getNonReferenceType(),
1847 CastExpr::CK_DerivedToBase,
1848 /*isLvalue=*/(From->getType()->isRecordType() &&
1849 From->isLvalue(Context) == Expr::LV_Valid),
1854 case ICK_Vector_Conversion:
1855 ImpCastExprToType(From, ToType, CastExpr::CK_BitCast);
1858 case ICK_Vector_Splat:
1859 ImpCastExprToType(From, ToType, CastExpr::CK_VectorSplat);
1862 case ICK_Complex_Real:
1863 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown);
1866 case ICK_Lvalue_To_Rvalue:
1867 case ICK_Array_To_Pointer:
1868 case ICK_Function_To_Pointer:
1869 case ICK_Qualification:
1870 case ICK_Num_Conversion_Kinds:
1871 assert(false && "Improper second standard conversion");
1875 switch (SCS.Third) {
1880 case ICK_Qualification:
1881 // FIXME: Not sure about lvalue vs rvalue here in the presence of rvalue
1883 ImpCastExprToType(From, ToType.getNonLValueExprType(Context),
1884 CastExpr::CK_NoOp, ToType->isLValueReferenceType());
1886 if (SCS.DeprecatedStringLiteralToCharPtr)
1887 Diag(From->getLocStart(), diag::warn_deprecated_string_literal_conversion)
1888 << ToType.getNonReferenceType();
1893 assert(false && "Improper third standard conversion");
1900 Sema::OwningExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
1901 SourceLocation KWLoc,
1902 SourceLocation LParen,
1904 SourceLocation RParen) {
1905 QualType T = GetTypeFromParser(Ty);
1907 // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
1908 // all traits except __is_class, __is_enum and __is_union require a the type
1910 if (OTT != UTT_IsClass && OTT != UTT_IsEnum && OTT != UTT_IsUnion) {
1911 if (RequireCompleteType(KWLoc, T,
1912 diag::err_incomplete_type_used_in_type_trait_expr))
1916 // There is no point in eagerly computing the value. The traits are designed
1917 // to be used from type trait templates, so Ty will be a template parameter
1919 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, OTT, T,
1920 RParen, Context.BoolTy));
1923 QualType Sema::CheckPointerToMemberOperands(
1924 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isIndirect) {
1925 const char *OpSpelling = isIndirect ? "->*" : ".*";
1927 // The binary operator .* [p3: ->*] binds its second operand, which shall
1928 // be of type "pointer to member of T" (where T is a completely-defined
1929 // class type) [...]
1930 QualType RType = rex->getType();
1931 const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>();
1933 Diag(Loc, diag::err_bad_memptr_rhs)
1934 << OpSpelling << RType << rex->getSourceRange();
1938 QualType Class(MemPtr->getClass(), 0);
1940 if (RequireCompleteType(Loc, Class, diag::err_memptr_rhs_to_incomplete))
1944 // [...] to its first operand, which shall be of class T or of a class of
1945 // which T is an unambiguous and accessible base class. [p3: a pointer to
1947 QualType LType = lex->getType();
1949 if (const PointerType *Ptr = LType->getAs<PointerType>())
1950 LType = Ptr->getPointeeType().getNonReferenceType();
1952 Diag(Loc, diag::err_bad_memptr_lhs)
1953 << OpSpelling << 1 << LType
1954 << FixItHint::CreateReplacement(SourceRange(Loc), ".*");
1959 if (!Context.hasSameUnqualifiedType(Class, LType)) {
1960 // If we want to check the hierarchy, we need a complete type.
1961 if (RequireCompleteType(Loc, LType, PDiag(diag::err_bad_memptr_lhs)
1962 << OpSpelling << (int)isIndirect)) {
1965 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1966 /*DetectVirtual=*/false);
1967 // FIXME: Would it be useful to print full ambiguity paths, or is that
1969 if (!IsDerivedFrom(LType, Class, Paths) ||
1970 Paths.isAmbiguous(Context.getCanonicalType(Class))) {
1971 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
1972 << (int)isIndirect << lex->getType();
1975 // Cast LHS to type of use.
1976 QualType UseType = isIndirect ? Context.getPointerType(Class) : Class;
1977 bool isLValue = !isIndirect && lex->isLvalue(Context) == Expr::LV_Valid;
1979 CXXBaseSpecifierArray BasePath;
1980 BuildBasePathArray(Paths, BasePath);
1981 ImpCastExprToType(lex, UseType, CastExpr::CK_DerivedToBase, isLValue,
1985 if (isa<CXXScalarValueInitExpr>(rex->IgnoreParens())) {
1986 // Diagnose use of pointer-to-member type which when used as
1987 // the functional cast in a pointer-to-member expression.
1988 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect;
1992 // The result is an object or a function of the type specified by the
1994 // The cv qualifiers are the union of those in the pointer and the left side,
1995 // in accordance with 5.5p5 and 5.2.5.
1996 // FIXME: This returns a dereferenced member function pointer as a normal
1997 // function type. However, the only operation valid on such functions is
1998 // calling them. There's also a GCC extension to get a function pointer to the
1999 // thing, which is another complication, because this type - unlike the type
2000 // that is the result of this expression - takes the class as the first
2002 // We probably need a "MemberFunctionClosureType" or something like that.
2003 QualType Result = MemPtr->getPointeeType();
2004 Result = Context.getCVRQualifiedType(Result, LType.getCVRQualifiers());
2008 /// \brief Try to convert a type to another according to C++0x 5.16p3.
2010 /// This is part of the parameter validation for the ? operator. If either
2011 /// value operand is a class type, the two operands are attempted to be
2012 /// converted to each other. This function does the conversion in one direction.
2013 /// It returns true if the program is ill-formed and has already been diagnosed
2015 static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
2016 SourceLocation QuestionLoc,
2017 bool &HaveConversion,
2019 HaveConversion = false;
2020 ToType = To->getType();
2022 InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(),
2025 // The process for determining whether an operand expression E1 of type T1
2026 // can be converted to match an operand expression E2 of type T2 is defined
2028 // -- If E2 is an lvalue:
2029 bool ToIsLvalue = (To->isLvalue(Self.Context) == Expr::LV_Valid);
2031 // E1 can be converted to match E2 if E1 can be implicitly converted to
2032 // type "lvalue reference to T2", subject to the constraint that in the
2033 // conversion the reference must bind directly to E1.
2034 QualType T = Self.Context.getLValueReferenceType(ToType);
2035 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
2037 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1);
2038 if (InitSeq.isDirectReferenceBinding()) {
2040 HaveConversion = true;
2044 if (InitSeq.isAmbiguous())
2045 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1);
2048 // -- If E2 is an rvalue, or if the conversion above cannot be done:
2049 // -- if E1 and E2 have class type, and the underlying class types are
2050 // the same or one is a base class of the other:
2051 QualType FTy = From->getType();
2052 QualType TTy = To->getType();
2053 const RecordType *FRec = FTy->getAs<RecordType>();
2054 const RecordType *TRec = TTy->getAs<RecordType>();
2055 bool FDerivedFromT = FRec && TRec && FRec != TRec &&
2056 Self.IsDerivedFrom(FTy, TTy);
2058 (FRec == TRec || FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) {
2059 // E1 can be converted to match E2 if the class of T2 is the
2060 // same type as, or a base class of, the class of T1, and
2062 if (FRec == TRec || FDerivedFromT) {
2063 if (TTy.isAtLeastAsQualifiedAs(FTy)) {
2064 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
2065 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1);
2066 if (InitSeq.getKind() != InitializationSequence::FailedSequence) {
2067 HaveConversion = true;
2071 if (InitSeq.isAmbiguous())
2072 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1);
2079 // -- Otherwise: E1 can be converted to match E2 if E1 can be
2080 // implicitly converted to the type that expression E2 would have
2081 // if E2 were converted to an rvalue (or the type it has, if E2 is
2084 // This actually refers very narrowly to the lvalue-to-rvalue conversion, not
2085 // to the array-to-pointer or function-to-pointer conversions.
2086 if (!TTy->getAs<TagType>())
2087 TTy = TTy.getUnqualifiedType();
2089 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
2090 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1);
2091 HaveConversion = InitSeq.getKind() != InitializationSequence::FailedSequence;
2093 if (InitSeq.isAmbiguous())
2094 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1);
2099 /// \brief Try to find a common type for two according to C++0x 5.16p5.
2101 /// This is part of the parameter validation for the ? operator. If either
2102 /// value operand is a class type, overload resolution is used to find a
2103 /// conversion to a common type.
2104 static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS,
2105 SourceLocation Loc) {
2106 Expr *Args[2] = { LHS, RHS };
2107 OverloadCandidateSet CandidateSet(Loc);
2108 Self.AddBuiltinOperatorCandidates(OO_Conditional, Loc, Args, 2, CandidateSet);
2110 OverloadCandidateSet::iterator Best;
2111 switch (Self.BestViableFunction(CandidateSet, Loc, Best)) {
2113 // We found a match. Perform the conversions on the arguments and move on.
2114 if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0],
2115 Best->Conversions[0], Sema::AA_Converting) ||
2116 Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1],
2117 Best->Conversions[1], Sema::AA_Converting))
2121 case OR_No_Viable_Function:
2122 Self.Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
2123 << LHS->getType() << RHS->getType()
2124 << LHS->getSourceRange() << RHS->getSourceRange();
2128 Self.Diag(Loc, diag::err_conditional_ambiguous_ovl)
2129 << LHS->getType() << RHS->getType()
2130 << LHS->getSourceRange() << RHS->getSourceRange();
2131 // FIXME: Print the possible common types by printing the return types of
2132 // the viable candidates.
2136 assert(false && "Conditional operator has only built-in overloads");
2142 /// \brief Perform an "extended" implicit conversion as returned by
2143 /// TryClassUnification.
2144 static bool ConvertForConditional(Sema &Self, Expr *&E, QualType T) {
2145 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
2146 InitializationKind Kind = InitializationKind::CreateCopy(E->getLocStart(),
2148 InitializationSequence InitSeq(Self, Entity, Kind, &E, 1);
2149 Sema::OwningExprResult Result = InitSeq.Perform(Self, Entity, Kind,
2150 Sema::MultiExprArg(Self, (void **)&E, 1));
2151 if (Result.isInvalid())
2154 E = Result.takeAs<Expr>();
2158 /// \brief Check the operands of ?: under C++ semantics.
2160 /// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y
2161 /// extension. In this case, LHS == Cond. (But they're not aliases.)
2162 QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS,
2163 SourceLocation QuestionLoc) {
2164 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++
2165 // interface pointers.
2168 // The first expression is contextually converted to bool.
2169 if (!Cond->isTypeDependent()) {
2170 if (CheckCXXBooleanCondition(Cond))
2174 // Either of the arguments dependent?
2175 if (LHS->isTypeDependent() || RHS->isTypeDependent())
2176 return Context.DependentTy;
2179 // If either the second or the third operand has type (cv) void, ...
2180 QualType LTy = LHS->getType();
2181 QualType RTy = RHS->getType();
2182 bool LVoid = LTy->isVoidType();
2183 bool RVoid = RTy->isVoidType();
2184 if (LVoid || RVoid) {
2185 // ... then the [l2r] conversions are performed on the second and third
2187 DefaultFunctionArrayLvalueConversion(LHS);
2188 DefaultFunctionArrayLvalueConversion(RHS);
2189 LTy = LHS->getType();
2190 RTy = RHS->getType();
2192 // ... and one of the following shall hold:
2193 // -- The second or the third operand (but not both) is a throw-
2194 // expression; the result is of the type of the other and is an rvalue.
2195 bool LThrow = isa<CXXThrowExpr>(LHS);
2196 bool RThrow = isa<CXXThrowExpr>(RHS);
2197 if (LThrow && !RThrow)
2199 if (RThrow && !LThrow)
2202 // -- Both the second and third operands have type void; the result is of
2203 // type void and is an rvalue.
2205 return Context.VoidTy;
2207 // Neither holds, error.
2208 Diag(QuestionLoc, diag::err_conditional_void_nonvoid)
2209 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1)
2210 << LHS->getSourceRange() << RHS->getSourceRange();
2217 // Otherwise, if the second and third operand have different types, and
2218 // either has (cv) class type, and attempt is made to convert each of those
2219 // operands to the other.
2220 if (!Context.hasSameType(LTy, RTy) &&
2221 (LTy->isRecordType() || RTy->isRecordType())) {
2222 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft;
2223 // These return true if a single direction is already ambiguous.
2224 QualType L2RType, R2LType;
2225 bool HaveL2R, HaveR2L;
2226 if (TryClassUnification(*this, LHS, RHS, QuestionLoc, HaveL2R, L2RType))
2228 if (TryClassUnification(*this, RHS, LHS, QuestionLoc, HaveR2L, R2LType))
2231 // If both can be converted, [...] the program is ill-formed.
2232 if (HaveL2R && HaveR2L) {
2233 Diag(QuestionLoc, diag::err_conditional_ambiguous)
2234 << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange();
2238 // If exactly one conversion is possible, that conversion is applied to
2239 // the chosen operand and the converted operands are used in place of the
2240 // original operands for the remainder of this section.
2242 if (ConvertForConditional(*this, LHS, L2RType))
2244 LTy = LHS->getType();
2245 } else if (HaveR2L) {
2246 if (ConvertForConditional(*this, RHS, R2LType))
2248 RTy = RHS->getType();
2253 // If the second and third operands are lvalues and have the same type,
2254 // the result is of that type [...]
2255 bool Same = Context.hasSameType(LTy, RTy);
2256 if (Same && LHS->isLvalue(Context) == Expr::LV_Valid &&
2257 RHS->isLvalue(Context) == Expr::LV_Valid)
2261 // Otherwise, the result is an rvalue. If the second and third operands
2262 // do not have the same type, and either has (cv) class type, ...
2263 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) {
2264 // ... overload resolution is used to determine the conversions (if any)
2265 // to be applied to the operands. If the overload resolution fails, the
2266 // program is ill-formed.
2267 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc))
2272 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard
2273 // conversions are performed on the second and third operands.
2274 DefaultFunctionArrayLvalueConversion(LHS);
2275 DefaultFunctionArrayLvalueConversion(RHS);
2276 LTy = LHS->getType();
2277 RTy = RHS->getType();
2279 // After those conversions, one of the following shall hold:
2280 // -- The second and third operands have the same type; the result
2281 // is of that type. If the operands have class type, the result
2282 // is a prvalue temporary of the result type, which is
2283 // copy-initialized from either the second operand or the third
2284 // operand depending on the value of the first operand.
2285 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) {
2286 if (LTy->isRecordType()) {
2287 // The operands have class type. Make a temporary copy.
2288 InitializedEntity Entity = InitializedEntity::InitializeTemporary(LTy);
2289 OwningExprResult LHSCopy = PerformCopyInitialization(Entity,
2292 if (LHSCopy.isInvalid())
2295 OwningExprResult RHSCopy = PerformCopyInitialization(Entity,
2298 if (RHSCopy.isInvalid())
2301 LHS = LHSCopy.takeAs<Expr>();
2302 RHS = RHSCopy.takeAs<Expr>();
2308 // Extension: conditional operator involving vector types.
2309 if (LTy->isVectorType() || RTy->isVectorType())
2310 return CheckVectorOperands(QuestionLoc, LHS, RHS);
2312 // -- The second and third operands have arithmetic or enumeration type;
2313 // the usual arithmetic conversions are performed to bring them to a
2314 // common type, and the result is of that type.
2315 if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
2316 UsualArithmeticConversions(LHS, RHS);
2317 return LHS->getType();
2320 // -- The second and third operands have pointer type, or one has pointer
2321 // type and the other is a null pointer constant; pointer conversions
2322 // and qualification conversions are performed to bring them to their
2323 // composite pointer type. The result is of the composite pointer type.
2324 // -- The second and third operands have pointer to member type, or one has
2325 // pointer to member type and the other is a null pointer constant;
2326 // pointer to member conversions and qualification conversions are
2327 // performed to bring them to a common type, whose cv-qualification
2328 // shall match the cv-qualification of either the second or the third
2329 // operand. The result is of the common type.
2330 bool NonStandardCompositeType = false;
2331 QualType Composite = FindCompositePointerType(QuestionLoc, LHS, RHS,
2332 isSFINAEContext()? 0 : &NonStandardCompositeType);
2333 if (!Composite.isNull()) {
2334 if (NonStandardCompositeType)
2336 diag::ext_typecheck_cond_incompatible_operands_nonstandard)
2337 << LTy << RTy << Composite
2338 << LHS->getSourceRange() << RHS->getSourceRange();
2343 // Similarly, attempt to find composite type of two objective-c pointers.
2344 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc);
2345 if (!Composite.isNull())
2348 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
2349 << LHS->getType() << RHS->getType()
2350 << LHS->getSourceRange() << RHS->getSourceRange();
2354 /// \brief Find a merged pointer type and convert the two expressions to it.
2356 /// This finds the composite pointer type (or member pointer type) for @p E1
2357 /// and @p E2 according to C++0x 5.9p2. It converts both expressions to this
2358 /// type and returns it.
2359 /// It does not emit diagnostics.
2361 /// \param Loc The location of the operator requiring these two expressions to
2362 /// be converted to the composite pointer type.
2364 /// If \p NonStandardCompositeType is non-NULL, then we are permitted to find
2365 /// a non-standard (but still sane) composite type to which both expressions
2366 /// can be converted. When such a type is chosen, \c *NonStandardCompositeType
2367 /// will be set true.
2368 QualType Sema::FindCompositePointerType(SourceLocation Loc,
2369 Expr *&E1, Expr *&E2,
2370 bool *NonStandardCompositeType) {
2371 if (NonStandardCompositeType)
2372 *NonStandardCompositeType = false;
2374 assert(getLangOptions().CPlusPlus && "This function assumes C++");
2375 QualType T1 = E1->getType(), T2 = E2->getType();
2377 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() &&
2378 !T2->isAnyPointerType() && !T2->isMemberPointerType())
2382 // Pointer conversions and qualification conversions are performed on
2383 // pointer operands to bring them to their composite pointer type. If
2384 // one operand is a null pointer constant, the composite pointer type is
2385 // the type of the other operand.
2386 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
2387 if (T2->isMemberPointerType())
2388 ImpCastExprToType(E1, T2, CastExpr::CK_NullToMemberPointer);
2390 ImpCastExprToType(E1, T2, CastExpr::CK_IntegralToPointer);
2393 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
2394 if (T1->isMemberPointerType())
2395 ImpCastExprToType(E2, T1, CastExpr::CK_NullToMemberPointer);
2397 ImpCastExprToType(E2, T1, CastExpr::CK_IntegralToPointer);
2401 // Now both have to be pointers or member pointers.
2402 if ((!T1->isPointerType() && !T1->isMemberPointerType()) ||
2403 (!T2->isPointerType() && !T2->isMemberPointerType()))
2406 // Otherwise, of one of the operands has type "pointer to cv1 void," then
2407 // the other has type "pointer to cv2 T" and the composite pointer type is
2408 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2.
2409 // Otherwise, the composite pointer type is a pointer type similar to the
2410 // type of one of the operands, with a cv-qualification signature that is
2411 // the union of the cv-qualification signatures of the operand types.
2412 // In practice, the first part here is redundant; it's subsumed by the second.
2413 // What we do here is, we build the two possible composite types, and try the
2414 // conversions in both directions. If only one works, or if the two composite
2415 // types are the same, we have succeeded.
2416 // FIXME: extended qualifiers?
2417 typedef llvm::SmallVector<unsigned, 4> QualifierVector;
2418 QualifierVector QualifierUnion;
2419 typedef llvm::SmallVector<std::pair<const Type *, const Type *>, 4>
2420 ContainingClassVector;
2421 ContainingClassVector MemberOfClass;
2422 QualType Composite1 = Context.getCanonicalType(T1),
2423 Composite2 = Context.getCanonicalType(T2);
2424 unsigned NeedConstBefore = 0;
2426 const PointerType *Ptr1, *Ptr2;
2427 if ((Ptr1 = Composite1->getAs<PointerType>()) &&
2428 (Ptr2 = Composite2->getAs<PointerType>())) {
2429 Composite1 = Ptr1->getPointeeType();
2430 Composite2 = Ptr2->getPointeeType();
2432 // If we're allowed to create a non-standard composite type, keep track
2433 // of where we need to fill in additional 'const' qualifiers.
2434 if (NonStandardCompositeType &&
2435 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
2436 NeedConstBefore = QualifierUnion.size();
2438 QualifierUnion.push_back(
2439 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
2440 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0));
2444 const MemberPointerType *MemPtr1, *MemPtr2;
2445 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) &&
2446 (MemPtr2 = Composite2->getAs<MemberPointerType>())) {
2447 Composite1 = MemPtr1->getPointeeType();
2448 Composite2 = MemPtr2->getPointeeType();
2450 // If we're allowed to create a non-standard composite type, keep track
2451 // of where we need to fill in additional 'const' qualifiers.
2452 if (NonStandardCompositeType &&
2453 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers())
2454 NeedConstBefore = QualifierUnion.size();
2456 QualifierUnion.push_back(
2457 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers());
2458 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(),
2459 MemPtr2->getClass()));
2463 // FIXME: block pointer types?
2465 // Cannot unwrap any more types.
2469 if (NeedConstBefore && NonStandardCompositeType) {
2470 // Extension: Add 'const' to qualifiers that come before the first qualifier
2471 // mismatch, so that our (non-standard!) composite type meets the
2472 // requirements of C++ [conv.qual]p4 bullet 3.
2473 for (unsigned I = 0; I != NeedConstBefore; ++I) {
2474 if ((QualifierUnion[I] & Qualifiers::Const) == 0) {
2475 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const;
2476 *NonStandardCompositeType = true;
2481 // Rewrap the composites as pointers or member pointers with the union CVRs.
2482 ContainingClassVector::reverse_iterator MOC
2483 = MemberOfClass.rbegin();
2484 for (QualifierVector::reverse_iterator
2485 I = QualifierUnion.rbegin(),
2486 E = QualifierUnion.rend();
2487 I != E; (void)++I, ++MOC) {
2488 Qualifiers Quals = Qualifiers::fromCVRMask(*I);
2489 if (MOC->first && MOC->second) {
2490 // Rebuild member pointer type
2491 Composite1 = Context.getMemberPointerType(
2492 Context.getQualifiedType(Composite1, Quals),
2494 Composite2 = Context.getMemberPointerType(
2495 Context.getQualifiedType(Composite2, Quals),
2498 // Rebuild pointer type
2500 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals));
2502 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals));
2506 // Try to convert to the first composite pointer type.
2507 InitializedEntity Entity1
2508 = InitializedEntity::InitializeTemporary(Composite1);
2509 InitializationKind Kind
2510 = InitializationKind::CreateCopy(Loc, SourceLocation());
2511 InitializationSequence E1ToC1(*this, Entity1, Kind, &E1, 1);
2512 InitializationSequence E2ToC1(*this, Entity1, Kind, &E2, 1);
2514 if (E1ToC1 && E2ToC1) {
2515 // Conversion to Composite1 is viable.
2516 if (!Context.hasSameType(Composite1, Composite2)) {
2517 // Composite2 is a different type from Composite1. Check whether
2518 // Composite2 is also viable.
2519 InitializedEntity Entity2
2520 = InitializedEntity::InitializeTemporary(Composite2);
2521 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1);
2522 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1);
2523 if (E1ToC2 && E2ToC2) {
2524 // Both Composite1 and Composite2 are viable and are different;
2525 // this is an ambiguity.
2530 // Convert E1 to Composite1
2531 OwningExprResult E1Result
2532 = E1ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,(void**)&E1,1));
2533 if (E1Result.isInvalid())
2535 E1 = E1Result.takeAs<Expr>();
2537 // Convert E2 to Composite1
2538 OwningExprResult E2Result
2539 = E2ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,(void**)&E2,1));
2540 if (E2Result.isInvalid())
2542 E2 = E2Result.takeAs<Expr>();
2547 // Check whether Composite2 is viable.
2548 InitializedEntity Entity2
2549 = InitializedEntity::InitializeTemporary(Composite2);
2550 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1);
2551 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1);
2552 if (!E1ToC2 || !E2ToC2)
2555 // Convert E1 to Composite2
2556 OwningExprResult E1Result
2557 = E1ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, (void**)&E1, 1));
2558 if (E1Result.isInvalid())
2560 E1 = E1Result.takeAs<Expr>();
2562 // Convert E2 to Composite2
2563 OwningExprResult E2Result
2564 = E2ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, (void**)&E2, 1));
2565 if (E2Result.isInvalid())
2567 E2 = E2Result.takeAs<Expr>();
2572 Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) {
2573 if (!Context.getLangOptions().CPlusPlus)
2576 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?");
2578 const RecordType *RT = E->getType()->getAs<RecordType>();
2582 // If this is the result of a call expression, our source might
2583 // actually be a reference, in which case we shouldn't bind.
2584 if (CallExpr *CE = dyn_cast<CallExpr>(E)) {
2585 QualType Ty = CE->getCallee()->getType();
2586 if (const PointerType *PT = Ty->getAs<PointerType>())
2587 Ty = PT->getPointeeType();
2588 else if (const BlockPointerType *BPT = Ty->getAs<BlockPointerType>())
2589 Ty = BPT->getPointeeType();
2591 const FunctionType *FTy = Ty->getAs<FunctionType>();
2592 if (FTy->getResultType()->isReferenceType())
2595 else if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
2596 QualType Ty = ME->getType();
2597 if (const PointerType *PT = Ty->getAs<PointerType>())
2598 Ty = PT->getPointeeType();
2599 else if (const BlockPointerType *BPT = Ty->getAs<BlockPointerType>())
2600 Ty = BPT->getPointeeType();
2601 if (Ty->isReferenceType())
2606 // That should be enough to guarantee that this type is complete.
2607 // If it has a trivial destructor, we can avoid the extra copy.
2608 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
2609 if (RD->hasTrivialDestructor())
2612 CXXTemporary *Temp = CXXTemporary::Create(Context, LookupDestructor(RD));
2613 ExprTemporaries.push_back(Temp);
2614 if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
2615 MarkDeclarationReferenced(E->getExprLoc(), Destructor);
2616 CheckDestructorAccess(E->getExprLoc(), Destructor,
2617 PDiag(diag::err_access_dtor_temp)
2620 // FIXME: Add the temporary to the temporaries vector.
2621 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E));
2624 Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr) {
2625 assert(SubExpr && "sub expression can't be null!");
2627 // Check any implicit conversions within the expression.
2628 CheckImplicitConversions(SubExpr);
2630 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries;
2631 assert(ExprTemporaries.size() >= FirstTemporary);
2632 if (ExprTemporaries.size() == FirstTemporary)
2635 Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr,
2636 &ExprTemporaries[FirstTemporary],
2637 ExprTemporaries.size() - FirstTemporary);
2638 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary,
2639 ExprTemporaries.end());
2644 Sema::OwningExprResult
2645 Sema::MaybeCreateCXXExprWithTemporaries(OwningExprResult SubExpr) {
2646 if (SubExpr.isInvalid())
2649 return Owned(MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>()));
2652 FullExpr Sema::CreateFullExpr(Expr *SubExpr) {
2653 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries;
2654 assert(ExprTemporaries.size() >= FirstTemporary);
2656 unsigned NumTemporaries = ExprTemporaries.size() - FirstTemporary;
2657 CXXTemporary **Temporaries =
2658 NumTemporaries == 0 ? 0 : &ExprTemporaries[FirstTemporary];
2660 FullExpr E = FullExpr::Create(Context, SubExpr, Temporaries, NumTemporaries);
2662 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary,
2663 ExprTemporaries.end());
2668 Sema::OwningExprResult
2669 Sema::ActOnStartCXXMemberReference(Scope *S, ExprArg Base, SourceLocation OpLoc,
2670 tok::TokenKind OpKind, TypeTy *&ObjectType,
2671 bool &MayBePseudoDestructor) {
2672 // Since this might be a postfix expression, get rid of ParenListExprs.
2673 Base = MaybeConvertParenListExprToParenExpr(S, move(Base));
2675 Expr *BaseExpr = (Expr*)Base.get();
2676 assert(BaseExpr && "no record expansion");
2678 QualType BaseType = BaseExpr->getType();
2679 MayBePseudoDestructor = false;
2680 if (BaseType->isDependentType()) {
2681 // If we have a pointer to a dependent type and are using the -> operator,
2682 // the object type is the type that the pointer points to. We might still
2683 // have enough information about that type to do something useful.
2684 if (OpKind == tok::arrow)
2685 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
2686 BaseType = Ptr->getPointeeType();
2688 ObjectType = BaseType.getAsOpaquePtr();
2689 MayBePseudoDestructor = true;
2693 // C++ [over.match.oper]p8:
2694 // [...] When operator->returns, the operator-> is applied to the value
2695 // returned, with the original second operand.
2696 if (OpKind == tok::arrow) {
2697 // The set of types we've considered so far.
2698 llvm::SmallPtrSet<CanQualType,8> CTypes;
2699 llvm::SmallVector<SourceLocation, 8> Locations;
2700 CTypes.insert(Context.getCanonicalType(BaseType));
2702 while (BaseType->isRecordType()) {
2703 Base = BuildOverloadedArrowExpr(S, move(Base), OpLoc);
2704 BaseExpr = (Expr*)Base.get();
2705 if (BaseExpr == NULL)
2707 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(BaseExpr))
2708 Locations.push_back(OpCall->getDirectCallee()->getLocation());
2709 BaseType = BaseExpr->getType();
2710 CanQualType CBaseType = Context.getCanonicalType(BaseType);
2711 if (!CTypes.insert(CBaseType)) {
2712 Diag(OpLoc, diag::err_operator_arrow_circular);
2713 for (unsigned i = 0; i < Locations.size(); i++)
2714 Diag(Locations[i], diag::note_declared_at);
2719 if (BaseType->isPointerType())
2720 BaseType = BaseType->getPointeeType();
2723 // We could end up with various non-record types here, such as extended
2724 // vector types or Objective-C interfaces. Just return early and let
2725 // ActOnMemberReferenceExpr do the work.
2726 if (!BaseType->isRecordType()) {
2727 // C++ [basic.lookup.classref]p2:
2728 // [...] If the type of the object expression is of pointer to scalar
2729 // type, the unqualified-id is looked up in the context of the complete
2730 // postfix-expression.
2732 // This also indicates that we should be parsing a
2733 // pseudo-destructor-name.
2735 MayBePseudoDestructor = true;
2739 // The object type must be complete (or dependent).
2740 if (!BaseType->isDependentType() &&
2741 RequireCompleteType(OpLoc, BaseType,
2742 PDiag(diag::err_incomplete_member_access)))
2745 // C++ [basic.lookup.classref]p2:
2746 // If the id-expression in a class member access (5.2.5) is an
2747 // unqualified-id, and the type of the object expression is of a class
2748 // type C (or of pointer to a class type C), the unqualified-id is looked
2749 // up in the scope of class C. [...]
2750 ObjectType = BaseType.getAsOpaquePtr();
2754 Sema::OwningExprResult Sema::DiagnoseDtorReference(SourceLocation NameLoc,
2756 Expr *E = (Expr *) MemExpr.get();
2757 SourceLocation ExpectedLParenLoc = PP.getLocForEndOfToken(NameLoc);
2758 Diag(E->getLocStart(), diag::err_dtor_expr_without_call)
2759 << isa<CXXPseudoDestructorExpr>(E)
2760 << FixItHint::CreateInsertion(ExpectedLParenLoc, "()");
2762 return ActOnCallExpr(/*Scope*/ 0,
2764 /*LPLoc*/ ExpectedLParenLoc,
2765 Sema::MultiExprArg(*this, 0, 0),
2767 /*RPLoc*/ ExpectedLParenLoc);
2770 Sema::OwningExprResult Sema::BuildPseudoDestructorExpr(ExprArg Base,
2771 SourceLocation OpLoc,
2772 tok::TokenKind OpKind,
2773 const CXXScopeSpec &SS,
2774 TypeSourceInfo *ScopeTypeInfo,
2775 SourceLocation CCLoc,
2776 SourceLocation TildeLoc,
2777 PseudoDestructorTypeStorage Destructed,
2778 bool HasTrailingLParen) {
2779 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo();
2781 // C++ [expr.pseudo]p2:
2782 // The left-hand side of the dot operator shall be of scalar type. The
2783 // left-hand side of the arrow operator shall be of pointer to scalar type.
2784 // This scalar type is the object type.
2785 Expr *BaseE = (Expr *)Base.get();
2786 QualType ObjectType = BaseE->getType();
2787 if (OpKind == tok::arrow) {
2788 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) {
2789 ObjectType = Ptr->getPointeeType();
2790 } else if (!BaseE->isTypeDependent()) {
2791 // The user wrote "p->" when she probably meant "p."; fix it.
2792 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
2793 << ObjectType << true
2794 << FixItHint::CreateReplacement(OpLoc, ".");
2795 if (isSFINAEContext())
2798 OpKind = tok::period;
2802 if (!ObjectType->isDependentType() && !ObjectType->isScalarType()) {
2803 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar)
2804 << ObjectType << BaseE->getSourceRange();
2808 // C++ [expr.pseudo]p2:
2809 // [...] The cv-unqualified versions of the object type and of the type
2810 // designated by the pseudo-destructor-name shall be the same type.
2811 if (DestructedTypeInfo) {
2812 QualType DestructedType = DestructedTypeInfo->getType();
2813 SourceLocation DestructedTypeStart
2814 = DestructedTypeInfo->getTypeLoc().getLocalSourceRange().getBegin();
2815 if (!DestructedType->isDependentType() && !ObjectType->isDependentType() &&
2816 !Context.hasSameUnqualifiedType(DestructedType, ObjectType)) {
2817 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch)
2818 << ObjectType << DestructedType << BaseE->getSourceRange()
2819 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange();
2821 // Recover by setting the destructed type to the object type.
2822 DestructedType = ObjectType;
2823 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType,
2824 DestructedTypeStart);
2825 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
2829 // C++ [expr.pseudo]p2:
2830 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the
2833 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name
2835 // shall designate the same scalar type.
2836 if (ScopeTypeInfo) {
2837 QualType ScopeType = ScopeTypeInfo->getType();
2838 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() &&
2839 !Context.hasSameUnqualifiedType(ScopeType, ObjectType)) {
2841 Diag(ScopeTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(),
2842 diag::err_pseudo_dtor_type_mismatch)
2843 << ObjectType << ScopeType << BaseE->getSourceRange()
2844 << ScopeTypeInfo->getTypeLoc().getLocalSourceRange();
2846 ScopeType = QualType();
2851 OwningExprResult Result
2852 = Owned(new (Context) CXXPseudoDestructorExpr(Context,
2853 Base.takeAs<Expr>(),
2854 OpKind == tok::arrow,
2856 (NestedNameSpecifier *) SS.getScopeRep(),
2863 if (HasTrailingLParen)
2864 return move(Result);
2866 return DiagnoseDtorReference(Destructed.getLocation(), move(Result));
2869 Sema::OwningExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, ExprArg Base,
2870 SourceLocation OpLoc,
2871 tok::TokenKind OpKind,
2873 UnqualifiedId &FirstTypeName,
2874 SourceLocation CCLoc,
2875 SourceLocation TildeLoc,
2876 UnqualifiedId &SecondTypeName,
2877 bool HasTrailingLParen) {
2878 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
2879 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
2880 "Invalid first type name in pseudo-destructor");
2881 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
2882 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
2883 "Invalid second type name in pseudo-destructor");
2885 Expr *BaseE = (Expr *)Base.get();
2887 // C++ [expr.pseudo]p2:
2888 // The left-hand side of the dot operator shall be of scalar type. The
2889 // left-hand side of the arrow operator shall be of pointer to scalar type.
2890 // This scalar type is the object type.
2891 QualType ObjectType = BaseE->getType();
2892 if (OpKind == tok::arrow) {
2893 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) {
2894 ObjectType = Ptr->getPointeeType();
2895 } else if (!ObjectType->isDependentType()) {
2896 // The user wrote "p->" when she probably meant "p."; fix it.
2897 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
2898 << ObjectType << true
2899 << FixItHint::CreateReplacement(OpLoc, ".");
2900 if (isSFINAEContext())
2903 OpKind = tok::period;
2907 // Compute the object type that we should use for name lookup purposes. Only
2908 // record types and dependent types matter.
2909 void *ObjectTypePtrForLookup = 0;
2911 ObjectTypePtrForLookup = const_cast<RecordType*>(
2912 ObjectType->getAs<RecordType>());
2913 if (!ObjectTypePtrForLookup && ObjectType->isDependentType())
2914 ObjectTypePtrForLookup = Context.DependentTy.getAsOpaquePtr();
2917 // Convert the name of the type being destructed (following the ~) into a
2918 // type (with source-location information).
2919 QualType DestructedType;
2920 TypeSourceInfo *DestructedTypeInfo = 0;
2921 PseudoDestructorTypeStorage Destructed;
2922 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) {
2923 TypeTy *T = getTypeName(*SecondTypeName.Identifier,
2924 SecondTypeName.StartLocation,
2925 S, &SS, true, ObjectTypePtrForLookup);
2927 ((SS.isSet() && !computeDeclContext(SS, false)) ||
2928 (!SS.isSet() && ObjectType->isDependentType()))) {
2929 // The name of the type being destroyed is a dependent name, and we
2930 // couldn't find anything useful in scope. Just store the identifier and
2931 // it's location, and we'll perform (qualified) name lookup again at
2932 // template instantiation time.
2933 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier,
2934 SecondTypeName.StartLocation);
2936 Diag(SecondTypeName.StartLocation,
2937 diag::err_pseudo_dtor_destructor_non_type)
2938 << SecondTypeName.Identifier << ObjectType;
2939 if (isSFINAEContext())
2942 // Recover by assuming we had the right type all along.
2943 DestructedType = ObjectType;
2945 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo);
2947 // Resolve the template-id to a type.
2948 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId;
2949 ASTTemplateArgsPtr TemplateArgsPtr(*this,
2950 TemplateId->getTemplateArgs(),
2951 TemplateId->NumArgs);
2952 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template),
2953 TemplateId->TemplateNameLoc,
2954 TemplateId->LAngleLoc,
2956 TemplateId->RAngleLoc);
2957 if (T.isInvalid() || !T.get()) {
2958 // Recover by assuming we had the right type all along.
2959 DestructedType = ObjectType;
2961 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo);
2964 // If we've performed some kind of recovery, (re-)build the type source
2966 if (!DestructedType.isNull()) {
2967 if (!DestructedTypeInfo)
2968 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType,
2969 SecondTypeName.StartLocation);
2970 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo);
2973 // Convert the name of the scope type (the type prior to '::') into a type.
2974 TypeSourceInfo *ScopeTypeInfo = 0;
2976 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
2977 FirstTypeName.Identifier) {
2978 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) {
2979 TypeTy *T = getTypeName(*FirstTypeName.Identifier,
2980 FirstTypeName.StartLocation,
2981 S, &SS, false, ObjectTypePtrForLookup);
2983 Diag(FirstTypeName.StartLocation,
2984 diag::err_pseudo_dtor_destructor_non_type)
2985 << FirstTypeName.Identifier << ObjectType;
2987 if (isSFINAEContext())
2990 // Just drop this type. It's unnecessary anyway.
2991 ScopeType = QualType();
2993 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo);
2995 // Resolve the template-id to a type.
2996 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId;
2997 ASTTemplateArgsPtr TemplateArgsPtr(*this,
2998 TemplateId->getTemplateArgs(),
2999 TemplateId->NumArgs);
3000 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template),
3001 TemplateId->TemplateNameLoc,
3002 TemplateId->LAngleLoc,
3004 TemplateId->RAngleLoc);
3005 if (T.isInvalid() || !T.get()) {
3006 // Recover by dropping this type.
3007 ScopeType = QualType();
3009 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo);
3013 if (!ScopeType.isNull() && !ScopeTypeInfo)
3014 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType,
3015 FirstTypeName.StartLocation);
3018 return BuildPseudoDestructorExpr(move(Base), OpLoc, OpKind, SS,
3019 ScopeTypeInfo, CCLoc, TildeLoc,
3020 Destructed, HasTrailingLParen);
3023 CXXMemberCallExpr *Sema::BuildCXXMemberCallExpr(Expr *Exp,
3024 NamedDecl *FoundDecl,
3025 CXXMethodDecl *Method) {
3026 if (PerformObjectArgumentInitialization(Exp, /*Qualifier=*/0,
3028 assert(0 && "Calling BuildCXXMemberCallExpr with invalid call?");
3031 new (Context) MemberExpr(Exp, /*IsArrow=*/false, Method,
3032 SourceLocation(), Method->getType());
3033 QualType ResultType = Method->getCallResultType();
3034 MarkDeclarationReferenced(Exp->getLocStart(), Method);
3035 CXXMemberCallExpr *CE =
3036 new (Context) CXXMemberCallExpr(Context, ME, 0, 0, ResultType,
3041 Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) {
3042 Expr *FullExpr = Arg.takeAs<Expr>();
3044 FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr);
3048 return Owned(FullExpr);