SemaExprCXX.cpp revision 29ecaba4ebe8c9a2627cf405e36473b764cc5cfd
1//===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements semantic analysis for C++ expressions. 11// 12//===----------------------------------------------------------------------===// 13 14#include "Sema.h" 15#include "SemaInit.h" 16#include "Lookup.h" 17#include "clang/AST/ASTContext.h" 18#include "clang/AST/CXXInheritance.h" 19#include "clang/AST/ExprCXX.h" 20#include "clang/AST/TypeLoc.h" 21#include "clang/Basic/PartialDiagnostic.h" 22#include "clang/Basic/TargetInfo.h" 23#include "clang/Lex/Preprocessor.h" 24#include "clang/Parse/DeclSpec.h" 25#include "clang/Parse/Template.h" 26#include "llvm/ADT/STLExtras.h" 27using namespace clang; 28 29Action::TypeTy *Sema::getDestructorName(SourceLocation TildeLoc, 30 IdentifierInfo &II, 31 SourceLocation NameLoc, 32 Scope *S, const CXXScopeSpec &SS, 33 TypeTy *ObjectTypePtr, 34 bool EnteringContext) { 35 // Determine where to perform name lookup. 36 37 // FIXME: This area of the standard is very messy, and the current 38 // wording is rather unclear about which scopes we search for the 39 // destructor name; see core issues 399 and 555. Issue 399 in 40 // particular shows where the current description of destructor name 41 // lookup is completely out of line with existing practice, e.g., 42 // this appears to be ill-formed: 43 // 44 // namespace N { 45 // template <typename T> struct S { 46 // ~S(); 47 // }; 48 // } 49 // 50 // void f(N::S<int>* s) { 51 // s->N::S<int>::~S(); 52 // } 53 // 54 // See also PR6358 and PR6359. 55 QualType SearchType; 56 DeclContext *LookupCtx = 0; 57 bool isDependent = false; 58 bool LookInScope = false; 59 60 // If we have an object type, it's because we are in a 61 // pseudo-destructor-expression or a member access expression, and 62 // we know what type we're looking for. 63 if (ObjectTypePtr) 64 SearchType = GetTypeFromParser(ObjectTypePtr); 65 66 if (SS.isSet()) { 67 NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep(); 68 69 bool AlreadySearched = false; 70 bool LookAtPrefix = true; 71 if (!getLangOptions().CPlusPlus0x) { 72 // C++ [basic.lookup.qual]p6: 73 // If a pseudo-destructor-name (5.2.4) contains a nested-name-specifier, 74 // the type-names are looked up as types in the scope designated by the 75 // nested-name-specifier. In a qualified-id of the form: 76 // 77 // ::[opt] nested-name-specifier ̃ class-name 78 // 79 // where the nested-name-specifier designates a namespace scope, and in 80 // a qualified-id of the form: 81 // 82 // ::opt nested-name-specifier class-name :: ̃ class-name 83 // 84 // the class-names are looked up as types in the scope designated by 85 // the nested-name-specifier. 86 // 87 // Here, we check the first case (completely) and determine whether the 88 // code below is permitted to look at the prefix of the 89 // nested-name-specifier (as we do in C++0x). 90 DeclContext *DC = computeDeclContext(SS, EnteringContext); 91 if (DC && DC->isFileContext()) { 92 AlreadySearched = true; 93 LookupCtx = DC; 94 isDependent = false; 95 } else if (DC && isa<CXXRecordDecl>(DC)) 96 LookAtPrefix = false; 97 } 98 99 // C++0x [basic.lookup.qual]p6: 100 // If a pseudo-destructor-name (5.2.4) contains a 101 // nested-name-specifier, the type-names are looked up as types 102 // in the scope designated by the nested-name-specifier. Similarly, in 103 // a qualified-id of the form: 104 // 105 // :: [opt] nested-name-specifier[opt] class-name :: ~class-name 106 // 107 // the second class-name is looked up in the same scope as the first. 108 // 109 // To implement this, we look at the prefix of the 110 // nested-name-specifier we were given, and determine the lookup 111 // context from that. 112 // 113 // We also fold in the second case from the C++03 rules quoted further 114 // above. 115 NestedNameSpecifier *Prefix = 0; 116 if (AlreadySearched) { 117 // Nothing left to do. 118 } else if (LookAtPrefix && (Prefix = NNS->getPrefix())) { 119 CXXScopeSpec PrefixSS; 120 PrefixSS.setScopeRep(Prefix); 121 LookupCtx = computeDeclContext(PrefixSS, EnteringContext); 122 isDependent = isDependentScopeSpecifier(PrefixSS); 123 } else if (getLangOptions().CPlusPlus0x && 124 (LookupCtx = computeDeclContext(SS, EnteringContext))) { 125 if (!LookupCtx->isTranslationUnit()) 126 LookupCtx = LookupCtx->getParent(); 127 isDependent = LookupCtx && LookupCtx->isDependentContext(); 128 } else if (ObjectTypePtr) { 129 LookupCtx = computeDeclContext(SearchType); 130 isDependent = SearchType->isDependentType(); 131 } else { 132 LookupCtx = computeDeclContext(SS, EnteringContext); 133 isDependent = LookupCtx && LookupCtx->isDependentContext(); 134 } 135 136 LookInScope = false; 137 } else if (ObjectTypePtr) { 138 // C++ [basic.lookup.classref]p3: 139 // If the unqualified-id is ~type-name, the type-name is looked up 140 // in the context of the entire postfix-expression. If the type T 141 // of the object expression is of a class type C, the type-name is 142 // also looked up in the scope of class C. At least one of the 143 // lookups shall find a name that refers to (possibly 144 // cv-qualified) T. 145 LookupCtx = computeDeclContext(SearchType); 146 isDependent = SearchType->isDependentType(); 147 assert((isDependent || !SearchType->isIncompleteType()) && 148 "Caller should have completed object type"); 149 150 LookInScope = true; 151 } else { 152 // Perform lookup into the current scope (only). 153 LookInScope = true; 154 } 155 156 LookupResult Found(*this, &II, NameLoc, LookupOrdinaryName); 157 for (unsigned Step = 0; Step != 2; ++Step) { 158 // Look for the name first in the computed lookup context (if we 159 // have one) and, if that fails to find a match, in the sope (if 160 // we're allowed to look there). 161 Found.clear(); 162 if (Step == 0 && LookupCtx) 163 LookupQualifiedName(Found, LookupCtx); 164 else if (Step == 1 && LookInScope && S) 165 LookupName(Found, S); 166 else 167 continue; 168 169 // FIXME: Should we be suppressing ambiguities here? 170 if (Found.isAmbiguous()) 171 return 0; 172 173 if (TypeDecl *Type = Found.getAsSingle<TypeDecl>()) { 174 QualType T = Context.getTypeDeclType(Type); 175 176 if (SearchType.isNull() || SearchType->isDependentType() || 177 Context.hasSameUnqualifiedType(T, SearchType)) { 178 // We found our type! 179 180 return T.getAsOpaquePtr(); 181 } 182 } 183 184 // If the name that we found is a class template name, and it is 185 // the same name as the template name in the last part of the 186 // nested-name-specifier (if present) or the object type, then 187 // this is the destructor for that class. 188 // FIXME: This is a workaround until we get real drafting for core 189 // issue 399, for which there isn't even an obvious direction. 190 if (ClassTemplateDecl *Template = Found.getAsSingle<ClassTemplateDecl>()) { 191 QualType MemberOfType; 192 if (SS.isSet()) { 193 if (DeclContext *Ctx = computeDeclContext(SS, EnteringContext)) { 194 // Figure out the type of the context, if it has one. 195 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx)) 196 MemberOfType = Context.getTypeDeclType(Record); 197 } 198 } 199 if (MemberOfType.isNull()) 200 MemberOfType = SearchType; 201 202 if (MemberOfType.isNull()) 203 continue; 204 205 // We're referring into a class template specialization. If the 206 // class template we found is the same as the template being 207 // specialized, we found what we are looking for. 208 if (const RecordType *Record = MemberOfType->getAs<RecordType>()) { 209 if (ClassTemplateSpecializationDecl *Spec 210 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) { 211 if (Spec->getSpecializedTemplate()->getCanonicalDecl() == 212 Template->getCanonicalDecl()) 213 return MemberOfType.getAsOpaquePtr(); 214 } 215 216 continue; 217 } 218 219 // We're referring to an unresolved class template 220 // specialization. Determine whether we class template we found 221 // is the same as the template being specialized or, if we don't 222 // know which template is being specialized, that it at least 223 // has the same name. 224 if (const TemplateSpecializationType *SpecType 225 = MemberOfType->getAs<TemplateSpecializationType>()) { 226 TemplateName SpecName = SpecType->getTemplateName(); 227 228 // The class template we found is the same template being 229 // specialized. 230 if (TemplateDecl *SpecTemplate = SpecName.getAsTemplateDecl()) { 231 if (SpecTemplate->getCanonicalDecl() == Template->getCanonicalDecl()) 232 return MemberOfType.getAsOpaquePtr(); 233 234 continue; 235 } 236 237 // The class template we found has the same name as the 238 // (dependent) template name being specialized. 239 if (DependentTemplateName *DepTemplate 240 = SpecName.getAsDependentTemplateName()) { 241 if (DepTemplate->isIdentifier() && 242 DepTemplate->getIdentifier() == Template->getIdentifier()) 243 return MemberOfType.getAsOpaquePtr(); 244 245 continue; 246 } 247 } 248 } 249 } 250 251 if (isDependent) { 252 // We didn't find our type, but that's okay: it's dependent 253 // anyway. 254 NestedNameSpecifier *NNS = 0; 255 SourceRange Range; 256 if (SS.isSet()) { 257 NNS = (NestedNameSpecifier *)SS.getScopeRep(); 258 Range = SourceRange(SS.getRange().getBegin(), NameLoc); 259 } else { 260 NNS = NestedNameSpecifier::Create(Context, &II); 261 Range = SourceRange(NameLoc); 262 } 263 264 return CheckTypenameType(NNS, II, Range).getAsOpaquePtr(); 265 } 266 267 if (ObjectTypePtr) 268 Diag(NameLoc, diag::err_ident_in_pseudo_dtor_not_a_type) 269 << &II; 270 else 271 Diag(NameLoc, diag::err_destructor_class_name); 272 273 return 0; 274} 275 276/// ActOnCXXTypeidOfType - Parse typeid( type-id ). 277Action::OwningExprResult 278Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc, 279 bool isType, void *TyOrExpr, SourceLocation RParenLoc) { 280 if (!StdNamespace) 281 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid)); 282 283 if (isType) { 284 // C++ [expr.typeid]p4: 285 // The top-level cv-qualifiers of the lvalue expression or the type-id 286 // that is the operand of typeid are always ignored. 287 // FIXME: Preserve type source info. 288 // FIXME: Preserve the type before we stripped the cv-qualifiers? 289 QualType T = GetTypeFromParser(TyOrExpr); 290 if (T.isNull()) 291 return ExprError(); 292 293 // C++ [expr.typeid]p4: 294 // If the type of the type-id is a class type or a reference to a class 295 // type, the class shall be completely-defined. 296 QualType CheckT = T; 297 if (const ReferenceType *RefType = CheckT->getAs<ReferenceType>()) 298 CheckT = RefType->getPointeeType(); 299 300 if (CheckT->getAs<RecordType>() && 301 RequireCompleteType(OpLoc, CheckT, diag::err_incomplete_typeid)) 302 return ExprError(); 303 304 TyOrExpr = T.getUnqualifiedType().getAsOpaquePtr(); 305 } 306 307 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info"); 308 LookupResult R(*this, TypeInfoII, SourceLocation(), LookupTagName); 309 LookupQualifiedName(R, StdNamespace); 310 RecordDecl *TypeInfoRecordDecl = R.getAsSingle<RecordDecl>(); 311 if (!TypeInfoRecordDecl) 312 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid)); 313 314 QualType TypeInfoType = Context.getTypeDeclType(TypeInfoRecordDecl); 315 316 if (!isType) { 317 bool isUnevaluatedOperand = true; 318 Expr *E = static_cast<Expr *>(TyOrExpr); 319 if (E && !E->isTypeDependent()) { 320 QualType T = E->getType(); 321 if (const RecordType *RecordT = T->getAs<RecordType>()) { 322 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl()); 323 // C++ [expr.typeid]p3: 324 // [...] If the type of the expression is a class type, the class 325 // shall be completely-defined. 326 if (RequireCompleteType(OpLoc, T, diag::err_incomplete_typeid)) 327 return ExprError(); 328 329 // C++ [expr.typeid]p3: 330 // When typeid is applied to an expression other than an lvalue of a 331 // polymorphic class type [...] [the] expression is an unevaluated 332 // operand. [...] 333 if (RecordD->isPolymorphic() && E->isLvalue(Context) == Expr::LV_Valid) 334 isUnevaluatedOperand = false; 335 } 336 337 // C++ [expr.typeid]p4: 338 // [...] If the type of the type-id is a reference to a possibly 339 // cv-qualified type, the result of the typeid expression refers to a 340 // std::type_info object representing the cv-unqualified referenced 341 // type. 342 if (T.hasQualifiers()) { 343 ImpCastExprToType(E, T.getUnqualifiedType(), CastExpr::CK_NoOp, 344 E->isLvalue(Context)); 345 TyOrExpr = E; 346 } 347 } 348 349 // If this is an unevaluated operand, clear out the set of 350 // declaration references we have been computing and eliminate any 351 // temporaries introduced in its computation. 352 if (isUnevaluatedOperand) 353 ExprEvalContexts.back().Context = Unevaluated; 354 } 355 356 return Owned(new (Context) CXXTypeidExpr(isType, TyOrExpr, 357 TypeInfoType.withConst(), 358 SourceRange(OpLoc, RParenLoc))); 359} 360 361/// ActOnCXXBoolLiteral - Parse {true,false} literals. 362Action::OwningExprResult 363Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) { 364 assert((Kind == tok::kw_true || Kind == tok::kw_false) && 365 "Unknown C++ Boolean value!"); 366 return Owned(new (Context) CXXBoolLiteralExpr(Kind == tok::kw_true, 367 Context.BoolTy, OpLoc)); 368} 369 370/// ActOnCXXNullPtrLiteral - Parse 'nullptr'. 371Action::OwningExprResult 372Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc) { 373 return Owned(new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc)); 374} 375 376/// ActOnCXXThrow - Parse throw expressions. 377Action::OwningExprResult 378Sema::ActOnCXXThrow(SourceLocation OpLoc, ExprArg E) { 379 Expr *Ex = E.takeAs<Expr>(); 380 if (Ex && !Ex->isTypeDependent() && CheckCXXThrowOperand(OpLoc, Ex)) 381 return ExprError(); 382 return Owned(new (Context) CXXThrowExpr(Ex, Context.VoidTy, OpLoc)); 383} 384 385/// CheckCXXThrowOperand - Validate the operand of a throw. 386bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E) { 387 // C++ [except.throw]p3: 388 // A throw-expression initializes a temporary object, called the exception 389 // object, the type of which is determined by removing any top-level 390 // cv-qualifiers from the static type of the operand of throw and adjusting 391 // the type from "array of T" or "function returning T" to "pointer to T" 392 // or "pointer to function returning T", [...] 393 if (E->getType().hasQualifiers()) 394 ImpCastExprToType(E, E->getType().getUnqualifiedType(), CastExpr::CK_NoOp, 395 E->isLvalue(Context) == Expr::LV_Valid); 396 397 DefaultFunctionArrayConversion(E); 398 399 // If the type of the exception would be an incomplete type or a pointer 400 // to an incomplete type other than (cv) void the program is ill-formed. 401 QualType Ty = E->getType(); 402 int isPointer = 0; 403 if (const PointerType* Ptr = Ty->getAs<PointerType>()) { 404 Ty = Ptr->getPointeeType(); 405 isPointer = 1; 406 } 407 if (!isPointer || !Ty->isVoidType()) { 408 if (RequireCompleteType(ThrowLoc, Ty, 409 PDiag(isPointer ? diag::err_throw_incomplete_ptr 410 : diag::err_throw_incomplete) 411 << E->getSourceRange())) 412 return true; 413 414 // FIXME: This is just a hack to mark the copy constructor referenced. 415 // This should go away when the next FIXME is fixed. 416 const RecordType *RT = Ty->getAs<RecordType>(); 417 if (!RT) 418 return false; 419 420 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 421 if (RD->hasTrivialCopyConstructor()) 422 return false; 423 CXXConstructorDecl *CopyCtor = RD->getCopyConstructor(Context, 0); 424 MarkDeclarationReferenced(ThrowLoc, CopyCtor); 425 } 426 427 // FIXME: Construct a temporary here. 428 return false; 429} 430 431Action::OwningExprResult Sema::ActOnCXXThis(SourceLocation ThisLoc) { 432 /// C++ 9.3.2: In the body of a non-static member function, the keyword this 433 /// is a non-lvalue expression whose value is the address of the object for 434 /// which the function is called. 435 436 if (!isa<FunctionDecl>(CurContext)) 437 return ExprError(Diag(ThisLoc, diag::err_invalid_this_use)); 438 439 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) 440 if (MD->isInstance()) 441 return Owned(new (Context) CXXThisExpr(ThisLoc, 442 MD->getThisType(Context), 443 /*isImplicit=*/false)); 444 445 return ExprError(Diag(ThisLoc, diag::err_invalid_this_use)); 446} 447 448/// ActOnCXXTypeConstructExpr - Parse construction of a specified type. 449/// Can be interpreted either as function-style casting ("int(x)") 450/// or class type construction ("ClassType(x,y,z)") 451/// or creation of a value-initialized type ("int()"). 452Action::OwningExprResult 453Sema::ActOnCXXTypeConstructExpr(SourceRange TypeRange, TypeTy *TypeRep, 454 SourceLocation LParenLoc, 455 MultiExprArg exprs, 456 SourceLocation *CommaLocs, 457 SourceLocation RParenLoc) { 458 if (!TypeRep) 459 return ExprError(); 460 461 TypeSourceInfo *TInfo; 462 QualType Ty = GetTypeFromParser(TypeRep, &TInfo); 463 if (!TInfo) 464 TInfo = Context.getTrivialTypeSourceInfo(Ty, SourceLocation()); 465 unsigned NumExprs = exprs.size(); 466 Expr **Exprs = (Expr**)exprs.get(); 467 SourceLocation TyBeginLoc = TypeRange.getBegin(); 468 SourceRange FullRange = SourceRange(TyBeginLoc, RParenLoc); 469 470 if (Ty->isDependentType() || 471 CallExpr::hasAnyTypeDependentArguments(Exprs, NumExprs)) { 472 exprs.release(); 473 474 return Owned(CXXUnresolvedConstructExpr::Create(Context, 475 TypeRange.getBegin(), Ty, 476 LParenLoc, 477 Exprs, NumExprs, 478 RParenLoc)); 479 } 480 481 if (Ty->isArrayType()) 482 return ExprError(Diag(TyBeginLoc, 483 diag::err_value_init_for_array_type) << FullRange); 484 if (!Ty->isVoidType() && 485 RequireCompleteType(TyBeginLoc, Ty, 486 PDiag(diag::err_invalid_incomplete_type_use) 487 << FullRange)) 488 return ExprError(); 489 490 if (RequireNonAbstractType(TyBeginLoc, Ty, 491 diag::err_allocation_of_abstract_type)) 492 return ExprError(); 493 494 495 // C++ [expr.type.conv]p1: 496 // If the expression list is a single expression, the type conversion 497 // expression is equivalent (in definedness, and if defined in meaning) to the 498 // corresponding cast expression. 499 // 500 if (NumExprs == 1) { 501 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 502 CXXMethodDecl *Method = 0; 503 if (CheckCastTypes(TypeRange, Ty, Exprs[0], Kind, Method, 504 /*FunctionalStyle=*/true)) 505 return ExprError(); 506 507 exprs.release(); 508 if (Method) { 509 OwningExprResult CastArg 510 = BuildCXXCastArgument(TypeRange.getBegin(), Ty.getNonReferenceType(), 511 Kind, Method, Owned(Exprs[0])); 512 if (CastArg.isInvalid()) 513 return ExprError(); 514 515 Exprs[0] = CastArg.takeAs<Expr>(); 516 } 517 518 return Owned(new (Context) CXXFunctionalCastExpr(Ty.getNonReferenceType(), 519 TInfo, TyBeginLoc, Kind, 520 Exprs[0], RParenLoc)); 521 } 522 523 if (const RecordType *RT = Ty->getAs<RecordType>()) { 524 CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl()); 525 526 if (NumExprs > 1 || !Record->hasTrivialConstructor() || 527 !Record->hasTrivialDestructor()) { 528 InitializedEntity Entity = InitializedEntity::InitializeTemporary(Ty); 529 InitializationKind Kind 530 = NumExprs ? InitializationKind::CreateDirect(TypeRange.getBegin(), 531 LParenLoc, RParenLoc) 532 : InitializationKind::CreateValue(TypeRange.getBegin(), 533 LParenLoc, RParenLoc); 534 InitializationSequence InitSeq(*this, Entity, Kind, Exprs, NumExprs); 535 OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind, 536 move(exprs)); 537 538 // FIXME: Improve AST representation? 539 return move(Result); 540 } 541 542 // Fall through to value-initialize an object of class type that 543 // doesn't have a user-declared default constructor. 544 } 545 546 // C++ [expr.type.conv]p1: 547 // If the expression list specifies more than a single value, the type shall 548 // be a class with a suitably declared constructor. 549 // 550 if (NumExprs > 1) 551 return ExprError(Diag(CommaLocs[0], 552 diag::err_builtin_func_cast_more_than_one_arg) 553 << FullRange); 554 555 assert(NumExprs == 0 && "Expected 0 expressions"); 556 // C++ [expr.type.conv]p2: 557 // The expression T(), where T is a simple-type-specifier for a non-array 558 // complete object type or the (possibly cv-qualified) void type, creates an 559 // rvalue of the specified type, which is value-initialized. 560 // 561 exprs.release(); 562 return Owned(new (Context) CXXZeroInitValueExpr(Ty, TyBeginLoc, RParenLoc)); 563} 564 565 566/// ActOnCXXNew - Parsed a C++ 'new' expression (C++ 5.3.4), as in e.g.: 567/// @code new (memory) int[size][4] @endcode 568/// or 569/// @code ::new Foo(23, "hello") @endcode 570/// For the interpretation of this heap of arguments, consult the base version. 571Action::OwningExprResult 572Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, 573 SourceLocation PlacementLParen, MultiExprArg PlacementArgs, 574 SourceLocation PlacementRParen, bool ParenTypeId, 575 Declarator &D, SourceLocation ConstructorLParen, 576 MultiExprArg ConstructorArgs, 577 SourceLocation ConstructorRParen) { 578 Expr *ArraySize = 0; 579 // If the specified type is an array, unwrap it and save the expression. 580 if (D.getNumTypeObjects() > 0 && 581 D.getTypeObject(0).Kind == DeclaratorChunk::Array) { 582 DeclaratorChunk &Chunk = D.getTypeObject(0); 583 if (Chunk.Arr.hasStatic) 584 return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new) 585 << D.getSourceRange()); 586 if (!Chunk.Arr.NumElts) 587 return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size) 588 << D.getSourceRange()); 589 590 if (ParenTypeId) { 591 // Can't have dynamic array size when the type-id is in parentheses. 592 Expr *NumElts = (Expr *)Chunk.Arr.NumElts; 593 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent() && 594 !NumElts->isIntegerConstantExpr(Context)) { 595 Diag(D.getTypeObject(0).Loc, diag::err_new_paren_array_nonconst) 596 << NumElts->getSourceRange(); 597 return ExprError(); 598 } 599 } 600 601 ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts); 602 D.DropFirstTypeObject(); 603 } 604 605 // Every dimension shall be of constant size. 606 if (ArraySize) { 607 for (unsigned I = 0, N = D.getNumTypeObjects(); I < N; ++I) { 608 if (D.getTypeObject(I).Kind != DeclaratorChunk::Array) 609 break; 610 611 DeclaratorChunk::ArrayTypeInfo &Array = D.getTypeObject(I).Arr; 612 if (Expr *NumElts = (Expr *)Array.NumElts) { 613 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent() && 614 !NumElts->isIntegerConstantExpr(Context)) { 615 Diag(D.getTypeObject(I).Loc, diag::err_new_array_nonconst) 616 << NumElts->getSourceRange(); 617 return ExprError(); 618 } 619 } 620 } 621 } 622 623 //FIXME: Store TypeSourceInfo in CXXNew expression. 624 TypeSourceInfo *TInfo = 0; 625 QualType AllocType = GetTypeForDeclarator(D, /*Scope=*/0, &TInfo); 626 if (D.isInvalidType()) 627 return ExprError(); 628 629 return BuildCXXNew(StartLoc, UseGlobal, 630 PlacementLParen, 631 move(PlacementArgs), 632 PlacementRParen, 633 ParenTypeId, 634 AllocType, 635 D.getSourceRange().getBegin(), 636 D.getSourceRange(), 637 Owned(ArraySize), 638 ConstructorLParen, 639 move(ConstructorArgs), 640 ConstructorRParen); 641} 642 643Sema::OwningExprResult 644Sema::BuildCXXNew(SourceLocation StartLoc, bool UseGlobal, 645 SourceLocation PlacementLParen, 646 MultiExprArg PlacementArgs, 647 SourceLocation PlacementRParen, 648 bool ParenTypeId, 649 QualType AllocType, 650 SourceLocation TypeLoc, 651 SourceRange TypeRange, 652 ExprArg ArraySizeE, 653 SourceLocation ConstructorLParen, 654 MultiExprArg ConstructorArgs, 655 SourceLocation ConstructorRParen) { 656 if (CheckAllocatedType(AllocType, TypeLoc, TypeRange)) 657 return ExprError(); 658 659 QualType ResultType = Context.getPointerType(AllocType); 660 661 // That every array dimension except the first is constant was already 662 // checked by the type check above. 663 664 // C++ 5.3.4p6: "The expression in a direct-new-declarator shall have integral 665 // or enumeration type with a non-negative value." 666 Expr *ArraySize = (Expr *)ArraySizeE.get(); 667 if (ArraySize && !ArraySize->isTypeDependent()) { 668 QualType SizeType = ArraySize->getType(); 669 if (!SizeType->isIntegralType() && !SizeType->isEnumeralType()) 670 return ExprError(Diag(ArraySize->getSourceRange().getBegin(), 671 diag::err_array_size_not_integral) 672 << SizeType << ArraySize->getSourceRange()); 673 // Let's see if this is a constant < 0. If so, we reject it out of hand. 674 // We don't care about special rules, so we tell the machinery it's not 675 // evaluated - it gives us a result in more cases. 676 if (!ArraySize->isValueDependent()) { 677 llvm::APSInt Value; 678 if (ArraySize->isIntegerConstantExpr(Value, Context, 0, false)) { 679 if (Value < llvm::APSInt( 680 llvm::APInt::getNullValue(Value.getBitWidth()), 681 Value.isUnsigned())) 682 return ExprError(Diag(ArraySize->getSourceRange().getBegin(), 683 diag::err_typecheck_negative_array_size) 684 << ArraySize->getSourceRange()); 685 } 686 } 687 688 ImpCastExprToType(ArraySize, Context.getSizeType(), 689 CastExpr::CK_IntegralCast); 690 } 691 692 FunctionDecl *OperatorNew = 0; 693 FunctionDecl *OperatorDelete = 0; 694 Expr **PlaceArgs = (Expr**)PlacementArgs.get(); 695 unsigned NumPlaceArgs = PlacementArgs.size(); 696 697 if (!AllocType->isDependentType() && 698 !Expr::hasAnyTypeDependentArguments(PlaceArgs, NumPlaceArgs) && 699 FindAllocationFunctions(StartLoc, 700 SourceRange(PlacementLParen, PlacementRParen), 701 UseGlobal, AllocType, ArraySize, PlaceArgs, 702 NumPlaceArgs, OperatorNew, OperatorDelete)) 703 return ExprError(); 704 llvm::SmallVector<Expr *, 8> AllPlaceArgs; 705 if (OperatorNew) { 706 // Add default arguments, if any. 707 const FunctionProtoType *Proto = 708 OperatorNew->getType()->getAs<FunctionProtoType>(); 709 VariadicCallType CallType = 710 Proto->isVariadic() ? VariadicFunction : VariadicDoesNotApply; 711 bool Invalid = GatherArgumentsForCall(PlacementLParen, OperatorNew, 712 Proto, 1, PlaceArgs, NumPlaceArgs, 713 AllPlaceArgs, CallType); 714 if (Invalid) 715 return ExprError(); 716 717 NumPlaceArgs = AllPlaceArgs.size(); 718 if (NumPlaceArgs > 0) 719 PlaceArgs = &AllPlaceArgs[0]; 720 } 721 722 bool Init = ConstructorLParen.isValid(); 723 // --- Choosing a constructor --- 724 CXXConstructorDecl *Constructor = 0; 725 Expr **ConsArgs = (Expr**)ConstructorArgs.get(); 726 unsigned NumConsArgs = ConstructorArgs.size(); 727 ASTOwningVector<&ActionBase::DeleteExpr> ConvertedConstructorArgs(*this); 728 729 if (!AllocType->isDependentType() && 730 !Expr::hasAnyTypeDependentArguments(ConsArgs, NumConsArgs)) { 731 // C++0x [expr.new]p15: 732 // A new-expression that creates an object of type T initializes that 733 // object as follows: 734 InitializationKind Kind 735 // - If the new-initializer is omitted, the object is default- 736 // initialized (8.5); if no initialization is performed, 737 // the object has indeterminate value 738 = !Init? InitializationKind::CreateDefault(TypeLoc) 739 // - Otherwise, the new-initializer is interpreted according to the 740 // initialization rules of 8.5 for direct-initialization. 741 : InitializationKind::CreateDirect(TypeLoc, 742 ConstructorLParen, 743 ConstructorRParen); 744 745 InitializedEntity Entity 746 = InitializedEntity::InitializeNew(StartLoc, AllocType); 747 InitializationSequence InitSeq(*this, Entity, Kind, ConsArgs, NumConsArgs); 748 OwningExprResult FullInit = InitSeq.Perform(*this, Entity, Kind, 749 move(ConstructorArgs)); 750 if (FullInit.isInvalid()) 751 return ExprError(); 752 753 // FullInit is our initializer; walk through it to determine if it's a 754 // constructor call, which CXXNewExpr handles directly. 755 if (Expr *FullInitExpr = (Expr *)FullInit.get()) { 756 if (CXXBindTemporaryExpr *Binder 757 = dyn_cast<CXXBindTemporaryExpr>(FullInitExpr)) 758 FullInitExpr = Binder->getSubExpr(); 759 if (CXXConstructExpr *Construct 760 = dyn_cast<CXXConstructExpr>(FullInitExpr)) { 761 Constructor = Construct->getConstructor(); 762 for (CXXConstructExpr::arg_iterator A = Construct->arg_begin(), 763 AEnd = Construct->arg_end(); 764 A != AEnd; ++A) 765 ConvertedConstructorArgs.push_back(A->Retain()); 766 } else { 767 // Take the converted initializer. 768 ConvertedConstructorArgs.push_back(FullInit.release()); 769 } 770 } else { 771 // No initialization required. 772 } 773 774 // Take the converted arguments and use them for the new expression. 775 NumConsArgs = ConvertedConstructorArgs.size(); 776 ConsArgs = (Expr **)ConvertedConstructorArgs.take(); 777 } 778 779 // Mark the new and delete operators as referenced. 780 if (OperatorNew) 781 MarkDeclarationReferenced(StartLoc, OperatorNew); 782 if (OperatorDelete) 783 MarkDeclarationReferenced(StartLoc, OperatorDelete); 784 785 // FIXME: Also check that the destructor is accessible. (C++ 5.3.4p16) 786 787 PlacementArgs.release(); 788 ConstructorArgs.release(); 789 ArraySizeE.release(); 790 return Owned(new (Context) CXXNewExpr(Context, UseGlobal, OperatorNew, 791 PlaceArgs, NumPlaceArgs, ParenTypeId, 792 ArraySize, Constructor, Init, 793 ConsArgs, NumConsArgs, OperatorDelete, 794 ResultType, StartLoc, 795 Init ? ConstructorRParen : 796 SourceLocation())); 797} 798 799/// CheckAllocatedType - Checks that a type is suitable as the allocated type 800/// in a new-expression. 801/// dimension off and stores the size expression in ArraySize. 802bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc, 803 SourceRange R) { 804 // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an 805 // abstract class type or array thereof. 806 if (AllocType->isFunctionType()) 807 return Diag(Loc, diag::err_bad_new_type) 808 << AllocType << 0 << R; 809 else if (AllocType->isReferenceType()) 810 return Diag(Loc, diag::err_bad_new_type) 811 << AllocType << 1 << R; 812 else if (!AllocType->isDependentType() && 813 RequireCompleteType(Loc, AllocType, 814 PDiag(diag::err_new_incomplete_type) 815 << R)) 816 return true; 817 else if (RequireNonAbstractType(Loc, AllocType, 818 diag::err_allocation_of_abstract_type)) 819 return true; 820 821 return false; 822} 823 824/// \brief Determine whether the given function is a non-placement 825/// deallocation function. 826static bool isNonPlacementDeallocationFunction(FunctionDecl *FD) { 827 if (FD->isInvalidDecl()) 828 return false; 829 830 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD)) 831 return Method->isUsualDeallocationFunction(); 832 833 return ((FD->getOverloadedOperator() == OO_Delete || 834 FD->getOverloadedOperator() == OO_Array_Delete) && 835 FD->getNumParams() == 1); 836} 837 838/// FindAllocationFunctions - Finds the overloads of operator new and delete 839/// that are appropriate for the allocation. 840bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, 841 bool UseGlobal, QualType AllocType, 842 bool IsArray, Expr **PlaceArgs, 843 unsigned NumPlaceArgs, 844 FunctionDecl *&OperatorNew, 845 FunctionDecl *&OperatorDelete) { 846 // --- Choosing an allocation function --- 847 // C++ 5.3.4p8 - 14 & 18 848 // 1) If UseGlobal is true, only look in the global scope. Else, also look 849 // in the scope of the allocated class. 850 // 2) If an array size is given, look for operator new[], else look for 851 // operator new. 852 // 3) The first argument is always size_t. Append the arguments from the 853 // placement form. 854 855 llvm::SmallVector<Expr*, 8> AllocArgs(1 + NumPlaceArgs); 856 // We don't care about the actual value of this argument. 857 // FIXME: Should the Sema create the expression and embed it in the syntax 858 // tree? Or should the consumer just recalculate the value? 859 IntegerLiteral Size(llvm::APInt::getNullValue( 860 Context.Target.getPointerWidth(0)), 861 Context.getSizeType(), 862 SourceLocation()); 863 AllocArgs[0] = &Size; 864 std::copy(PlaceArgs, PlaceArgs + NumPlaceArgs, AllocArgs.begin() + 1); 865 866 // C++ [expr.new]p8: 867 // If the allocated type is a non-array type, the allocation 868 // function’s name is operator new and the deallocation function’s 869 // name is operator delete. If the allocated type is an array 870 // type, the allocation function’s name is operator new[] and the 871 // deallocation function’s name is operator delete[]. 872 DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName( 873 IsArray ? OO_Array_New : OO_New); 874 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName( 875 IsArray ? OO_Array_Delete : OO_Delete); 876 877 if (AllocType->isRecordType() && !UseGlobal) { 878 CXXRecordDecl *Record 879 = cast<CXXRecordDecl>(AllocType->getAs<RecordType>()->getDecl()); 880 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0], 881 AllocArgs.size(), Record, /*AllowMissing=*/true, 882 OperatorNew)) 883 return true; 884 } 885 if (!OperatorNew) { 886 // Didn't find a member overload. Look for a global one. 887 DeclareGlobalNewDelete(); 888 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 889 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0], 890 AllocArgs.size(), TUDecl, /*AllowMissing=*/false, 891 OperatorNew)) 892 return true; 893 } 894 895 // FindAllocationOverload can change the passed in arguments, so we need to 896 // copy them back. 897 if (NumPlaceArgs > 0) 898 std::copy(&AllocArgs[1], AllocArgs.end(), PlaceArgs); 899 900 // C++ [expr.new]p19: 901 // 902 // If the new-expression begins with a unary :: operator, the 903 // deallocation function’s name is looked up in the global 904 // scope. Otherwise, if the allocated type is a class type T or an 905 // array thereof, the deallocation function’s name is looked up in 906 // the scope of T. If this lookup fails to find the name, or if 907 // the allocated type is not a class type or array thereof, the 908 // deallocation function’s name is looked up in the global scope. 909 LookupResult FoundDelete(*this, DeleteName, StartLoc, LookupOrdinaryName); 910 if (AllocType->isRecordType() && !UseGlobal) { 911 CXXRecordDecl *RD 912 = cast<CXXRecordDecl>(AllocType->getAs<RecordType>()->getDecl()); 913 LookupQualifiedName(FoundDelete, RD); 914 } 915 if (FoundDelete.isAmbiguous()) 916 return true; // FIXME: clean up expressions? 917 918 if (FoundDelete.empty()) { 919 DeclareGlobalNewDelete(); 920 LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl()); 921 } 922 923 FoundDelete.suppressDiagnostics(); 924 925 llvm::SmallVector<std::pair<DeclAccessPair,FunctionDecl*>, 2> Matches; 926 927 if (NumPlaceArgs > 0) { 928 // C++ [expr.new]p20: 929 // A declaration of a placement deallocation function matches the 930 // declaration of a placement allocation function if it has the 931 // same number of parameters and, after parameter transformations 932 // (8.3.5), all parameter types except the first are 933 // identical. [...] 934 // 935 // To perform this comparison, we compute the function type that 936 // the deallocation function should have, and use that type both 937 // for template argument deduction and for comparison purposes. 938 QualType ExpectedFunctionType; 939 { 940 const FunctionProtoType *Proto 941 = OperatorNew->getType()->getAs<FunctionProtoType>(); 942 llvm::SmallVector<QualType, 4> ArgTypes; 943 ArgTypes.push_back(Context.VoidPtrTy); 944 for (unsigned I = 1, N = Proto->getNumArgs(); I < N; ++I) 945 ArgTypes.push_back(Proto->getArgType(I)); 946 947 ExpectedFunctionType 948 = Context.getFunctionType(Context.VoidTy, ArgTypes.data(), 949 ArgTypes.size(), 950 Proto->isVariadic(), 951 0, false, false, 0, 0, false, CC_Default); 952 } 953 954 for (LookupResult::iterator D = FoundDelete.begin(), 955 DEnd = FoundDelete.end(); 956 D != DEnd; ++D) { 957 FunctionDecl *Fn = 0; 958 if (FunctionTemplateDecl *FnTmpl 959 = dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) { 960 // Perform template argument deduction to try to match the 961 // expected function type. 962 TemplateDeductionInfo Info(Context, StartLoc); 963 if (DeduceTemplateArguments(FnTmpl, 0, ExpectedFunctionType, Fn, Info)) 964 continue; 965 } else 966 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl()); 967 968 if (Context.hasSameType(Fn->getType(), ExpectedFunctionType)) 969 Matches.push_back(std::make_pair(D.getPair(), Fn)); 970 } 971 } else { 972 // C++ [expr.new]p20: 973 // [...] Any non-placement deallocation function matches a 974 // non-placement allocation function. [...] 975 for (LookupResult::iterator D = FoundDelete.begin(), 976 DEnd = FoundDelete.end(); 977 D != DEnd; ++D) { 978 if (FunctionDecl *Fn = dyn_cast<FunctionDecl>((*D)->getUnderlyingDecl())) 979 if (isNonPlacementDeallocationFunction(Fn)) 980 Matches.push_back(std::make_pair(D.getPair(), Fn)); 981 } 982 } 983 984 // C++ [expr.new]p20: 985 // [...] If the lookup finds a single matching deallocation 986 // function, that function will be called; otherwise, no 987 // deallocation function will be called. 988 if (Matches.size() == 1) { 989 OperatorDelete = Matches[0].second; 990 991 // C++0x [expr.new]p20: 992 // If the lookup finds the two-parameter form of a usual 993 // deallocation function (3.7.4.2) and that function, considered 994 // as a placement deallocation function, would have been 995 // selected as a match for the allocation function, the program 996 // is ill-formed. 997 if (NumPlaceArgs && getLangOptions().CPlusPlus0x && 998 isNonPlacementDeallocationFunction(OperatorDelete)) { 999 Diag(StartLoc, diag::err_placement_new_non_placement_delete) 1000 << SourceRange(PlaceArgs[0]->getLocStart(), 1001 PlaceArgs[NumPlaceArgs - 1]->getLocEnd()); 1002 Diag(OperatorDelete->getLocation(), diag::note_previous_decl) 1003 << DeleteName; 1004 } else { 1005 CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(), 1006 Matches[0].first); 1007 } 1008 } 1009 1010 return false; 1011} 1012 1013/// FindAllocationOverload - Find an fitting overload for the allocation 1014/// function in the specified scope. 1015bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range, 1016 DeclarationName Name, Expr** Args, 1017 unsigned NumArgs, DeclContext *Ctx, 1018 bool AllowMissing, FunctionDecl *&Operator) { 1019 LookupResult R(*this, Name, StartLoc, LookupOrdinaryName); 1020 LookupQualifiedName(R, Ctx); 1021 if (R.empty()) { 1022 if (AllowMissing) 1023 return false; 1024 return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call) 1025 << Name << Range; 1026 } 1027 1028 if (R.isAmbiguous()) 1029 return true; 1030 1031 R.suppressDiagnostics(); 1032 1033 OverloadCandidateSet Candidates(StartLoc); 1034 for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end(); 1035 Alloc != AllocEnd; ++Alloc) { 1036 // Even member operator new/delete are implicitly treated as 1037 // static, so don't use AddMemberCandidate. 1038 NamedDecl *D = (*Alloc)->getUnderlyingDecl(); 1039 1040 if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) { 1041 AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(), 1042 /*ExplicitTemplateArgs=*/0, Args, NumArgs, 1043 Candidates, 1044 /*SuppressUserConversions=*/false); 1045 continue; 1046 } 1047 1048 FunctionDecl *Fn = cast<FunctionDecl>(D); 1049 AddOverloadCandidate(Fn, Alloc.getPair(), Args, NumArgs, Candidates, 1050 /*SuppressUserConversions=*/false); 1051 } 1052 1053 // Do the resolution. 1054 OverloadCandidateSet::iterator Best; 1055 switch(BestViableFunction(Candidates, StartLoc, Best)) { 1056 case OR_Success: { 1057 // Got one! 1058 FunctionDecl *FnDecl = Best->Function; 1059 // The first argument is size_t, and the first parameter must be size_t, 1060 // too. This is checked on declaration and can be assumed. (It can't be 1061 // asserted on, though, since invalid decls are left in there.) 1062 // Watch out for variadic allocator function. 1063 unsigned NumArgsInFnDecl = FnDecl->getNumParams(); 1064 for (unsigned i = 0; (i < NumArgs && i < NumArgsInFnDecl); ++i) { 1065 OwningExprResult Result 1066 = PerformCopyInitialization(InitializedEntity::InitializeParameter( 1067 FnDecl->getParamDecl(i)), 1068 SourceLocation(), 1069 Owned(Args[i]->Retain())); 1070 if (Result.isInvalid()) 1071 return true; 1072 1073 Args[i] = Result.takeAs<Expr>(); 1074 } 1075 Operator = FnDecl; 1076 CheckAllocationAccess(StartLoc, Range, R.getNamingClass(), Best->FoundDecl); 1077 return false; 1078 } 1079 1080 case OR_No_Viable_Function: 1081 Diag(StartLoc, diag::err_ovl_no_viable_function_in_call) 1082 << Name << Range; 1083 PrintOverloadCandidates(Candidates, OCD_AllCandidates, Args, NumArgs); 1084 return true; 1085 1086 case OR_Ambiguous: 1087 Diag(StartLoc, diag::err_ovl_ambiguous_call) 1088 << Name << Range; 1089 PrintOverloadCandidates(Candidates, OCD_ViableCandidates, Args, NumArgs); 1090 return true; 1091 1092 case OR_Deleted: 1093 Diag(StartLoc, diag::err_ovl_deleted_call) 1094 << Best->Function->isDeleted() 1095 << Name << Range; 1096 PrintOverloadCandidates(Candidates, OCD_AllCandidates, Args, NumArgs); 1097 return true; 1098 } 1099 assert(false && "Unreachable, bad result from BestViableFunction"); 1100 return true; 1101} 1102 1103 1104/// DeclareGlobalNewDelete - Declare the global forms of operator new and 1105/// delete. These are: 1106/// @code 1107/// void* operator new(std::size_t) throw(std::bad_alloc); 1108/// void* operator new[](std::size_t) throw(std::bad_alloc); 1109/// void operator delete(void *) throw(); 1110/// void operator delete[](void *) throw(); 1111/// @endcode 1112/// Note that the placement and nothrow forms of new are *not* implicitly 1113/// declared. Their use requires including \<new\>. 1114void Sema::DeclareGlobalNewDelete() { 1115 if (GlobalNewDeleteDeclared) 1116 return; 1117 1118 // C++ [basic.std.dynamic]p2: 1119 // [...] The following allocation and deallocation functions (18.4) are 1120 // implicitly declared in global scope in each translation unit of a 1121 // program 1122 // 1123 // void* operator new(std::size_t) throw(std::bad_alloc); 1124 // void* operator new[](std::size_t) throw(std::bad_alloc); 1125 // void operator delete(void*) throw(); 1126 // void operator delete[](void*) throw(); 1127 // 1128 // These implicit declarations introduce only the function names operator 1129 // new, operator new[], operator delete, operator delete[]. 1130 // 1131 // Here, we need to refer to std::bad_alloc, so we will implicitly declare 1132 // "std" or "bad_alloc" as necessary to form the exception specification. 1133 // However, we do not make these implicit declarations visible to name 1134 // lookup. 1135 if (!StdNamespace) { 1136 // The "std" namespace has not yet been defined, so build one implicitly. 1137 StdNamespace = NamespaceDecl::Create(Context, 1138 Context.getTranslationUnitDecl(), 1139 SourceLocation(), 1140 &PP.getIdentifierTable().get("std")); 1141 StdNamespace->setImplicit(true); 1142 } 1143 1144 if (!StdBadAlloc) { 1145 // The "std::bad_alloc" class has not yet been declared, so build it 1146 // implicitly. 1147 StdBadAlloc = CXXRecordDecl::Create(Context, TagDecl::TK_class, 1148 StdNamespace, 1149 SourceLocation(), 1150 &PP.getIdentifierTable().get("bad_alloc"), 1151 SourceLocation(), 0); 1152 StdBadAlloc->setImplicit(true); 1153 } 1154 1155 GlobalNewDeleteDeclared = true; 1156 1157 QualType VoidPtr = Context.getPointerType(Context.VoidTy); 1158 QualType SizeT = Context.getSizeType(); 1159 bool AssumeSaneOperatorNew = getLangOptions().AssumeSaneOperatorNew; 1160 1161 DeclareGlobalAllocationFunction( 1162 Context.DeclarationNames.getCXXOperatorName(OO_New), 1163 VoidPtr, SizeT, AssumeSaneOperatorNew); 1164 DeclareGlobalAllocationFunction( 1165 Context.DeclarationNames.getCXXOperatorName(OO_Array_New), 1166 VoidPtr, SizeT, AssumeSaneOperatorNew); 1167 DeclareGlobalAllocationFunction( 1168 Context.DeclarationNames.getCXXOperatorName(OO_Delete), 1169 Context.VoidTy, VoidPtr); 1170 DeclareGlobalAllocationFunction( 1171 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete), 1172 Context.VoidTy, VoidPtr); 1173} 1174 1175/// DeclareGlobalAllocationFunction - Declares a single implicit global 1176/// allocation function if it doesn't already exist. 1177void Sema::DeclareGlobalAllocationFunction(DeclarationName Name, 1178 QualType Return, QualType Argument, 1179 bool AddMallocAttr) { 1180 DeclContext *GlobalCtx = Context.getTranslationUnitDecl(); 1181 1182 // Check if this function is already declared. 1183 { 1184 DeclContext::lookup_iterator Alloc, AllocEnd; 1185 for (llvm::tie(Alloc, AllocEnd) = GlobalCtx->lookup(Name); 1186 Alloc != AllocEnd; ++Alloc) { 1187 // Only look at non-template functions, as it is the predefined, 1188 // non-templated allocation function we are trying to declare here. 1189 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) { 1190 QualType InitialParamType = 1191 Context.getCanonicalType( 1192 Func->getParamDecl(0)->getType().getUnqualifiedType()); 1193 // FIXME: Do we need to check for default arguments here? 1194 if (Func->getNumParams() == 1 && InitialParamType == Argument) 1195 return; 1196 } 1197 } 1198 } 1199 1200 QualType BadAllocType; 1201 bool HasBadAllocExceptionSpec 1202 = (Name.getCXXOverloadedOperator() == OO_New || 1203 Name.getCXXOverloadedOperator() == OO_Array_New); 1204 if (HasBadAllocExceptionSpec) { 1205 assert(StdBadAlloc && "Must have std::bad_alloc declared"); 1206 BadAllocType = Context.getTypeDeclType(StdBadAlloc); 1207 } 1208 1209 QualType FnType = Context.getFunctionType(Return, &Argument, 1, false, 0, 1210 true, false, 1211 HasBadAllocExceptionSpec? 1 : 0, 1212 &BadAllocType, false, CC_Default); 1213 FunctionDecl *Alloc = 1214 FunctionDecl::Create(Context, GlobalCtx, SourceLocation(), Name, 1215 FnType, /*TInfo=*/0, FunctionDecl::None, false, true); 1216 Alloc->setImplicit(); 1217 1218 if (AddMallocAttr) 1219 Alloc->addAttr(::new (Context) MallocAttr()); 1220 1221 ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(), 1222 0, Argument, /*TInfo=*/0, 1223 VarDecl::None, 0); 1224 Alloc->setParams(&Param, 1); 1225 1226 // FIXME: Also add this declaration to the IdentifierResolver, but 1227 // make sure it is at the end of the chain to coincide with the 1228 // global scope. 1229 ((DeclContext *)TUScope->getEntity())->addDecl(Alloc); 1230} 1231 1232bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, 1233 DeclarationName Name, 1234 FunctionDecl* &Operator) { 1235 LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName); 1236 // Try to find operator delete/operator delete[] in class scope. 1237 LookupQualifiedName(Found, RD); 1238 1239 if (Found.isAmbiguous()) 1240 return true; 1241 1242 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end(); 1243 F != FEnd; ++F) { 1244 if (CXXMethodDecl *Delete = dyn_cast<CXXMethodDecl>(*F)) 1245 if (Delete->isUsualDeallocationFunction()) { 1246 Operator = Delete; 1247 return false; 1248 } 1249 } 1250 1251 // We did find operator delete/operator delete[] declarations, but 1252 // none of them were suitable. 1253 if (!Found.empty()) { 1254 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found) 1255 << Name << RD; 1256 1257 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end(); 1258 F != FEnd; ++F) { 1259 Diag((*F)->getLocation(), 1260 diag::note_delete_member_function_declared_here) 1261 << Name; 1262 } 1263 1264 return true; 1265 } 1266 1267 // Look for a global declaration. 1268 DeclareGlobalNewDelete(); 1269 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 1270 1271 CXXNullPtrLiteralExpr Null(Context.VoidPtrTy, SourceLocation()); 1272 Expr* DeallocArgs[1]; 1273 DeallocArgs[0] = &Null; 1274 if (FindAllocationOverload(StartLoc, SourceRange(), Name, 1275 DeallocArgs, 1, TUDecl, /*AllowMissing=*/false, 1276 Operator)) 1277 return true; 1278 1279 assert(Operator && "Did not find a deallocation function!"); 1280 return false; 1281} 1282 1283/// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in: 1284/// @code ::delete ptr; @endcode 1285/// or 1286/// @code delete [] ptr; @endcode 1287Action::OwningExprResult 1288Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, 1289 bool ArrayForm, ExprArg Operand) { 1290 // C++ [expr.delete]p1: 1291 // The operand shall have a pointer type, or a class type having a single 1292 // conversion function to a pointer type. The result has type void. 1293 // 1294 // DR599 amends "pointer type" to "pointer to object type" in both cases. 1295 1296 FunctionDecl *OperatorDelete = 0; 1297 1298 Expr *Ex = (Expr *)Operand.get(); 1299 if (!Ex->isTypeDependent()) { 1300 QualType Type = Ex->getType(); 1301 1302 if (const RecordType *Record = Type->getAs<RecordType>()) { 1303 llvm::SmallVector<CXXConversionDecl *, 4> ObjectPtrConversions; 1304 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); 1305 const UnresolvedSetImpl *Conversions = RD->getVisibleConversionFunctions(); 1306 1307 for (UnresolvedSetImpl::iterator I = Conversions->begin(), 1308 E = Conversions->end(); I != E; ++I) { 1309 // Skip over templated conversion functions; they aren't considered. 1310 if (isa<FunctionTemplateDecl>(*I)) 1311 continue; 1312 1313 CXXConversionDecl *Conv = cast<CXXConversionDecl>(*I); 1314 1315 QualType ConvType = Conv->getConversionType().getNonReferenceType(); 1316 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>()) 1317 if (ConvPtrType->getPointeeType()->isObjectType()) 1318 ObjectPtrConversions.push_back(Conv); 1319 } 1320 if (ObjectPtrConversions.size() == 1) { 1321 // We have a single conversion to a pointer-to-object type. Perform 1322 // that conversion. 1323 Operand.release(); 1324 if (!PerformImplicitConversion(Ex, 1325 ObjectPtrConversions.front()->getConversionType(), 1326 AA_Converting)) { 1327 Operand = Owned(Ex); 1328 Type = Ex->getType(); 1329 } 1330 } 1331 else if (ObjectPtrConversions.size() > 1) { 1332 Diag(StartLoc, diag::err_ambiguous_delete_operand) 1333 << Type << Ex->getSourceRange(); 1334 for (unsigned i= 0; i < ObjectPtrConversions.size(); i++) { 1335 CXXConversionDecl *Conv = ObjectPtrConversions[i]; 1336 NoteOverloadCandidate(Conv); 1337 } 1338 return ExprError(); 1339 } 1340 } 1341 1342 if (!Type->isPointerType()) 1343 return ExprError(Diag(StartLoc, diag::err_delete_operand) 1344 << Type << Ex->getSourceRange()); 1345 1346 QualType Pointee = Type->getAs<PointerType>()->getPointeeType(); 1347 if (Pointee->isFunctionType() || Pointee->isVoidType()) 1348 return ExprError(Diag(StartLoc, diag::err_delete_operand) 1349 << Type << Ex->getSourceRange()); 1350 else if (!Pointee->isDependentType() && 1351 RequireCompleteType(StartLoc, Pointee, 1352 PDiag(diag::warn_delete_incomplete) 1353 << Ex->getSourceRange())) 1354 return ExprError(); 1355 1356 // C++ [expr.delete]p2: 1357 // [Note: a pointer to a const type can be the operand of a 1358 // delete-expression; it is not necessary to cast away the constness 1359 // (5.2.11) of the pointer expression before it is used as the operand 1360 // of the delete-expression. ] 1361 ImpCastExprToType(Ex, Context.getPointerType(Context.VoidTy), 1362 CastExpr::CK_NoOp); 1363 1364 // Update the operand. 1365 Operand.take(); 1366 Operand = ExprArg(*this, Ex); 1367 1368 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName( 1369 ArrayForm ? OO_Array_Delete : OO_Delete); 1370 1371 if (const RecordType *RT = Pointee->getAs<RecordType>()) { 1372 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1373 1374 if (!UseGlobal && 1375 FindDeallocationFunction(StartLoc, RD, DeleteName, OperatorDelete)) 1376 return ExprError(); 1377 1378 if (!RD->hasTrivialDestructor()) 1379 if (const CXXDestructorDecl *Dtor = RD->getDestructor(Context)) 1380 MarkDeclarationReferenced(StartLoc, 1381 const_cast<CXXDestructorDecl*>(Dtor)); 1382 } 1383 1384 if (!OperatorDelete) { 1385 // Look for a global declaration. 1386 DeclareGlobalNewDelete(); 1387 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 1388 if (FindAllocationOverload(StartLoc, SourceRange(), DeleteName, 1389 &Ex, 1, TUDecl, /*AllowMissing=*/false, 1390 OperatorDelete)) 1391 return ExprError(); 1392 } 1393 1394 // FIXME: Check access and ambiguity of operator delete and destructor. 1395 } 1396 1397 Operand.release(); 1398 return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm, 1399 OperatorDelete, Ex, StartLoc)); 1400} 1401 1402/// \brief Check the use of the given variable as a C++ condition in an if, 1403/// while, do-while, or switch statement. 1404Action::OwningExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar) { 1405 QualType T = ConditionVar->getType(); 1406 1407 // C++ [stmt.select]p2: 1408 // The declarator shall not specify a function or an array. 1409 if (T->isFunctionType()) 1410 return ExprError(Diag(ConditionVar->getLocation(), 1411 diag::err_invalid_use_of_function_type) 1412 << ConditionVar->getSourceRange()); 1413 else if (T->isArrayType()) 1414 return ExprError(Diag(ConditionVar->getLocation(), 1415 diag::err_invalid_use_of_array_type) 1416 << ConditionVar->getSourceRange()); 1417 1418 return Owned(DeclRefExpr::Create(Context, 0, SourceRange(), ConditionVar, 1419 ConditionVar->getLocation(), 1420 ConditionVar->getType().getNonReferenceType())); 1421} 1422 1423/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid. 1424bool Sema::CheckCXXBooleanCondition(Expr *&CondExpr) { 1425 // C++ 6.4p4: 1426 // The value of a condition that is an initialized declaration in a statement 1427 // other than a switch statement is the value of the declared variable 1428 // implicitly converted to type bool. If that conversion is ill-formed, the 1429 // program is ill-formed. 1430 // The value of a condition that is an expression is the value of the 1431 // expression, implicitly converted to bool. 1432 // 1433 return PerformContextuallyConvertToBool(CondExpr); 1434} 1435 1436/// Helper function to determine whether this is the (deprecated) C++ 1437/// conversion from a string literal to a pointer to non-const char or 1438/// non-const wchar_t (for narrow and wide string literals, 1439/// respectively). 1440bool 1441Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) { 1442 // Look inside the implicit cast, if it exists. 1443 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From)) 1444 From = Cast->getSubExpr(); 1445 1446 // A string literal (2.13.4) that is not a wide string literal can 1447 // be converted to an rvalue of type "pointer to char"; a wide 1448 // string literal can be converted to an rvalue of type "pointer 1449 // to wchar_t" (C++ 4.2p2). 1450 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From)) 1451 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) 1452 if (const BuiltinType *ToPointeeType 1453 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) { 1454 // This conversion is considered only when there is an 1455 // explicit appropriate pointer target type (C++ 4.2p2). 1456 if (!ToPtrType->getPointeeType().hasQualifiers() && 1457 ((StrLit->isWide() && ToPointeeType->isWideCharType()) || 1458 (!StrLit->isWide() && 1459 (ToPointeeType->getKind() == BuiltinType::Char_U || 1460 ToPointeeType->getKind() == BuiltinType::Char_S)))) 1461 return true; 1462 } 1463 1464 return false; 1465} 1466 1467/// PerformImplicitConversion - Perform an implicit conversion of the 1468/// expression From to the type ToType. Returns true if there was an 1469/// error, false otherwise. The expression From is replaced with the 1470/// converted expression. Flavor is the kind of conversion we're 1471/// performing, used in the error message. If @p AllowExplicit, 1472/// explicit user-defined conversions are permitted. @p Elidable should be true 1473/// when called for copies which may be elided (C++ 12.8p15). C++0x overload 1474/// resolution works differently in that case. 1475bool 1476Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1477 AssignmentAction Action, bool AllowExplicit, 1478 bool Elidable) { 1479 ImplicitConversionSequence ICS; 1480 return PerformImplicitConversion(From, ToType, Action, AllowExplicit, 1481 Elidable, ICS); 1482} 1483 1484bool 1485Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1486 AssignmentAction Action, bool AllowExplicit, 1487 bool Elidable, 1488 ImplicitConversionSequence& ICS) { 1489 ICS.setBad(BadConversionSequence::no_conversion, From, ToType); 1490 if (Elidable && getLangOptions().CPlusPlus0x) { 1491 ICS = TryImplicitConversion(From, ToType, 1492 /*SuppressUserConversions=*/false, 1493 AllowExplicit, 1494 /*ForceRValue=*/true, 1495 /*InOverloadResolution=*/false); 1496 } 1497 if (ICS.isBad()) { 1498 ICS = TryImplicitConversion(From, ToType, 1499 /*SuppressUserConversions=*/false, 1500 AllowExplicit, 1501 /*ForceRValue=*/false, 1502 /*InOverloadResolution=*/false); 1503 } 1504 return PerformImplicitConversion(From, ToType, ICS, Action); 1505} 1506 1507/// PerformImplicitConversion - Perform an implicit conversion of the 1508/// expression From to the type ToType using the pre-computed implicit 1509/// conversion sequence ICS. Returns true if there was an error, false 1510/// otherwise. The expression From is replaced with the converted 1511/// expression. Action is the kind of conversion we're performing, 1512/// used in the error message. 1513bool 1514Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1515 const ImplicitConversionSequence &ICS, 1516 AssignmentAction Action, bool IgnoreBaseAccess) { 1517 switch (ICS.getKind()) { 1518 case ImplicitConversionSequence::StandardConversion: 1519 if (PerformImplicitConversion(From, ToType, ICS.Standard, Action, 1520 IgnoreBaseAccess)) 1521 return true; 1522 break; 1523 1524 case ImplicitConversionSequence::UserDefinedConversion: { 1525 1526 FunctionDecl *FD = ICS.UserDefined.ConversionFunction; 1527 CastExpr::CastKind CastKind = CastExpr::CK_Unknown; 1528 QualType BeforeToType; 1529 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) { 1530 CastKind = CastExpr::CK_UserDefinedConversion; 1531 1532 // If the user-defined conversion is specified by a conversion function, 1533 // the initial standard conversion sequence converts the source type to 1534 // the implicit object parameter of the conversion function. 1535 BeforeToType = Context.getTagDeclType(Conv->getParent()); 1536 } else if (const CXXConstructorDecl *Ctor = 1537 dyn_cast<CXXConstructorDecl>(FD)) { 1538 CastKind = CastExpr::CK_ConstructorConversion; 1539 // Do no conversion if dealing with ... for the first conversion. 1540 if (!ICS.UserDefined.EllipsisConversion) { 1541 // If the user-defined conversion is specified by a constructor, the 1542 // initial standard conversion sequence converts the source type to the 1543 // type required by the argument of the constructor 1544 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType(); 1545 } 1546 } 1547 else 1548 assert(0 && "Unknown conversion function kind!"); 1549 // Whatch out for elipsis conversion. 1550 if (!ICS.UserDefined.EllipsisConversion) { 1551 if (PerformImplicitConversion(From, BeforeToType, 1552 ICS.UserDefined.Before, AA_Converting, 1553 IgnoreBaseAccess)) 1554 return true; 1555 } 1556 1557 OwningExprResult CastArg 1558 = BuildCXXCastArgument(From->getLocStart(), 1559 ToType.getNonReferenceType(), 1560 CastKind, cast<CXXMethodDecl>(FD), 1561 Owned(From)); 1562 1563 if (CastArg.isInvalid()) 1564 return true; 1565 1566 From = CastArg.takeAs<Expr>(); 1567 1568 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After, 1569 AA_Converting, IgnoreBaseAccess); 1570 } 1571 1572 case ImplicitConversionSequence::AmbiguousConversion: 1573 DiagnoseAmbiguousConversion(ICS, From->getExprLoc(), 1574 PDiag(diag::err_typecheck_ambiguous_condition) 1575 << From->getSourceRange()); 1576 return true; 1577 1578 case ImplicitConversionSequence::EllipsisConversion: 1579 assert(false && "Cannot perform an ellipsis conversion"); 1580 return false; 1581 1582 case ImplicitConversionSequence::BadConversion: 1583 return true; 1584 } 1585 1586 // Everything went well. 1587 return false; 1588} 1589 1590/// PerformImplicitConversion - Perform an implicit conversion of the 1591/// expression From to the type ToType by following the standard 1592/// conversion sequence SCS. Returns true if there was an error, false 1593/// otherwise. The expression From is replaced with the converted 1594/// expression. Flavor is the context in which we're performing this 1595/// conversion, for use in error messages. 1596bool 1597Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1598 const StandardConversionSequence& SCS, 1599 AssignmentAction Action, bool IgnoreBaseAccess) { 1600 // Overall FIXME: we are recomputing too many types here and doing far too 1601 // much extra work. What this means is that we need to keep track of more 1602 // information that is computed when we try the implicit conversion initially, 1603 // so that we don't need to recompute anything here. 1604 QualType FromType = From->getType(); 1605 1606 if (SCS.CopyConstructor) { 1607 // FIXME: When can ToType be a reference type? 1608 assert(!ToType->isReferenceType()); 1609 if (SCS.Second == ICK_Derived_To_Base) { 1610 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this); 1611 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor), 1612 MultiExprArg(*this, (void **)&From, 1), 1613 /*FIXME:ConstructLoc*/SourceLocation(), 1614 ConstructorArgs)) 1615 return true; 1616 OwningExprResult FromResult = 1617 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 1618 ToType, SCS.CopyConstructor, 1619 move_arg(ConstructorArgs)); 1620 if (FromResult.isInvalid()) 1621 return true; 1622 From = FromResult.takeAs<Expr>(); 1623 return false; 1624 } 1625 OwningExprResult FromResult = 1626 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 1627 ToType, SCS.CopyConstructor, 1628 MultiExprArg(*this, (void**)&From, 1)); 1629 1630 if (FromResult.isInvalid()) 1631 return true; 1632 1633 From = FromResult.takeAs<Expr>(); 1634 return false; 1635 } 1636 1637 // Perform the first implicit conversion. 1638 switch (SCS.First) { 1639 case ICK_Identity: 1640 case ICK_Lvalue_To_Rvalue: 1641 // Nothing to do. 1642 break; 1643 1644 case ICK_Array_To_Pointer: 1645 FromType = Context.getArrayDecayedType(FromType); 1646 ImpCastExprToType(From, FromType, CastExpr::CK_ArrayToPointerDecay); 1647 break; 1648 1649 case ICK_Function_To_Pointer: 1650 if (Context.getCanonicalType(FromType) == Context.OverloadTy) { 1651 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, true); 1652 if (!Fn) 1653 return true; 1654 1655 if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin())) 1656 return true; 1657 1658 From = FixOverloadedFunctionReference(From, Fn); 1659 FromType = From->getType(); 1660 1661 // If there's already an address-of operator in the expression, we have 1662 // the right type already, and the code below would just introduce an 1663 // invalid additional pointer level. 1664 if (FromType->isPointerType() || FromType->isMemberFunctionPointerType()) 1665 break; 1666 } 1667 FromType = Context.getPointerType(FromType); 1668 ImpCastExprToType(From, FromType, CastExpr::CK_FunctionToPointerDecay); 1669 break; 1670 1671 default: 1672 assert(false && "Improper first standard conversion"); 1673 break; 1674 } 1675 1676 // Perform the second implicit conversion 1677 switch (SCS.Second) { 1678 case ICK_Identity: 1679 // If both sides are functions (or pointers/references to them), there could 1680 // be incompatible exception declarations. 1681 if (CheckExceptionSpecCompatibility(From, ToType)) 1682 return true; 1683 // Nothing else to do. 1684 break; 1685 1686 case ICK_NoReturn_Adjustment: 1687 // If both sides are functions (or pointers/references to them), there could 1688 // be incompatible exception declarations. 1689 if (CheckExceptionSpecCompatibility(From, ToType)) 1690 return true; 1691 1692 ImpCastExprToType(From, Context.getNoReturnType(From->getType(), false), 1693 CastExpr::CK_NoOp); 1694 break; 1695 1696 case ICK_Integral_Promotion: 1697 case ICK_Integral_Conversion: 1698 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralCast); 1699 break; 1700 1701 case ICK_Floating_Promotion: 1702 case ICK_Floating_Conversion: 1703 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingCast); 1704 break; 1705 1706 case ICK_Complex_Promotion: 1707 case ICK_Complex_Conversion: 1708 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown); 1709 break; 1710 1711 case ICK_Floating_Integral: 1712 if (ToType->isFloatingType()) 1713 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralToFloating); 1714 else 1715 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingToIntegral); 1716 break; 1717 1718 case ICK_Complex_Real: 1719 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown); 1720 break; 1721 1722 case ICK_Compatible_Conversion: 1723 ImpCastExprToType(From, ToType, CastExpr::CK_NoOp); 1724 break; 1725 1726 case ICK_Pointer_Conversion: { 1727 if (SCS.IncompatibleObjC) { 1728 // Diagnose incompatible Objective-C conversions 1729 Diag(From->getSourceRange().getBegin(), 1730 diag::ext_typecheck_convert_incompatible_pointer) 1731 << From->getType() << ToType << Action 1732 << From->getSourceRange(); 1733 } 1734 1735 1736 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1737 if (CheckPointerConversion(From, ToType, Kind, IgnoreBaseAccess)) 1738 return true; 1739 ImpCastExprToType(From, ToType, Kind); 1740 break; 1741 } 1742 1743 case ICK_Pointer_Member: { 1744 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1745 if (CheckMemberPointerConversion(From, ToType, Kind, IgnoreBaseAccess)) 1746 return true; 1747 if (CheckExceptionSpecCompatibility(From, ToType)) 1748 return true; 1749 ImpCastExprToType(From, ToType, Kind); 1750 break; 1751 } 1752 case ICK_Boolean_Conversion: { 1753 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1754 if (FromType->isMemberPointerType()) 1755 Kind = CastExpr::CK_MemberPointerToBoolean; 1756 1757 ImpCastExprToType(From, Context.BoolTy, Kind); 1758 break; 1759 } 1760 1761 case ICK_Derived_To_Base: 1762 if (CheckDerivedToBaseConversion(From->getType(), 1763 ToType.getNonReferenceType(), 1764 From->getLocStart(), 1765 From->getSourceRange(), 1766 IgnoreBaseAccess)) 1767 return true; 1768 ImpCastExprToType(From, ToType.getNonReferenceType(), 1769 CastExpr::CK_DerivedToBase); 1770 break; 1771 1772 default: 1773 assert(false && "Improper second standard conversion"); 1774 break; 1775 } 1776 1777 switch (SCS.Third) { 1778 case ICK_Identity: 1779 // Nothing to do. 1780 break; 1781 1782 case ICK_Qualification: 1783 // FIXME: Not sure about lvalue vs rvalue here in the presence of rvalue 1784 // references. 1785 ImpCastExprToType(From, ToType.getNonReferenceType(), 1786 CastExpr::CK_NoOp, 1787 ToType->isLValueReferenceType()); 1788 1789 if (SCS.DeprecatedStringLiteralToCharPtr) 1790 Diag(From->getLocStart(), diag::warn_deprecated_string_literal_conversion) 1791 << ToType.getNonReferenceType(); 1792 1793 break; 1794 1795 default: 1796 assert(false && "Improper second standard conversion"); 1797 break; 1798 } 1799 1800 return false; 1801} 1802 1803Sema::OwningExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait OTT, 1804 SourceLocation KWLoc, 1805 SourceLocation LParen, 1806 TypeTy *Ty, 1807 SourceLocation RParen) { 1808 QualType T = GetTypeFromParser(Ty); 1809 1810 // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html 1811 // all traits except __is_class, __is_enum and __is_union require a the type 1812 // to be complete. 1813 if (OTT != UTT_IsClass && OTT != UTT_IsEnum && OTT != UTT_IsUnion) { 1814 if (RequireCompleteType(KWLoc, T, 1815 diag::err_incomplete_type_used_in_type_trait_expr)) 1816 return ExprError(); 1817 } 1818 1819 // There is no point in eagerly computing the value. The traits are designed 1820 // to be used from type trait templates, so Ty will be a template parameter 1821 // 99% of the time. 1822 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, OTT, T, 1823 RParen, Context.BoolTy)); 1824} 1825 1826QualType Sema::CheckPointerToMemberOperands( 1827 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isIndirect) { 1828 const char *OpSpelling = isIndirect ? "->*" : ".*"; 1829 // C++ 5.5p2 1830 // The binary operator .* [p3: ->*] binds its second operand, which shall 1831 // be of type "pointer to member of T" (where T is a completely-defined 1832 // class type) [...] 1833 QualType RType = rex->getType(); 1834 const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>(); 1835 if (!MemPtr) { 1836 Diag(Loc, diag::err_bad_memptr_rhs) 1837 << OpSpelling << RType << rex->getSourceRange(); 1838 return QualType(); 1839 } 1840 1841 QualType Class(MemPtr->getClass(), 0); 1842 1843 // C++ 5.5p2 1844 // [...] to its first operand, which shall be of class T or of a class of 1845 // which T is an unambiguous and accessible base class. [p3: a pointer to 1846 // such a class] 1847 QualType LType = lex->getType(); 1848 if (isIndirect) { 1849 if (const PointerType *Ptr = LType->getAs<PointerType>()) 1850 LType = Ptr->getPointeeType().getNonReferenceType(); 1851 else { 1852 Diag(Loc, diag::err_bad_memptr_lhs) 1853 << OpSpelling << 1 << LType 1854 << CodeModificationHint::CreateReplacement(SourceRange(Loc), ".*"); 1855 return QualType(); 1856 } 1857 } 1858 1859 if (!Context.hasSameUnqualifiedType(Class, LType)) { 1860 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false, 1861 /*DetectVirtual=*/false); 1862 // FIXME: Would it be useful to print full ambiguity paths, or is that 1863 // overkill? 1864 if (!IsDerivedFrom(LType, Class, Paths) || 1865 Paths.isAmbiguous(Context.getCanonicalType(Class))) { 1866 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling 1867 << (int)isIndirect << lex->getType(); 1868 return QualType(); 1869 } 1870 // Cast LHS to type of use. 1871 QualType UseType = isIndirect ? Context.getPointerType(Class) : Class; 1872 bool isLValue = !isIndirect && lex->isLvalue(Context) == Expr::LV_Valid; 1873 ImpCastExprToType(lex, UseType, CastExpr::CK_DerivedToBase, isLValue); 1874 } 1875 1876 if (isa<CXXZeroInitValueExpr>(rex->IgnoreParens())) { 1877 // Diagnose use of pointer-to-member type which when used as 1878 // the functional cast in a pointer-to-member expression. 1879 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect; 1880 return QualType(); 1881 } 1882 // C++ 5.5p2 1883 // The result is an object or a function of the type specified by the 1884 // second operand. 1885 // The cv qualifiers are the union of those in the pointer and the left side, 1886 // in accordance with 5.5p5 and 5.2.5. 1887 // FIXME: This returns a dereferenced member function pointer as a normal 1888 // function type. However, the only operation valid on such functions is 1889 // calling them. There's also a GCC extension to get a function pointer to the 1890 // thing, which is another complication, because this type - unlike the type 1891 // that is the result of this expression - takes the class as the first 1892 // argument. 1893 // We probably need a "MemberFunctionClosureType" or something like that. 1894 QualType Result = MemPtr->getPointeeType(); 1895 Result = Context.getCVRQualifiedType(Result, LType.getCVRQualifiers()); 1896 return Result; 1897} 1898 1899/// \brief Get the target type of a standard or user-defined conversion. 1900static QualType TargetType(const ImplicitConversionSequence &ICS) { 1901 switch (ICS.getKind()) { 1902 case ImplicitConversionSequence::StandardConversion: 1903 return ICS.Standard.getToType(2); 1904 case ImplicitConversionSequence::UserDefinedConversion: 1905 return ICS.UserDefined.After.getToType(2); 1906 case ImplicitConversionSequence::AmbiguousConversion: 1907 return ICS.Ambiguous.getToType(); 1908 1909 case ImplicitConversionSequence::EllipsisConversion: 1910 case ImplicitConversionSequence::BadConversion: 1911 llvm_unreachable("function not valid for ellipsis or bad conversions"); 1912 } 1913 return QualType(); // silence warnings 1914} 1915 1916/// \brief Try to convert a type to another according to C++0x 5.16p3. 1917/// 1918/// This is part of the parameter validation for the ? operator. If either 1919/// value operand is a class type, the two operands are attempted to be 1920/// converted to each other. This function does the conversion in one direction. 1921/// It returns true if the program is ill-formed and has already been diagnosed 1922/// as such. 1923static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, 1924 SourceLocation QuestionLoc, 1925 bool &HaveConversion, 1926 QualType &ToType) { 1927 HaveConversion = false; 1928 ToType = To->getType(); 1929 1930 InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(), 1931 SourceLocation()); 1932 // C++0x 5.16p3 1933 // The process for determining whether an operand expression E1 of type T1 1934 // can be converted to match an operand expression E2 of type T2 is defined 1935 // as follows: 1936 // -- If E2 is an lvalue: 1937 if (To->isLvalue(Self.Context) == Expr::LV_Valid) { 1938 // E1 can be converted to match E2 if E1 can be implicitly converted to 1939 // type "lvalue reference to T2", subject to the constraint that in the 1940 // conversion the reference must bind directly to E1. 1941 QualType T = Self.Context.getLValueReferenceType(ToType); 1942 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 1943 1944 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 1945 if (InitSeq.isDirectReferenceBinding()) { 1946 ToType = T; 1947 HaveConversion = true; 1948 return false; 1949 } 1950 1951 if (InitSeq.isAmbiguous()) 1952 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 1953 } 1954 1955 // -- If E2 is an rvalue, or if the conversion above cannot be done: 1956 // -- if E1 and E2 have class type, and the underlying class types are 1957 // the same or one is a base class of the other: 1958 QualType FTy = From->getType(); 1959 QualType TTy = To->getType(); 1960 const RecordType *FRec = FTy->getAs<RecordType>(); 1961 const RecordType *TRec = TTy->getAs<RecordType>(); 1962 bool FDerivedFromT = FRec && TRec && FRec != TRec && 1963 Self.IsDerivedFrom(FTy, TTy); 1964 if (FRec && TRec && 1965 (FRec == TRec || FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) { 1966 // E1 can be converted to match E2 if the class of T2 is the 1967 // same type as, or a base class of, the class of T1, and 1968 // [cv2 > cv1]. 1969 if (FRec == TRec || FDerivedFromT) { 1970 if (TTy.isAtLeastAsQualifiedAs(FTy)) { 1971 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 1972 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 1973 if (InitSeq.getKind() != InitializationSequence::FailedSequence) { 1974 HaveConversion = true; 1975 return false; 1976 } 1977 1978 if (InitSeq.isAmbiguous()) 1979 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 1980 } 1981 } 1982 1983 return false; 1984 } 1985 1986 // -- Otherwise: E1 can be converted to match E2 if E1 can be 1987 // implicitly converted to the type that expression E2 would have 1988 // if E2 were converted to an rvalue. 1989 // First find the decayed type. 1990 if (TTy->isFunctionType()) 1991 TTy = Self.Context.getPointerType(TTy); 1992 else if (TTy->isArrayType()) 1993 TTy = Self.Context.getArrayDecayedType(TTy); 1994 1995 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 1996 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 1997 HaveConversion = InitSeq.getKind() != InitializationSequence::FailedSequence; 1998 ToType = TTy; 1999 if (InitSeq.isAmbiguous()) 2000 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 2001 2002 return false; 2003} 2004 2005/// \brief Try to find a common type for two according to C++0x 5.16p5. 2006/// 2007/// This is part of the parameter validation for the ? operator. If either 2008/// value operand is a class type, overload resolution is used to find a 2009/// conversion to a common type. 2010static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS, 2011 SourceLocation Loc) { 2012 Expr *Args[2] = { LHS, RHS }; 2013 OverloadCandidateSet CandidateSet(Loc); 2014 Self.AddBuiltinOperatorCandidates(OO_Conditional, Loc, Args, 2, CandidateSet); 2015 2016 OverloadCandidateSet::iterator Best; 2017 switch (Self.BestViableFunction(CandidateSet, Loc, Best)) { 2018 case OR_Success: 2019 // We found a match. Perform the conversions on the arguments and move on. 2020 if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0], 2021 Best->Conversions[0], Sema::AA_Converting) || 2022 Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1], 2023 Best->Conversions[1], Sema::AA_Converting)) 2024 break; 2025 return false; 2026 2027 case OR_No_Viable_Function: 2028 Self.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 2029 << LHS->getType() << RHS->getType() 2030 << LHS->getSourceRange() << RHS->getSourceRange(); 2031 return true; 2032 2033 case OR_Ambiguous: 2034 Self.Diag(Loc, diag::err_conditional_ambiguous_ovl) 2035 << LHS->getType() << RHS->getType() 2036 << LHS->getSourceRange() << RHS->getSourceRange(); 2037 // FIXME: Print the possible common types by printing the return types of 2038 // the viable candidates. 2039 break; 2040 2041 case OR_Deleted: 2042 assert(false && "Conditional operator has only built-in overloads"); 2043 break; 2044 } 2045 return true; 2046} 2047 2048/// \brief Perform an "extended" implicit conversion as returned by 2049/// TryClassUnification. 2050static bool ConvertForConditional(Sema &Self, Expr *&E, QualType T) { 2051 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 2052 InitializationKind Kind = InitializationKind::CreateCopy(E->getLocStart(), 2053 SourceLocation()); 2054 InitializationSequence InitSeq(Self, Entity, Kind, &E, 1); 2055 Sema::OwningExprResult Result = InitSeq.Perform(Self, Entity, Kind, 2056 Sema::MultiExprArg(Self, (void **)&E, 1)); 2057 if (Result.isInvalid()) 2058 return true; 2059 2060 E = Result.takeAs<Expr>(); 2061 return false; 2062} 2063 2064/// \brief Check the operands of ?: under C++ semantics. 2065/// 2066/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y 2067/// extension. In this case, LHS == Cond. (But they're not aliases.) 2068QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, 2069 SourceLocation QuestionLoc) { 2070 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++ 2071 // interface pointers. 2072 2073 // C++0x 5.16p1 2074 // The first expression is contextually converted to bool. 2075 if (!Cond->isTypeDependent()) { 2076 if (CheckCXXBooleanCondition(Cond)) 2077 return QualType(); 2078 } 2079 2080 // Either of the arguments dependent? 2081 if (LHS->isTypeDependent() || RHS->isTypeDependent()) 2082 return Context.DependentTy; 2083 2084 CheckSignCompare(LHS, RHS, QuestionLoc); 2085 2086 // C++0x 5.16p2 2087 // If either the second or the third operand has type (cv) void, ... 2088 QualType LTy = LHS->getType(); 2089 QualType RTy = RHS->getType(); 2090 bool LVoid = LTy->isVoidType(); 2091 bool RVoid = RTy->isVoidType(); 2092 if (LVoid || RVoid) { 2093 // ... then the [l2r] conversions are performed on the second and third 2094 // operands ... 2095 DefaultFunctionArrayLvalueConversion(LHS); 2096 DefaultFunctionArrayLvalueConversion(RHS); 2097 LTy = LHS->getType(); 2098 RTy = RHS->getType(); 2099 2100 // ... and one of the following shall hold: 2101 // -- The second or the third operand (but not both) is a throw- 2102 // expression; the result is of the type of the other and is an rvalue. 2103 bool LThrow = isa<CXXThrowExpr>(LHS); 2104 bool RThrow = isa<CXXThrowExpr>(RHS); 2105 if (LThrow && !RThrow) 2106 return RTy; 2107 if (RThrow && !LThrow) 2108 return LTy; 2109 2110 // -- Both the second and third operands have type void; the result is of 2111 // type void and is an rvalue. 2112 if (LVoid && RVoid) 2113 return Context.VoidTy; 2114 2115 // Neither holds, error. 2116 Diag(QuestionLoc, diag::err_conditional_void_nonvoid) 2117 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1) 2118 << LHS->getSourceRange() << RHS->getSourceRange(); 2119 return QualType(); 2120 } 2121 2122 // Neither is void. 2123 2124 // C++0x 5.16p3 2125 // Otherwise, if the second and third operand have different types, and 2126 // either has (cv) class type, and attempt is made to convert each of those 2127 // operands to the other. 2128 if (!Context.hasSameType(LTy, RTy) && 2129 (LTy->isRecordType() || RTy->isRecordType())) { 2130 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft; 2131 // These return true if a single direction is already ambiguous. 2132 QualType L2RType, R2LType; 2133 bool HaveL2R, HaveR2L; 2134 if (TryClassUnification(*this, LHS, RHS, QuestionLoc, HaveL2R, L2RType)) 2135 return QualType(); 2136 if (TryClassUnification(*this, RHS, LHS, QuestionLoc, HaveR2L, R2LType)) 2137 return QualType(); 2138 2139 // If both can be converted, [...] the program is ill-formed. 2140 if (HaveL2R && HaveR2L) { 2141 Diag(QuestionLoc, diag::err_conditional_ambiguous) 2142 << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange(); 2143 return QualType(); 2144 } 2145 2146 // If exactly one conversion is possible, that conversion is applied to 2147 // the chosen operand and the converted operands are used in place of the 2148 // original operands for the remainder of this section. 2149 if (HaveL2R) { 2150 if (ConvertForConditional(*this, LHS, L2RType)) 2151 return QualType(); 2152 LTy = LHS->getType(); 2153 } else if (HaveR2L) { 2154 if (ConvertForConditional(*this, RHS, R2LType)) 2155 return QualType(); 2156 RTy = RHS->getType(); 2157 } 2158 } 2159 2160 // C++0x 5.16p4 2161 // If the second and third operands are lvalues and have the same type, 2162 // the result is of that type [...] 2163 bool Same = Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy); 2164 if (Same && LHS->isLvalue(Context) == Expr::LV_Valid && 2165 RHS->isLvalue(Context) == Expr::LV_Valid) 2166 return LTy; 2167 2168 // C++0x 5.16p5 2169 // Otherwise, the result is an rvalue. If the second and third operands 2170 // do not have the same type, and either has (cv) class type, ... 2171 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) { 2172 // ... overload resolution is used to determine the conversions (if any) 2173 // to be applied to the operands. If the overload resolution fails, the 2174 // program is ill-formed. 2175 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc)) 2176 return QualType(); 2177 } 2178 2179 // C++0x 5.16p6 2180 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard 2181 // conversions are performed on the second and third operands. 2182 DefaultFunctionArrayLvalueConversion(LHS); 2183 DefaultFunctionArrayLvalueConversion(RHS); 2184 LTy = LHS->getType(); 2185 RTy = RHS->getType(); 2186 2187 // After those conversions, one of the following shall hold: 2188 // -- The second and third operands have the same type; the result 2189 // is of that type. 2190 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) 2191 return LTy; 2192 2193 // -- The second and third operands have arithmetic or enumeration type; 2194 // the usual arithmetic conversions are performed to bring them to a 2195 // common type, and the result is of that type. 2196 if (LTy->isArithmeticType() && RTy->isArithmeticType()) { 2197 UsualArithmeticConversions(LHS, RHS); 2198 return LHS->getType(); 2199 } 2200 2201 // -- The second and third operands have pointer type, or one has pointer 2202 // type and the other is a null pointer constant; pointer conversions 2203 // and qualification conversions are performed to bring them to their 2204 // composite pointer type. The result is of the composite pointer type. 2205 // -- The second and third operands have pointer to member type, or one has 2206 // pointer to member type and the other is a null pointer constant; 2207 // pointer to member conversions and qualification conversions are 2208 // performed to bring them to a common type, whose cv-qualification 2209 // shall match the cv-qualification of either the second or the third 2210 // operand. The result is of the common type. 2211 bool NonStandardCompositeType = false; 2212 QualType Composite = FindCompositePointerType(LHS, RHS, 2213 isSFINAEContext()? 0 : &NonStandardCompositeType); 2214 if (!Composite.isNull()) { 2215 if (NonStandardCompositeType) 2216 Diag(QuestionLoc, 2217 diag::ext_typecheck_cond_incompatible_operands_nonstandard) 2218 << LTy << RTy << Composite 2219 << LHS->getSourceRange() << RHS->getSourceRange(); 2220 2221 return Composite; 2222 } 2223 2224 // Similarly, attempt to find composite type of twp objective-c pointers. 2225 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc); 2226 if (!Composite.isNull()) 2227 return Composite; 2228 2229 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 2230 << LHS->getType() << RHS->getType() 2231 << LHS->getSourceRange() << RHS->getSourceRange(); 2232 return QualType(); 2233} 2234 2235/// \brief Find a merged pointer type and convert the two expressions to it. 2236/// 2237/// This finds the composite pointer type (or member pointer type) for @p E1 2238/// and @p E2 according to C++0x 5.9p2. It converts both expressions to this 2239/// type and returns it. 2240/// It does not emit diagnostics. 2241/// 2242/// If \p NonStandardCompositeType is non-NULL, then we are permitted to find 2243/// a non-standard (but still sane) composite type to which both expressions 2244/// can be converted. When such a type is chosen, \c *NonStandardCompositeType 2245/// will be set true. 2246QualType Sema::FindCompositePointerType(Expr *&E1, Expr *&E2, 2247 bool *NonStandardCompositeType) { 2248 if (NonStandardCompositeType) 2249 *NonStandardCompositeType = false; 2250 2251 assert(getLangOptions().CPlusPlus && "This function assumes C++"); 2252 QualType T1 = E1->getType(), T2 = E2->getType(); 2253 2254 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() && 2255 !T2->isAnyPointerType() && !T2->isMemberPointerType()) 2256 return QualType(); 2257 2258 // C++0x 5.9p2 2259 // Pointer conversions and qualification conversions are performed on 2260 // pointer operands to bring them to their composite pointer type. If 2261 // one operand is a null pointer constant, the composite pointer type is 2262 // the type of the other operand. 2263 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 2264 if (T2->isMemberPointerType()) 2265 ImpCastExprToType(E1, T2, CastExpr::CK_NullToMemberPointer); 2266 else 2267 ImpCastExprToType(E1, T2, CastExpr::CK_IntegralToPointer); 2268 return T2; 2269 } 2270 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 2271 if (T1->isMemberPointerType()) 2272 ImpCastExprToType(E2, T1, CastExpr::CK_NullToMemberPointer); 2273 else 2274 ImpCastExprToType(E2, T1, CastExpr::CK_IntegralToPointer); 2275 return T1; 2276 } 2277 2278 // Now both have to be pointers or member pointers. 2279 if ((!T1->isPointerType() && !T1->isMemberPointerType()) || 2280 (!T2->isPointerType() && !T2->isMemberPointerType())) 2281 return QualType(); 2282 2283 // Otherwise, of one of the operands has type "pointer to cv1 void," then 2284 // the other has type "pointer to cv2 T" and the composite pointer type is 2285 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2. 2286 // Otherwise, the composite pointer type is a pointer type similar to the 2287 // type of one of the operands, with a cv-qualification signature that is 2288 // the union of the cv-qualification signatures of the operand types. 2289 // In practice, the first part here is redundant; it's subsumed by the second. 2290 // What we do here is, we build the two possible composite types, and try the 2291 // conversions in both directions. If only one works, or if the two composite 2292 // types are the same, we have succeeded. 2293 // FIXME: extended qualifiers? 2294 typedef llvm::SmallVector<unsigned, 4> QualifierVector; 2295 QualifierVector QualifierUnion; 2296 typedef llvm::SmallVector<std::pair<const Type *, const Type *>, 4> 2297 ContainingClassVector; 2298 ContainingClassVector MemberOfClass; 2299 QualType Composite1 = Context.getCanonicalType(T1), 2300 Composite2 = Context.getCanonicalType(T2); 2301 unsigned NeedConstBefore = 0; 2302 do { 2303 const PointerType *Ptr1, *Ptr2; 2304 if ((Ptr1 = Composite1->getAs<PointerType>()) && 2305 (Ptr2 = Composite2->getAs<PointerType>())) { 2306 Composite1 = Ptr1->getPointeeType(); 2307 Composite2 = Ptr2->getPointeeType(); 2308 2309 // If we're allowed to create a non-standard composite type, keep track 2310 // of where we need to fill in additional 'const' qualifiers. 2311 if (NonStandardCompositeType && 2312 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 2313 NeedConstBefore = QualifierUnion.size(); 2314 2315 QualifierUnion.push_back( 2316 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 2317 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0)); 2318 continue; 2319 } 2320 2321 const MemberPointerType *MemPtr1, *MemPtr2; 2322 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) && 2323 (MemPtr2 = Composite2->getAs<MemberPointerType>())) { 2324 Composite1 = MemPtr1->getPointeeType(); 2325 Composite2 = MemPtr2->getPointeeType(); 2326 2327 // If we're allowed to create a non-standard composite type, keep track 2328 // of where we need to fill in additional 'const' qualifiers. 2329 if (NonStandardCompositeType && 2330 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 2331 NeedConstBefore = QualifierUnion.size(); 2332 2333 QualifierUnion.push_back( 2334 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 2335 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(), 2336 MemPtr2->getClass())); 2337 continue; 2338 } 2339 2340 // FIXME: block pointer types? 2341 2342 // Cannot unwrap any more types. 2343 break; 2344 } while (true); 2345 2346 if (NeedConstBefore && NonStandardCompositeType) { 2347 // Extension: Add 'const' to qualifiers that come before the first qualifier 2348 // mismatch, so that our (non-standard!) composite type meets the 2349 // requirements of C++ [conv.qual]p4 bullet 3. 2350 for (unsigned I = 0; I != NeedConstBefore; ++I) { 2351 if ((QualifierUnion[I] & Qualifiers::Const) == 0) { 2352 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const; 2353 *NonStandardCompositeType = true; 2354 } 2355 } 2356 } 2357 2358 // Rewrap the composites as pointers or member pointers with the union CVRs. 2359 ContainingClassVector::reverse_iterator MOC 2360 = MemberOfClass.rbegin(); 2361 for (QualifierVector::reverse_iterator 2362 I = QualifierUnion.rbegin(), 2363 E = QualifierUnion.rend(); 2364 I != E; (void)++I, ++MOC) { 2365 Qualifiers Quals = Qualifiers::fromCVRMask(*I); 2366 if (MOC->first && MOC->second) { 2367 // Rebuild member pointer type 2368 Composite1 = Context.getMemberPointerType( 2369 Context.getQualifiedType(Composite1, Quals), 2370 MOC->first); 2371 Composite2 = Context.getMemberPointerType( 2372 Context.getQualifiedType(Composite2, Quals), 2373 MOC->second); 2374 } else { 2375 // Rebuild pointer type 2376 Composite1 2377 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals)); 2378 Composite2 2379 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals)); 2380 } 2381 } 2382 2383 ImplicitConversionSequence E1ToC1 = 2384 TryImplicitConversion(E1, Composite1, 2385 /*SuppressUserConversions=*/false, 2386 /*AllowExplicit=*/false, 2387 /*ForceRValue=*/false, 2388 /*InOverloadResolution=*/false); 2389 ImplicitConversionSequence E2ToC1 = 2390 TryImplicitConversion(E2, Composite1, 2391 /*SuppressUserConversions=*/false, 2392 /*AllowExplicit=*/false, 2393 /*ForceRValue=*/false, 2394 /*InOverloadResolution=*/false); 2395 2396 bool ToC2Viable = false; 2397 ImplicitConversionSequence E1ToC2, E2ToC2; 2398 if (Context.getCanonicalType(Composite1) != 2399 Context.getCanonicalType(Composite2)) { 2400 E1ToC2 = TryImplicitConversion(E1, Composite2, 2401 /*SuppressUserConversions=*/false, 2402 /*AllowExplicit=*/false, 2403 /*ForceRValue=*/false, 2404 /*InOverloadResolution=*/false); 2405 E2ToC2 = TryImplicitConversion(E2, Composite2, 2406 /*SuppressUserConversions=*/false, 2407 /*AllowExplicit=*/false, 2408 /*ForceRValue=*/false, 2409 /*InOverloadResolution=*/false); 2410 ToC2Viable = !E1ToC2.isBad() && !E2ToC2.isBad(); 2411 } 2412 2413 bool ToC1Viable = !E1ToC1.isBad() && !E2ToC1.isBad(); 2414 if (ToC1Viable && !ToC2Viable) { 2415 if (!PerformImplicitConversion(E1, Composite1, E1ToC1, Sema::AA_Converting) && 2416 !PerformImplicitConversion(E2, Composite1, E2ToC1, Sema::AA_Converting)) 2417 return Composite1; 2418 } 2419 if (ToC2Viable && !ToC1Viable) { 2420 if (!PerformImplicitConversion(E1, Composite2, E1ToC2, Sema::AA_Converting) && 2421 !PerformImplicitConversion(E2, Composite2, E2ToC2, Sema::AA_Converting)) 2422 return Composite2; 2423 } 2424 return QualType(); 2425} 2426 2427Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) { 2428 if (!Context.getLangOptions().CPlusPlus) 2429 return Owned(E); 2430 2431 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?"); 2432 2433 const RecordType *RT = E->getType()->getAs<RecordType>(); 2434 if (!RT) 2435 return Owned(E); 2436 2437 // If this is the result of a call expression, our source might 2438 // actually be a reference, in which case we shouldn't bind. 2439 if (CallExpr *CE = dyn_cast<CallExpr>(E)) { 2440 QualType Ty = CE->getCallee()->getType(); 2441 if (const PointerType *PT = Ty->getAs<PointerType>()) 2442 Ty = PT->getPointeeType(); 2443 else if (const BlockPointerType *BPT = Ty->getAs<BlockPointerType>()) 2444 Ty = BPT->getPointeeType(); 2445 2446 const FunctionType *FTy = Ty->getAs<FunctionType>(); 2447 if (FTy->getResultType()->isReferenceType()) 2448 return Owned(E); 2449 } 2450 2451 // That should be enough to guarantee that this type is complete. 2452 // If it has a trivial destructor, we can avoid the extra copy. 2453 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 2454 if (RD->hasTrivialDestructor()) 2455 return Owned(E); 2456 2457 CXXTemporary *Temp = CXXTemporary::Create(Context, 2458 RD->getDestructor(Context)); 2459 ExprTemporaries.push_back(Temp); 2460 if (CXXDestructorDecl *Destructor = 2461 const_cast<CXXDestructorDecl*>(RD->getDestructor(Context))) 2462 MarkDeclarationReferenced(E->getExprLoc(), Destructor); 2463 // FIXME: Add the temporary to the temporaries vector. 2464 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E)); 2465} 2466 2467Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr) { 2468 assert(SubExpr && "sub expression can't be null!"); 2469 2470 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 2471 assert(ExprTemporaries.size() >= FirstTemporary); 2472 if (ExprTemporaries.size() == FirstTemporary) 2473 return SubExpr; 2474 2475 Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr, 2476 &ExprTemporaries[FirstTemporary], 2477 ExprTemporaries.size() - FirstTemporary); 2478 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 2479 ExprTemporaries.end()); 2480 2481 return E; 2482} 2483 2484Sema::OwningExprResult 2485Sema::MaybeCreateCXXExprWithTemporaries(OwningExprResult SubExpr) { 2486 if (SubExpr.isInvalid()) 2487 return ExprError(); 2488 2489 return Owned(MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>())); 2490} 2491 2492FullExpr Sema::CreateFullExpr(Expr *SubExpr) { 2493 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 2494 assert(ExprTemporaries.size() >= FirstTemporary); 2495 2496 unsigned NumTemporaries = ExprTemporaries.size() - FirstTemporary; 2497 CXXTemporary **Temporaries = 2498 NumTemporaries == 0 ? 0 : &ExprTemporaries[FirstTemporary]; 2499 2500 FullExpr E = FullExpr::Create(Context, SubExpr, Temporaries, NumTemporaries); 2501 2502 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 2503 ExprTemporaries.end()); 2504 2505 return E; 2506} 2507 2508Sema::OwningExprResult 2509Sema::ActOnStartCXXMemberReference(Scope *S, ExprArg Base, SourceLocation OpLoc, 2510 tok::TokenKind OpKind, TypeTy *&ObjectType, 2511 bool &MayBePseudoDestructor) { 2512 // Since this might be a postfix expression, get rid of ParenListExprs. 2513 Base = MaybeConvertParenListExprToParenExpr(S, move(Base)); 2514 2515 Expr *BaseExpr = (Expr*)Base.get(); 2516 assert(BaseExpr && "no record expansion"); 2517 2518 QualType BaseType = BaseExpr->getType(); 2519 MayBePseudoDestructor = false; 2520 if (BaseType->isDependentType()) { 2521 // If we have a pointer to a dependent type and are using the -> operator, 2522 // the object type is the type that the pointer points to. We might still 2523 // have enough information about that type to do something useful. 2524 if (OpKind == tok::arrow) 2525 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 2526 BaseType = Ptr->getPointeeType(); 2527 2528 ObjectType = BaseType.getAsOpaquePtr(); 2529 MayBePseudoDestructor = true; 2530 return move(Base); 2531 } 2532 2533 // C++ [over.match.oper]p8: 2534 // [...] When operator->returns, the operator-> is applied to the value 2535 // returned, with the original second operand. 2536 if (OpKind == tok::arrow) { 2537 // The set of types we've considered so far. 2538 llvm::SmallPtrSet<CanQualType,8> CTypes; 2539 llvm::SmallVector<SourceLocation, 8> Locations; 2540 CTypes.insert(Context.getCanonicalType(BaseType)); 2541 2542 while (BaseType->isRecordType()) { 2543 Base = BuildOverloadedArrowExpr(S, move(Base), OpLoc); 2544 BaseExpr = (Expr*)Base.get(); 2545 if (BaseExpr == NULL) 2546 return ExprError(); 2547 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(BaseExpr)) 2548 Locations.push_back(OpCall->getDirectCallee()->getLocation()); 2549 BaseType = BaseExpr->getType(); 2550 CanQualType CBaseType = Context.getCanonicalType(BaseType); 2551 if (!CTypes.insert(CBaseType)) { 2552 Diag(OpLoc, diag::err_operator_arrow_circular); 2553 for (unsigned i = 0; i < Locations.size(); i++) 2554 Diag(Locations[i], diag::note_declared_at); 2555 return ExprError(); 2556 } 2557 } 2558 2559 if (BaseType->isPointerType()) 2560 BaseType = BaseType->getPointeeType(); 2561 } 2562 2563 // We could end up with various non-record types here, such as extended 2564 // vector types or Objective-C interfaces. Just return early and let 2565 // ActOnMemberReferenceExpr do the work. 2566 if (!BaseType->isRecordType()) { 2567 // C++ [basic.lookup.classref]p2: 2568 // [...] If the type of the object expression is of pointer to scalar 2569 // type, the unqualified-id is looked up in the context of the complete 2570 // postfix-expression. 2571 // 2572 // This also indicates that we should be parsing a 2573 // pseudo-destructor-name. 2574 ObjectType = 0; 2575 MayBePseudoDestructor = true; 2576 return move(Base); 2577 } 2578 2579 // The object type must be complete (or dependent). 2580 if (!BaseType->isDependentType() && 2581 RequireCompleteType(OpLoc, BaseType, 2582 PDiag(diag::err_incomplete_member_access))) 2583 return ExprError(); 2584 2585 // C++ [basic.lookup.classref]p2: 2586 // If the id-expression in a class member access (5.2.5) is an 2587 // unqualified-id, and the type of the object expression is of a class 2588 // type C (or of pointer to a class type C), the unqualified-id is looked 2589 // up in the scope of class C. [...] 2590 ObjectType = BaseType.getAsOpaquePtr(); 2591 return move(Base); 2592} 2593 2594Sema::OwningExprResult Sema::DiagnoseDtorReference(SourceLocation NameLoc, 2595 ExprArg MemExpr) { 2596 Expr *E = (Expr *) MemExpr.get(); 2597 SourceLocation ExpectedLParenLoc = PP.getLocForEndOfToken(NameLoc); 2598 Diag(E->getLocStart(), diag::err_dtor_expr_without_call) 2599 << isa<CXXPseudoDestructorExpr>(E) 2600 << CodeModificationHint::CreateInsertion(ExpectedLParenLoc, "()"); 2601 2602 return ActOnCallExpr(/*Scope*/ 0, 2603 move(MemExpr), 2604 /*LPLoc*/ ExpectedLParenLoc, 2605 Sema::MultiExprArg(*this, 0, 0), 2606 /*CommaLocs*/ 0, 2607 /*RPLoc*/ ExpectedLParenLoc); 2608} 2609 2610Sema::OwningExprResult Sema::BuildPseudoDestructorExpr(ExprArg Base, 2611 SourceLocation OpLoc, 2612 tok::TokenKind OpKind, 2613 const CXXScopeSpec &SS, 2614 TypeSourceInfo *ScopeTypeInfo, 2615 SourceLocation CCLoc, 2616 SourceLocation TildeLoc, 2617 PseudoDestructorTypeStorage Destructed, 2618 bool HasTrailingLParen) { 2619 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo(); 2620 2621 // C++ [expr.pseudo]p2: 2622 // The left-hand side of the dot operator shall be of scalar type. The 2623 // left-hand side of the arrow operator shall be of pointer to scalar type. 2624 // This scalar type is the object type. 2625 Expr *BaseE = (Expr *)Base.get(); 2626 QualType ObjectType = BaseE->getType(); 2627 if (OpKind == tok::arrow) { 2628 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 2629 ObjectType = Ptr->getPointeeType(); 2630 } else if (!BaseE->isTypeDependent()) { 2631 // The user wrote "p->" when she probably meant "p."; fix it. 2632 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 2633 << ObjectType << true 2634 << CodeModificationHint::CreateReplacement(OpLoc, "."); 2635 if (isSFINAEContext()) 2636 return ExprError(); 2637 2638 OpKind = tok::period; 2639 } 2640 } 2641 2642 if (!ObjectType->isDependentType() && !ObjectType->isScalarType()) { 2643 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar) 2644 << ObjectType << BaseE->getSourceRange(); 2645 return ExprError(); 2646 } 2647 2648 // C++ [expr.pseudo]p2: 2649 // [...] The cv-unqualified versions of the object type and of the type 2650 // designated by the pseudo-destructor-name shall be the same type. 2651 if (DestructedTypeInfo) { 2652 QualType DestructedType = DestructedTypeInfo->getType(); 2653 SourceLocation DestructedTypeStart 2654 = DestructedTypeInfo->getTypeLoc().getSourceRange().getBegin(); 2655 if (!DestructedType->isDependentType() && !ObjectType->isDependentType() && 2656 !Context.hasSameUnqualifiedType(DestructedType, ObjectType)) { 2657 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch) 2658 << ObjectType << DestructedType << BaseE->getSourceRange() 2659 << DestructedTypeInfo->getTypeLoc().getSourceRange(); 2660 2661 // Recover by setting the destructed type to the object type. 2662 DestructedType = ObjectType; 2663 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType, 2664 DestructedTypeStart); 2665 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 2666 } 2667 } 2668 2669 // C++ [expr.pseudo]p2: 2670 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the 2671 // form 2672 // 2673 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name 2674 // 2675 // shall designate the same scalar type. 2676 if (ScopeTypeInfo) { 2677 QualType ScopeType = ScopeTypeInfo->getType(); 2678 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() && 2679 !Context.hasSameType(ScopeType, ObjectType)) { 2680 2681 Diag(ScopeTypeInfo->getTypeLoc().getSourceRange().getBegin(), 2682 diag::err_pseudo_dtor_type_mismatch) 2683 << ObjectType << ScopeType << BaseE->getSourceRange() 2684 << ScopeTypeInfo->getTypeLoc().getSourceRange(); 2685 2686 ScopeType = QualType(); 2687 ScopeTypeInfo = 0; 2688 } 2689 } 2690 2691 OwningExprResult Result 2692 = Owned(new (Context) CXXPseudoDestructorExpr(Context, 2693 Base.takeAs<Expr>(), 2694 OpKind == tok::arrow, 2695 OpLoc, 2696 (NestedNameSpecifier *) SS.getScopeRep(), 2697 SS.getRange(), 2698 ScopeTypeInfo, 2699 CCLoc, 2700 TildeLoc, 2701 Destructed)); 2702 2703 if (HasTrailingLParen) 2704 return move(Result); 2705 2706 return DiagnoseDtorReference(Destructed.getLocation(), move(Result)); 2707} 2708 2709Sema::OwningExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, ExprArg Base, 2710 SourceLocation OpLoc, 2711 tok::TokenKind OpKind, 2712 const CXXScopeSpec &SS, 2713 UnqualifiedId &FirstTypeName, 2714 SourceLocation CCLoc, 2715 SourceLocation TildeLoc, 2716 UnqualifiedId &SecondTypeName, 2717 bool HasTrailingLParen) { 2718 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2719 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) && 2720 "Invalid first type name in pseudo-destructor"); 2721 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2722 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) && 2723 "Invalid second type name in pseudo-destructor"); 2724 2725 Expr *BaseE = (Expr *)Base.get(); 2726 2727 // C++ [expr.pseudo]p2: 2728 // The left-hand side of the dot operator shall be of scalar type. The 2729 // left-hand side of the arrow operator shall be of pointer to scalar type. 2730 // This scalar type is the object type. 2731 QualType ObjectType = BaseE->getType(); 2732 if (OpKind == tok::arrow) { 2733 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 2734 ObjectType = Ptr->getPointeeType(); 2735 } else if (!ObjectType->isDependentType()) { 2736 // The user wrote "p->" when she probably meant "p."; fix it. 2737 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 2738 << ObjectType << true 2739 << CodeModificationHint::CreateReplacement(OpLoc, "."); 2740 if (isSFINAEContext()) 2741 return ExprError(); 2742 2743 OpKind = tok::period; 2744 } 2745 } 2746 2747 // Compute the object type that we should use for name lookup purposes. Only 2748 // record types and dependent types matter. 2749 void *ObjectTypePtrForLookup = 0; 2750 if (!SS.isSet()) { 2751 ObjectTypePtrForLookup = (void *)ObjectType->getAs<RecordType>(); 2752 if (!ObjectTypePtrForLookup && ObjectType->isDependentType()) 2753 ObjectTypePtrForLookup = Context.DependentTy.getAsOpaquePtr(); 2754 } 2755 2756 // Convert the name of the type being destructed (following the ~) into a 2757 // type (with source-location information). 2758 QualType DestructedType; 2759 TypeSourceInfo *DestructedTypeInfo = 0; 2760 PseudoDestructorTypeStorage Destructed; 2761 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) { 2762 TypeTy *T = getTypeName(*SecondTypeName.Identifier, 2763 SecondTypeName.StartLocation, 2764 S, &SS, true, ObjectTypePtrForLookup); 2765 if (!T && 2766 ((SS.isSet() && !computeDeclContext(SS, false)) || 2767 (!SS.isSet() && ObjectType->isDependentType()))) { 2768 // The name of the type being destroyed is a dependent name, and we 2769 // couldn't find anything useful in scope. Just store the identifier and 2770 // it's location, and we'll perform (qualified) name lookup again at 2771 // template instantiation time. 2772 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier, 2773 SecondTypeName.StartLocation); 2774 } else if (!T) { 2775 Diag(SecondTypeName.StartLocation, 2776 diag::err_pseudo_dtor_destructor_non_type) 2777 << SecondTypeName.Identifier << ObjectType; 2778 if (isSFINAEContext()) 2779 return ExprError(); 2780 2781 // Recover by assuming we had the right type all along. 2782 DestructedType = ObjectType; 2783 } else 2784 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo); 2785 } else { 2786 // Resolve the template-id to a type. 2787 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId; 2788 ASTTemplateArgsPtr TemplateArgsPtr(*this, 2789 TemplateId->getTemplateArgs(), 2790 TemplateId->NumArgs); 2791 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template), 2792 TemplateId->TemplateNameLoc, 2793 TemplateId->LAngleLoc, 2794 TemplateArgsPtr, 2795 TemplateId->RAngleLoc); 2796 if (T.isInvalid() || !T.get()) { 2797 // Recover by assuming we had the right type all along. 2798 DestructedType = ObjectType; 2799 } else 2800 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo); 2801 } 2802 2803 // If we've performed some kind of recovery, (re-)build the type source 2804 // information. 2805 if (!DestructedType.isNull()) { 2806 if (!DestructedTypeInfo) 2807 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType, 2808 SecondTypeName.StartLocation); 2809 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 2810 } 2811 2812 // Convert the name of the scope type (the type prior to '::') into a type. 2813 TypeSourceInfo *ScopeTypeInfo = 0; 2814 QualType ScopeType; 2815 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2816 FirstTypeName.Identifier) { 2817 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) { 2818 TypeTy *T = getTypeName(*FirstTypeName.Identifier, 2819 FirstTypeName.StartLocation, 2820 S, &SS, false, ObjectTypePtrForLookup); 2821 if (!T) { 2822 Diag(FirstTypeName.StartLocation, 2823 diag::err_pseudo_dtor_destructor_non_type) 2824 << FirstTypeName.Identifier << ObjectType; 2825 2826 if (isSFINAEContext()) 2827 return ExprError(); 2828 2829 // Just drop this type. It's unnecessary anyway. 2830 ScopeType = QualType(); 2831 } else 2832 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo); 2833 } else { 2834 // Resolve the template-id to a type. 2835 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId; 2836 ASTTemplateArgsPtr TemplateArgsPtr(*this, 2837 TemplateId->getTemplateArgs(), 2838 TemplateId->NumArgs); 2839 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template), 2840 TemplateId->TemplateNameLoc, 2841 TemplateId->LAngleLoc, 2842 TemplateArgsPtr, 2843 TemplateId->RAngleLoc); 2844 if (T.isInvalid() || !T.get()) { 2845 // Recover by dropping this type. 2846 ScopeType = QualType(); 2847 } else 2848 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo); 2849 } 2850 } 2851 2852 if (!ScopeType.isNull() && !ScopeTypeInfo) 2853 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType, 2854 FirstTypeName.StartLocation); 2855 2856 2857 return BuildPseudoDestructorExpr(move(Base), OpLoc, OpKind, SS, 2858 ScopeTypeInfo, CCLoc, TildeLoc, 2859 Destructed, HasTrailingLParen); 2860} 2861 2862CXXMemberCallExpr *Sema::BuildCXXMemberCallExpr(Expr *Exp, 2863 CXXMethodDecl *Method) { 2864 if (PerformObjectArgumentInitialization(Exp, /*Qualifier=*/0, Method)) 2865 assert(0 && "Calling BuildCXXMemberCallExpr with invalid call?"); 2866 2867 MemberExpr *ME = 2868 new (Context) MemberExpr(Exp, /*IsArrow=*/false, Method, 2869 SourceLocation(), Method->getType()); 2870 QualType ResultType = Method->getResultType().getNonReferenceType(); 2871 MarkDeclarationReferenced(Exp->getLocStart(), Method); 2872 CXXMemberCallExpr *CE = 2873 new (Context) CXXMemberCallExpr(Context, ME, 0, 0, ResultType, 2874 Exp->getLocEnd()); 2875 return CE; 2876} 2877 2878Sema::OwningExprResult Sema::BuildCXXCastArgument(SourceLocation CastLoc, 2879 QualType Ty, 2880 CastExpr::CastKind Kind, 2881 CXXMethodDecl *Method, 2882 ExprArg Arg) { 2883 Expr *From = Arg.takeAs<Expr>(); 2884 2885 switch (Kind) { 2886 default: assert(0 && "Unhandled cast kind!"); 2887 case CastExpr::CK_ConstructorConversion: { 2888 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this); 2889 2890 if (CompleteConstructorCall(cast<CXXConstructorDecl>(Method), 2891 MultiExprArg(*this, (void **)&From, 1), 2892 CastLoc, ConstructorArgs)) 2893 return ExprError(); 2894 2895 OwningExprResult Result = 2896 BuildCXXConstructExpr(CastLoc, Ty, cast<CXXConstructorDecl>(Method), 2897 move_arg(ConstructorArgs)); 2898 if (Result.isInvalid()) 2899 return ExprError(); 2900 2901 return MaybeBindToTemporary(Result.takeAs<Expr>()); 2902 } 2903 2904 case CastExpr::CK_UserDefinedConversion: { 2905 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!"); 2906 2907 // Create an implicit call expr that calls it. 2908 CXXMemberCallExpr *CE = BuildCXXMemberCallExpr(From, Method); 2909 return MaybeBindToTemporary(CE); 2910 } 2911 } 2912} 2913 2914Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) { 2915 Expr *FullExpr = Arg.takeAs<Expr>(); 2916 if (FullExpr) 2917 FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr); 2918 2919 return Owned(FullExpr); 2920} 2921