SemaExprCXX.cpp revision bebe8c9e574bf64101182480ce5d503862c49bda
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 if (PerformCopyInitialization(Args[i], 1066 FnDecl->getParamDecl(i)->getType(), 1067 AA_Passing)) 1068 return true; 1069 } 1070 Operator = FnDecl; 1071 CheckAllocationAccess(StartLoc, Range, R.getNamingClass(), Best->FoundDecl); 1072 return false; 1073 } 1074 1075 case OR_No_Viable_Function: 1076 Diag(StartLoc, diag::err_ovl_no_viable_function_in_call) 1077 << Name << Range; 1078 PrintOverloadCandidates(Candidates, OCD_AllCandidates, Args, NumArgs); 1079 return true; 1080 1081 case OR_Ambiguous: 1082 Diag(StartLoc, diag::err_ovl_ambiguous_call) 1083 << Name << Range; 1084 PrintOverloadCandidates(Candidates, OCD_ViableCandidates, Args, NumArgs); 1085 return true; 1086 1087 case OR_Deleted: 1088 Diag(StartLoc, diag::err_ovl_deleted_call) 1089 << Best->Function->isDeleted() 1090 << Name << Range; 1091 PrintOverloadCandidates(Candidates, OCD_AllCandidates, Args, NumArgs); 1092 return true; 1093 } 1094 assert(false && "Unreachable, bad result from BestViableFunction"); 1095 return true; 1096} 1097 1098 1099/// DeclareGlobalNewDelete - Declare the global forms of operator new and 1100/// delete. These are: 1101/// @code 1102/// void* operator new(std::size_t) throw(std::bad_alloc); 1103/// void* operator new[](std::size_t) throw(std::bad_alloc); 1104/// void operator delete(void *) throw(); 1105/// void operator delete[](void *) throw(); 1106/// @endcode 1107/// Note that the placement and nothrow forms of new are *not* implicitly 1108/// declared. Their use requires including \<new\>. 1109void Sema::DeclareGlobalNewDelete() { 1110 if (GlobalNewDeleteDeclared) 1111 return; 1112 1113 // C++ [basic.std.dynamic]p2: 1114 // [...] The following allocation and deallocation functions (18.4) are 1115 // implicitly declared in global scope in each translation unit of a 1116 // program 1117 // 1118 // void* operator new(std::size_t) throw(std::bad_alloc); 1119 // void* operator new[](std::size_t) throw(std::bad_alloc); 1120 // void operator delete(void*) throw(); 1121 // void operator delete[](void*) throw(); 1122 // 1123 // These implicit declarations introduce only the function names operator 1124 // new, operator new[], operator delete, operator delete[]. 1125 // 1126 // Here, we need to refer to std::bad_alloc, so we will implicitly declare 1127 // "std" or "bad_alloc" as necessary to form the exception specification. 1128 // However, we do not make these implicit declarations visible to name 1129 // lookup. 1130 if (!StdNamespace) { 1131 // The "std" namespace has not yet been defined, so build one implicitly. 1132 StdNamespace = NamespaceDecl::Create(Context, 1133 Context.getTranslationUnitDecl(), 1134 SourceLocation(), 1135 &PP.getIdentifierTable().get("std")); 1136 StdNamespace->setImplicit(true); 1137 } 1138 1139 if (!StdBadAlloc) { 1140 // The "std::bad_alloc" class has not yet been declared, so build it 1141 // implicitly. 1142 StdBadAlloc = CXXRecordDecl::Create(Context, TagDecl::TK_class, 1143 StdNamespace, 1144 SourceLocation(), 1145 &PP.getIdentifierTable().get("bad_alloc"), 1146 SourceLocation(), 0); 1147 StdBadAlloc->setImplicit(true); 1148 } 1149 1150 GlobalNewDeleteDeclared = true; 1151 1152 QualType VoidPtr = Context.getPointerType(Context.VoidTy); 1153 QualType SizeT = Context.getSizeType(); 1154 bool AssumeSaneOperatorNew = getLangOptions().AssumeSaneOperatorNew; 1155 1156 DeclareGlobalAllocationFunction( 1157 Context.DeclarationNames.getCXXOperatorName(OO_New), 1158 VoidPtr, SizeT, AssumeSaneOperatorNew); 1159 DeclareGlobalAllocationFunction( 1160 Context.DeclarationNames.getCXXOperatorName(OO_Array_New), 1161 VoidPtr, SizeT, AssumeSaneOperatorNew); 1162 DeclareGlobalAllocationFunction( 1163 Context.DeclarationNames.getCXXOperatorName(OO_Delete), 1164 Context.VoidTy, VoidPtr); 1165 DeclareGlobalAllocationFunction( 1166 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete), 1167 Context.VoidTy, VoidPtr); 1168} 1169 1170/// DeclareGlobalAllocationFunction - Declares a single implicit global 1171/// allocation function if it doesn't already exist. 1172void Sema::DeclareGlobalAllocationFunction(DeclarationName Name, 1173 QualType Return, QualType Argument, 1174 bool AddMallocAttr) { 1175 DeclContext *GlobalCtx = Context.getTranslationUnitDecl(); 1176 1177 // Check if this function is already declared. 1178 { 1179 DeclContext::lookup_iterator Alloc, AllocEnd; 1180 for (llvm::tie(Alloc, AllocEnd) = GlobalCtx->lookup(Name); 1181 Alloc != AllocEnd; ++Alloc) { 1182 // Only look at non-template functions, as it is the predefined, 1183 // non-templated allocation function we are trying to declare here. 1184 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) { 1185 QualType InitialParamType = 1186 Context.getCanonicalType( 1187 Func->getParamDecl(0)->getType().getUnqualifiedType()); 1188 // FIXME: Do we need to check for default arguments here? 1189 if (Func->getNumParams() == 1 && InitialParamType == Argument) 1190 return; 1191 } 1192 } 1193 } 1194 1195 QualType BadAllocType; 1196 bool HasBadAllocExceptionSpec 1197 = (Name.getCXXOverloadedOperator() == OO_New || 1198 Name.getCXXOverloadedOperator() == OO_Array_New); 1199 if (HasBadAllocExceptionSpec) { 1200 assert(StdBadAlloc && "Must have std::bad_alloc declared"); 1201 BadAllocType = Context.getTypeDeclType(StdBadAlloc); 1202 } 1203 1204 QualType FnType = Context.getFunctionType(Return, &Argument, 1, false, 0, 1205 true, false, 1206 HasBadAllocExceptionSpec? 1 : 0, 1207 &BadAllocType, false, CC_Default); 1208 FunctionDecl *Alloc = 1209 FunctionDecl::Create(Context, GlobalCtx, SourceLocation(), Name, 1210 FnType, /*TInfo=*/0, FunctionDecl::None, false, true); 1211 Alloc->setImplicit(); 1212 1213 if (AddMallocAttr) 1214 Alloc->addAttr(::new (Context) MallocAttr()); 1215 1216 ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(), 1217 0, Argument, /*TInfo=*/0, 1218 VarDecl::None, 0); 1219 Alloc->setParams(&Param, 1); 1220 1221 // FIXME: Also add this declaration to the IdentifierResolver, but 1222 // make sure it is at the end of the chain to coincide with the 1223 // global scope. 1224 ((DeclContext *)TUScope->getEntity())->addDecl(Alloc); 1225} 1226 1227bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, 1228 DeclarationName Name, 1229 FunctionDecl* &Operator) { 1230 LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName); 1231 // Try to find operator delete/operator delete[] in class scope. 1232 LookupQualifiedName(Found, RD); 1233 1234 if (Found.isAmbiguous()) 1235 return true; 1236 1237 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end(); 1238 F != FEnd; ++F) { 1239 if (CXXMethodDecl *Delete = dyn_cast<CXXMethodDecl>(*F)) 1240 if (Delete->isUsualDeallocationFunction()) { 1241 Operator = Delete; 1242 return false; 1243 } 1244 } 1245 1246 // We did find operator delete/operator delete[] declarations, but 1247 // none of them were suitable. 1248 if (!Found.empty()) { 1249 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found) 1250 << Name << RD; 1251 1252 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end(); 1253 F != FEnd; ++F) { 1254 Diag((*F)->getLocation(), 1255 diag::note_delete_member_function_declared_here) 1256 << Name; 1257 } 1258 1259 return true; 1260 } 1261 1262 // Look for a global declaration. 1263 DeclareGlobalNewDelete(); 1264 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 1265 1266 CXXNullPtrLiteralExpr Null(Context.VoidPtrTy, SourceLocation()); 1267 Expr* DeallocArgs[1]; 1268 DeallocArgs[0] = &Null; 1269 if (FindAllocationOverload(StartLoc, SourceRange(), Name, 1270 DeallocArgs, 1, TUDecl, /*AllowMissing=*/false, 1271 Operator)) 1272 return true; 1273 1274 assert(Operator && "Did not find a deallocation function!"); 1275 return false; 1276} 1277 1278/// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in: 1279/// @code ::delete ptr; @endcode 1280/// or 1281/// @code delete [] ptr; @endcode 1282Action::OwningExprResult 1283Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, 1284 bool ArrayForm, ExprArg Operand) { 1285 // C++ [expr.delete]p1: 1286 // The operand shall have a pointer type, or a class type having a single 1287 // conversion function to a pointer type. The result has type void. 1288 // 1289 // DR599 amends "pointer type" to "pointer to object type" in both cases. 1290 1291 FunctionDecl *OperatorDelete = 0; 1292 1293 Expr *Ex = (Expr *)Operand.get(); 1294 if (!Ex->isTypeDependent()) { 1295 QualType Type = Ex->getType(); 1296 1297 if (const RecordType *Record = Type->getAs<RecordType>()) { 1298 llvm::SmallVector<CXXConversionDecl *, 4> ObjectPtrConversions; 1299 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); 1300 const UnresolvedSetImpl *Conversions = RD->getVisibleConversionFunctions(); 1301 1302 for (UnresolvedSetImpl::iterator I = Conversions->begin(), 1303 E = Conversions->end(); I != E; ++I) { 1304 // Skip over templated conversion functions; they aren't considered. 1305 if (isa<FunctionTemplateDecl>(*I)) 1306 continue; 1307 1308 CXXConversionDecl *Conv = cast<CXXConversionDecl>(*I); 1309 1310 QualType ConvType = Conv->getConversionType().getNonReferenceType(); 1311 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>()) 1312 if (ConvPtrType->getPointeeType()->isObjectType()) 1313 ObjectPtrConversions.push_back(Conv); 1314 } 1315 if (ObjectPtrConversions.size() == 1) { 1316 // We have a single conversion to a pointer-to-object type. Perform 1317 // that conversion. 1318 Operand.release(); 1319 if (!PerformImplicitConversion(Ex, 1320 ObjectPtrConversions.front()->getConversionType(), 1321 AA_Converting)) { 1322 Operand = Owned(Ex); 1323 Type = Ex->getType(); 1324 } 1325 } 1326 else if (ObjectPtrConversions.size() > 1) { 1327 Diag(StartLoc, diag::err_ambiguous_delete_operand) 1328 << Type << Ex->getSourceRange(); 1329 for (unsigned i= 0; i < ObjectPtrConversions.size(); i++) { 1330 CXXConversionDecl *Conv = ObjectPtrConversions[i]; 1331 NoteOverloadCandidate(Conv); 1332 } 1333 return ExprError(); 1334 } 1335 } 1336 1337 if (!Type->isPointerType()) 1338 return ExprError(Diag(StartLoc, diag::err_delete_operand) 1339 << Type << Ex->getSourceRange()); 1340 1341 QualType Pointee = Type->getAs<PointerType>()->getPointeeType(); 1342 if (Pointee->isFunctionType() || Pointee->isVoidType()) 1343 return ExprError(Diag(StartLoc, diag::err_delete_operand) 1344 << Type << Ex->getSourceRange()); 1345 else if (!Pointee->isDependentType() && 1346 RequireCompleteType(StartLoc, Pointee, 1347 PDiag(diag::warn_delete_incomplete) 1348 << Ex->getSourceRange())) 1349 return ExprError(); 1350 1351 // C++ [expr.delete]p2: 1352 // [Note: a pointer to a const type can be the operand of a 1353 // delete-expression; it is not necessary to cast away the constness 1354 // (5.2.11) of the pointer expression before it is used as the operand 1355 // of the delete-expression. ] 1356 ImpCastExprToType(Ex, Context.getPointerType(Context.VoidTy), 1357 CastExpr::CK_NoOp); 1358 1359 // Update the operand. 1360 Operand.take(); 1361 Operand = ExprArg(*this, Ex); 1362 1363 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName( 1364 ArrayForm ? OO_Array_Delete : OO_Delete); 1365 1366 if (const RecordType *RT = Pointee->getAs<RecordType>()) { 1367 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1368 1369 if (!UseGlobal && 1370 FindDeallocationFunction(StartLoc, RD, DeleteName, OperatorDelete)) 1371 return ExprError(); 1372 1373 if (!RD->hasTrivialDestructor()) 1374 if (const CXXDestructorDecl *Dtor = RD->getDestructor(Context)) 1375 MarkDeclarationReferenced(StartLoc, 1376 const_cast<CXXDestructorDecl*>(Dtor)); 1377 } 1378 1379 if (!OperatorDelete) { 1380 // Look for a global declaration. 1381 DeclareGlobalNewDelete(); 1382 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 1383 if (FindAllocationOverload(StartLoc, SourceRange(), DeleteName, 1384 &Ex, 1, TUDecl, /*AllowMissing=*/false, 1385 OperatorDelete)) 1386 return ExprError(); 1387 } 1388 1389 // FIXME: Check access and ambiguity of operator delete and destructor. 1390 } 1391 1392 Operand.release(); 1393 return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm, 1394 OperatorDelete, Ex, StartLoc)); 1395} 1396 1397/// \brief Check the use of the given variable as a C++ condition in an if, 1398/// while, do-while, or switch statement. 1399Action::OwningExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar) { 1400 QualType T = ConditionVar->getType(); 1401 1402 // C++ [stmt.select]p2: 1403 // The declarator shall not specify a function or an array. 1404 if (T->isFunctionType()) 1405 return ExprError(Diag(ConditionVar->getLocation(), 1406 diag::err_invalid_use_of_function_type) 1407 << ConditionVar->getSourceRange()); 1408 else if (T->isArrayType()) 1409 return ExprError(Diag(ConditionVar->getLocation(), 1410 diag::err_invalid_use_of_array_type) 1411 << ConditionVar->getSourceRange()); 1412 1413 return Owned(DeclRefExpr::Create(Context, 0, SourceRange(), ConditionVar, 1414 ConditionVar->getLocation(), 1415 ConditionVar->getType().getNonReferenceType())); 1416} 1417 1418/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid. 1419bool Sema::CheckCXXBooleanCondition(Expr *&CondExpr) { 1420 // C++ 6.4p4: 1421 // The value of a condition that is an initialized declaration in a statement 1422 // other than a switch statement is the value of the declared variable 1423 // implicitly converted to type bool. If that conversion is ill-formed, the 1424 // program is ill-formed. 1425 // The value of a condition that is an expression is the value of the 1426 // expression, implicitly converted to bool. 1427 // 1428 return PerformContextuallyConvertToBool(CondExpr); 1429} 1430 1431/// Helper function to determine whether this is the (deprecated) C++ 1432/// conversion from a string literal to a pointer to non-const char or 1433/// non-const wchar_t (for narrow and wide string literals, 1434/// respectively). 1435bool 1436Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) { 1437 // Look inside the implicit cast, if it exists. 1438 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From)) 1439 From = Cast->getSubExpr(); 1440 1441 // A string literal (2.13.4) that is not a wide string literal can 1442 // be converted to an rvalue of type "pointer to char"; a wide 1443 // string literal can be converted to an rvalue of type "pointer 1444 // to wchar_t" (C++ 4.2p2). 1445 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From)) 1446 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) 1447 if (const BuiltinType *ToPointeeType 1448 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) { 1449 // This conversion is considered only when there is an 1450 // explicit appropriate pointer target type (C++ 4.2p2). 1451 if (!ToPtrType->getPointeeType().hasQualifiers() && 1452 ((StrLit->isWide() && ToPointeeType->isWideCharType()) || 1453 (!StrLit->isWide() && 1454 (ToPointeeType->getKind() == BuiltinType::Char_U || 1455 ToPointeeType->getKind() == BuiltinType::Char_S)))) 1456 return true; 1457 } 1458 1459 return false; 1460} 1461 1462/// PerformImplicitConversion - Perform an implicit conversion of the 1463/// expression From to the type ToType. Returns true if there was an 1464/// error, false otherwise. The expression From is replaced with the 1465/// converted expression. Flavor is the kind of conversion we're 1466/// performing, used in the error message. If @p AllowExplicit, 1467/// explicit user-defined conversions are permitted. @p Elidable should be true 1468/// when called for copies which may be elided (C++ 12.8p15). C++0x overload 1469/// resolution works differently in that case. 1470bool 1471Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1472 AssignmentAction Action, bool AllowExplicit, 1473 bool Elidable) { 1474 ImplicitConversionSequence ICS; 1475 return PerformImplicitConversion(From, ToType, Action, AllowExplicit, 1476 Elidable, ICS); 1477} 1478 1479bool 1480Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1481 AssignmentAction Action, bool AllowExplicit, 1482 bool Elidable, 1483 ImplicitConversionSequence& ICS) { 1484 ICS.setBad(BadConversionSequence::no_conversion, From, ToType); 1485 if (Elidable && getLangOptions().CPlusPlus0x) { 1486 ICS = TryImplicitConversion(From, ToType, 1487 /*SuppressUserConversions=*/false, 1488 AllowExplicit, 1489 /*ForceRValue=*/true, 1490 /*InOverloadResolution=*/false); 1491 } 1492 if (ICS.isBad()) { 1493 ICS = TryImplicitConversion(From, ToType, 1494 /*SuppressUserConversions=*/false, 1495 AllowExplicit, 1496 /*ForceRValue=*/false, 1497 /*InOverloadResolution=*/false); 1498 } 1499 return PerformImplicitConversion(From, ToType, ICS, Action); 1500} 1501 1502/// PerformImplicitConversion - Perform an implicit conversion of the 1503/// expression From to the type ToType using the pre-computed implicit 1504/// conversion sequence ICS. Returns true if there was an error, false 1505/// otherwise. The expression From is replaced with the converted 1506/// expression. Action is the kind of conversion we're performing, 1507/// used in the error message. 1508bool 1509Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1510 const ImplicitConversionSequence &ICS, 1511 AssignmentAction Action, bool IgnoreBaseAccess) { 1512 switch (ICS.getKind()) { 1513 case ImplicitConversionSequence::StandardConversion: 1514 if (PerformImplicitConversion(From, ToType, ICS.Standard, Action, 1515 IgnoreBaseAccess)) 1516 return true; 1517 break; 1518 1519 case ImplicitConversionSequence::UserDefinedConversion: { 1520 1521 FunctionDecl *FD = ICS.UserDefined.ConversionFunction; 1522 CastExpr::CastKind CastKind = CastExpr::CK_Unknown; 1523 QualType BeforeToType; 1524 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) { 1525 CastKind = CastExpr::CK_UserDefinedConversion; 1526 1527 // If the user-defined conversion is specified by a conversion function, 1528 // the initial standard conversion sequence converts the source type to 1529 // the implicit object parameter of the conversion function. 1530 BeforeToType = Context.getTagDeclType(Conv->getParent()); 1531 } else if (const CXXConstructorDecl *Ctor = 1532 dyn_cast<CXXConstructorDecl>(FD)) { 1533 CastKind = CastExpr::CK_ConstructorConversion; 1534 // Do no conversion if dealing with ... for the first conversion. 1535 if (!ICS.UserDefined.EllipsisConversion) { 1536 // If the user-defined conversion is specified by a constructor, the 1537 // initial standard conversion sequence converts the source type to the 1538 // type required by the argument of the constructor 1539 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType(); 1540 } 1541 } 1542 else 1543 assert(0 && "Unknown conversion function kind!"); 1544 // Whatch out for elipsis conversion. 1545 if (!ICS.UserDefined.EllipsisConversion) { 1546 if (PerformImplicitConversion(From, BeforeToType, 1547 ICS.UserDefined.Before, AA_Converting, 1548 IgnoreBaseAccess)) 1549 return true; 1550 } 1551 1552 OwningExprResult CastArg 1553 = BuildCXXCastArgument(From->getLocStart(), 1554 ToType.getNonReferenceType(), 1555 CastKind, cast<CXXMethodDecl>(FD), 1556 Owned(From)); 1557 1558 if (CastArg.isInvalid()) 1559 return true; 1560 1561 From = CastArg.takeAs<Expr>(); 1562 1563 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After, 1564 AA_Converting, IgnoreBaseAccess); 1565 } 1566 1567 case ImplicitConversionSequence::AmbiguousConversion: 1568 DiagnoseAmbiguousConversion(ICS, From->getExprLoc(), 1569 PDiag(diag::err_typecheck_ambiguous_condition) 1570 << From->getSourceRange()); 1571 return true; 1572 1573 case ImplicitConversionSequence::EllipsisConversion: 1574 assert(false && "Cannot perform an ellipsis conversion"); 1575 return false; 1576 1577 case ImplicitConversionSequence::BadConversion: 1578 return true; 1579 } 1580 1581 // Everything went well. 1582 return false; 1583} 1584 1585/// PerformImplicitConversion - Perform an implicit conversion of the 1586/// expression From to the type ToType by following the standard 1587/// conversion sequence SCS. Returns true if there was an error, false 1588/// otherwise. The expression From is replaced with the converted 1589/// expression. Flavor is the context in which we're performing this 1590/// conversion, for use in error messages. 1591bool 1592Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1593 const StandardConversionSequence& SCS, 1594 AssignmentAction Action, bool IgnoreBaseAccess) { 1595 // Overall FIXME: we are recomputing too many types here and doing far too 1596 // much extra work. What this means is that we need to keep track of more 1597 // information that is computed when we try the implicit conversion initially, 1598 // so that we don't need to recompute anything here. 1599 QualType FromType = From->getType(); 1600 1601 if (SCS.CopyConstructor) { 1602 // FIXME: When can ToType be a reference type? 1603 assert(!ToType->isReferenceType()); 1604 if (SCS.Second == ICK_Derived_To_Base) { 1605 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this); 1606 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor), 1607 MultiExprArg(*this, (void **)&From, 1), 1608 /*FIXME:ConstructLoc*/SourceLocation(), 1609 ConstructorArgs)) 1610 return true; 1611 OwningExprResult FromResult = 1612 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 1613 ToType, SCS.CopyConstructor, 1614 move_arg(ConstructorArgs)); 1615 if (FromResult.isInvalid()) 1616 return true; 1617 From = FromResult.takeAs<Expr>(); 1618 return false; 1619 } 1620 OwningExprResult FromResult = 1621 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 1622 ToType, SCS.CopyConstructor, 1623 MultiExprArg(*this, (void**)&From, 1)); 1624 1625 if (FromResult.isInvalid()) 1626 return true; 1627 1628 From = FromResult.takeAs<Expr>(); 1629 return false; 1630 } 1631 1632 // Perform the first implicit conversion. 1633 switch (SCS.First) { 1634 case ICK_Identity: 1635 case ICK_Lvalue_To_Rvalue: 1636 // Nothing to do. 1637 break; 1638 1639 case ICK_Array_To_Pointer: 1640 FromType = Context.getArrayDecayedType(FromType); 1641 ImpCastExprToType(From, FromType, CastExpr::CK_ArrayToPointerDecay); 1642 break; 1643 1644 case ICK_Function_To_Pointer: 1645 if (Context.getCanonicalType(FromType) == Context.OverloadTy) { 1646 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, true); 1647 if (!Fn) 1648 return true; 1649 1650 if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin())) 1651 return true; 1652 1653 From = FixOverloadedFunctionReference(From, Fn); 1654 FromType = From->getType(); 1655 1656 // If there's already an address-of operator in the expression, we have 1657 // the right type already, and the code below would just introduce an 1658 // invalid additional pointer level. 1659 if (FromType->isPointerType() || FromType->isMemberFunctionPointerType()) 1660 break; 1661 } 1662 FromType = Context.getPointerType(FromType); 1663 ImpCastExprToType(From, FromType, CastExpr::CK_FunctionToPointerDecay); 1664 break; 1665 1666 default: 1667 assert(false && "Improper first standard conversion"); 1668 break; 1669 } 1670 1671 // Perform the second implicit conversion 1672 switch (SCS.Second) { 1673 case ICK_Identity: 1674 // If both sides are functions (or pointers/references to them), there could 1675 // be incompatible exception declarations. 1676 if (CheckExceptionSpecCompatibility(From, ToType)) 1677 return true; 1678 // Nothing else to do. 1679 break; 1680 1681 case ICK_NoReturn_Adjustment: 1682 // If both sides are functions (or pointers/references to them), there could 1683 // be incompatible exception declarations. 1684 if (CheckExceptionSpecCompatibility(From, ToType)) 1685 return true; 1686 1687 ImpCastExprToType(From, Context.getNoReturnType(From->getType(), false), 1688 CastExpr::CK_NoOp); 1689 break; 1690 1691 case ICK_Integral_Promotion: 1692 case ICK_Integral_Conversion: 1693 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralCast); 1694 break; 1695 1696 case ICK_Floating_Promotion: 1697 case ICK_Floating_Conversion: 1698 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingCast); 1699 break; 1700 1701 case ICK_Complex_Promotion: 1702 case ICK_Complex_Conversion: 1703 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown); 1704 break; 1705 1706 case ICK_Floating_Integral: 1707 if (ToType->isFloatingType()) 1708 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralToFloating); 1709 else 1710 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingToIntegral); 1711 break; 1712 1713 case ICK_Complex_Real: 1714 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown); 1715 break; 1716 1717 case ICK_Compatible_Conversion: 1718 ImpCastExprToType(From, ToType, CastExpr::CK_NoOp); 1719 break; 1720 1721 case ICK_Pointer_Conversion: { 1722 if (SCS.IncompatibleObjC) { 1723 // Diagnose incompatible Objective-C conversions 1724 Diag(From->getSourceRange().getBegin(), 1725 diag::ext_typecheck_convert_incompatible_pointer) 1726 << From->getType() << ToType << Action 1727 << From->getSourceRange(); 1728 } 1729 1730 1731 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1732 if (CheckPointerConversion(From, ToType, Kind, IgnoreBaseAccess)) 1733 return true; 1734 ImpCastExprToType(From, ToType, Kind); 1735 break; 1736 } 1737 1738 case ICK_Pointer_Member: { 1739 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1740 if (CheckMemberPointerConversion(From, ToType, Kind, IgnoreBaseAccess)) 1741 return true; 1742 if (CheckExceptionSpecCompatibility(From, ToType)) 1743 return true; 1744 ImpCastExprToType(From, ToType, Kind); 1745 break; 1746 } 1747 case ICK_Boolean_Conversion: { 1748 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1749 if (FromType->isMemberPointerType()) 1750 Kind = CastExpr::CK_MemberPointerToBoolean; 1751 1752 ImpCastExprToType(From, Context.BoolTy, Kind); 1753 break; 1754 } 1755 1756 case ICK_Derived_To_Base: 1757 if (CheckDerivedToBaseConversion(From->getType(), 1758 ToType.getNonReferenceType(), 1759 From->getLocStart(), 1760 From->getSourceRange(), 1761 IgnoreBaseAccess)) 1762 return true; 1763 ImpCastExprToType(From, ToType.getNonReferenceType(), 1764 CastExpr::CK_DerivedToBase); 1765 break; 1766 1767 default: 1768 assert(false && "Improper second standard conversion"); 1769 break; 1770 } 1771 1772 switch (SCS.Third) { 1773 case ICK_Identity: 1774 // Nothing to do. 1775 break; 1776 1777 case ICK_Qualification: 1778 // FIXME: Not sure about lvalue vs rvalue here in the presence of rvalue 1779 // references. 1780 ImpCastExprToType(From, ToType.getNonReferenceType(), 1781 CastExpr::CK_NoOp, 1782 ToType->isLValueReferenceType()); 1783 1784 if (SCS.DeprecatedStringLiteralToCharPtr) 1785 Diag(From->getLocStart(), diag::warn_deprecated_string_literal_conversion) 1786 << ToType.getNonReferenceType(); 1787 1788 break; 1789 1790 default: 1791 assert(false && "Improper second standard conversion"); 1792 break; 1793 } 1794 1795 return false; 1796} 1797 1798Sema::OwningExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait OTT, 1799 SourceLocation KWLoc, 1800 SourceLocation LParen, 1801 TypeTy *Ty, 1802 SourceLocation RParen) { 1803 QualType T = GetTypeFromParser(Ty); 1804 1805 // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html 1806 // all traits except __is_class, __is_enum and __is_union require a the type 1807 // to be complete. 1808 if (OTT != UTT_IsClass && OTT != UTT_IsEnum && OTT != UTT_IsUnion) { 1809 if (RequireCompleteType(KWLoc, T, 1810 diag::err_incomplete_type_used_in_type_trait_expr)) 1811 return ExprError(); 1812 } 1813 1814 // There is no point in eagerly computing the value. The traits are designed 1815 // to be used from type trait templates, so Ty will be a template parameter 1816 // 99% of the time. 1817 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, OTT, T, 1818 RParen, Context.BoolTy)); 1819} 1820 1821QualType Sema::CheckPointerToMemberOperands( 1822 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isIndirect) { 1823 const char *OpSpelling = isIndirect ? "->*" : ".*"; 1824 // C++ 5.5p2 1825 // The binary operator .* [p3: ->*] binds its second operand, which shall 1826 // be of type "pointer to member of T" (where T is a completely-defined 1827 // class type) [...] 1828 QualType RType = rex->getType(); 1829 const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>(); 1830 if (!MemPtr) { 1831 Diag(Loc, diag::err_bad_memptr_rhs) 1832 << OpSpelling << RType << rex->getSourceRange(); 1833 return QualType(); 1834 } 1835 1836 QualType Class(MemPtr->getClass(), 0); 1837 1838 // C++ 5.5p2 1839 // [...] to its first operand, which shall be of class T or of a class of 1840 // which T is an unambiguous and accessible base class. [p3: a pointer to 1841 // such a class] 1842 QualType LType = lex->getType(); 1843 if (isIndirect) { 1844 if (const PointerType *Ptr = LType->getAs<PointerType>()) 1845 LType = Ptr->getPointeeType().getNonReferenceType(); 1846 else { 1847 Diag(Loc, diag::err_bad_memptr_lhs) 1848 << OpSpelling << 1 << LType 1849 << CodeModificationHint::CreateReplacement(SourceRange(Loc), ".*"); 1850 return QualType(); 1851 } 1852 } 1853 1854 if (!Context.hasSameUnqualifiedType(Class, LType)) { 1855 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false, 1856 /*DetectVirtual=*/false); 1857 // FIXME: Would it be useful to print full ambiguity paths, or is that 1858 // overkill? 1859 if (!IsDerivedFrom(LType, Class, Paths) || 1860 Paths.isAmbiguous(Context.getCanonicalType(Class))) { 1861 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling 1862 << (int)isIndirect << lex->getType(); 1863 return QualType(); 1864 } 1865 // Cast LHS to type of use. 1866 QualType UseType = isIndirect ? Context.getPointerType(Class) : Class; 1867 bool isLValue = !isIndirect && lex->isLvalue(Context) == Expr::LV_Valid; 1868 ImpCastExprToType(lex, UseType, CastExpr::CK_DerivedToBase, isLValue); 1869 } 1870 1871 if (isa<CXXZeroInitValueExpr>(rex->IgnoreParens())) { 1872 // Diagnose use of pointer-to-member type which when used as 1873 // the functional cast in a pointer-to-member expression. 1874 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect; 1875 return QualType(); 1876 } 1877 // C++ 5.5p2 1878 // The result is an object or a function of the type specified by the 1879 // second operand. 1880 // The cv qualifiers are the union of those in the pointer and the left side, 1881 // in accordance with 5.5p5 and 5.2.5. 1882 // FIXME: This returns a dereferenced member function pointer as a normal 1883 // function type. However, the only operation valid on such functions is 1884 // calling them. There's also a GCC extension to get a function pointer to the 1885 // thing, which is another complication, because this type - unlike the type 1886 // that is the result of this expression - takes the class as the first 1887 // argument. 1888 // We probably need a "MemberFunctionClosureType" or something like that. 1889 QualType Result = MemPtr->getPointeeType(); 1890 Result = Context.getCVRQualifiedType(Result, LType.getCVRQualifiers()); 1891 return Result; 1892} 1893 1894/// \brief Get the target type of a standard or user-defined conversion. 1895static QualType TargetType(const ImplicitConversionSequence &ICS) { 1896 switch (ICS.getKind()) { 1897 case ImplicitConversionSequence::StandardConversion: 1898 return ICS.Standard.getToType(2); 1899 case ImplicitConversionSequence::UserDefinedConversion: 1900 return ICS.UserDefined.After.getToType(2); 1901 case ImplicitConversionSequence::AmbiguousConversion: 1902 return ICS.Ambiguous.getToType(); 1903 1904 case ImplicitConversionSequence::EllipsisConversion: 1905 case ImplicitConversionSequence::BadConversion: 1906 llvm_unreachable("function not valid for ellipsis or bad conversions"); 1907 } 1908 return QualType(); // silence warnings 1909} 1910 1911/// \brief Try to convert a type to another according to C++0x 5.16p3. 1912/// 1913/// This is part of the parameter validation for the ? operator. If either 1914/// value operand is a class type, the two operands are attempted to be 1915/// converted to each other. This function does the conversion in one direction. 1916/// It returns true if the program is ill-formed and has already been diagnosed 1917/// as such. 1918static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, 1919 SourceLocation QuestionLoc, 1920 bool &HaveConversion, 1921 QualType &ToType) { 1922 HaveConversion = false; 1923 ToType = To->getType(); 1924 1925 InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(), 1926 SourceLocation()); 1927 // C++0x 5.16p3 1928 // The process for determining whether an operand expression E1 of type T1 1929 // can be converted to match an operand expression E2 of type T2 is defined 1930 // as follows: 1931 // -- If E2 is an lvalue: 1932 if (To->isLvalue(Self.Context) == Expr::LV_Valid) { 1933 // E1 can be converted to match E2 if E1 can be implicitly converted to 1934 // type "lvalue reference to T2", subject to the constraint that in the 1935 // conversion the reference must bind directly to E1. 1936 QualType T = Self.Context.getLValueReferenceType(ToType); 1937 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 1938 1939 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 1940 if (InitSeq.isDirectReferenceBinding()) { 1941 ToType = T; 1942 HaveConversion = true; 1943 return false; 1944 } 1945 1946 if (InitSeq.isAmbiguous()) 1947 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 1948 } 1949 1950 // -- If E2 is an rvalue, or if the conversion above cannot be done: 1951 // -- if E1 and E2 have class type, and the underlying class types are 1952 // the same or one is a base class of the other: 1953 QualType FTy = From->getType(); 1954 QualType TTy = To->getType(); 1955 const RecordType *FRec = FTy->getAs<RecordType>(); 1956 const RecordType *TRec = TTy->getAs<RecordType>(); 1957 bool FDerivedFromT = FRec && TRec && FRec != TRec && 1958 Self.IsDerivedFrom(FTy, TTy); 1959 if (FRec && TRec && 1960 (FRec == TRec || FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) { 1961 // E1 can be converted to match E2 if the class of T2 is the 1962 // same type as, or a base class of, the class of T1, and 1963 // [cv2 > cv1]. 1964 if (FRec == TRec || FDerivedFromT) { 1965 if (TTy.isAtLeastAsQualifiedAs(FTy)) { 1966 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 1967 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 1968 if (InitSeq.getKind() != InitializationSequence::FailedSequence) { 1969 HaveConversion = true; 1970 return false; 1971 } 1972 1973 if (InitSeq.isAmbiguous()) 1974 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 1975 } 1976 } 1977 1978 return false; 1979 } 1980 1981 // -- Otherwise: E1 can be converted to match E2 if E1 can be 1982 // implicitly converted to the type that expression E2 would have 1983 // if E2 were converted to an rvalue. 1984 // First find the decayed type. 1985 if (TTy->isFunctionType()) 1986 TTy = Self.Context.getPointerType(TTy); 1987 else if (TTy->isArrayType()) 1988 TTy = Self.Context.getArrayDecayedType(TTy); 1989 1990 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 1991 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 1992 HaveConversion = InitSeq.getKind() != InitializationSequence::FailedSequence; 1993 ToType = TTy; 1994 if (InitSeq.isAmbiguous()) 1995 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 1996 1997 return false; 1998} 1999 2000/// \brief Try to find a common type for two according to C++0x 5.16p5. 2001/// 2002/// This is part of the parameter validation for the ? operator. If either 2003/// value operand is a class type, overload resolution is used to find a 2004/// conversion to a common type. 2005static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS, 2006 SourceLocation Loc) { 2007 Expr *Args[2] = { LHS, RHS }; 2008 OverloadCandidateSet CandidateSet(Loc); 2009 Self.AddBuiltinOperatorCandidates(OO_Conditional, Loc, Args, 2, CandidateSet); 2010 2011 OverloadCandidateSet::iterator Best; 2012 switch (Self.BestViableFunction(CandidateSet, Loc, Best)) { 2013 case OR_Success: 2014 // We found a match. Perform the conversions on the arguments and move on. 2015 if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0], 2016 Best->Conversions[0], Sema::AA_Converting) || 2017 Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1], 2018 Best->Conversions[1], Sema::AA_Converting)) 2019 break; 2020 return false; 2021 2022 case OR_No_Viable_Function: 2023 Self.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 2024 << LHS->getType() << RHS->getType() 2025 << LHS->getSourceRange() << RHS->getSourceRange(); 2026 return true; 2027 2028 case OR_Ambiguous: 2029 Self.Diag(Loc, diag::err_conditional_ambiguous_ovl) 2030 << LHS->getType() << RHS->getType() 2031 << LHS->getSourceRange() << RHS->getSourceRange(); 2032 // FIXME: Print the possible common types by printing the return types of 2033 // the viable candidates. 2034 break; 2035 2036 case OR_Deleted: 2037 assert(false && "Conditional operator has only built-in overloads"); 2038 break; 2039 } 2040 return true; 2041} 2042 2043/// \brief Perform an "extended" implicit conversion as returned by 2044/// TryClassUnification. 2045static bool ConvertForConditional(Sema &Self, Expr *&E, QualType T) { 2046 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 2047 InitializationKind Kind = InitializationKind::CreateCopy(E->getLocStart(), 2048 SourceLocation()); 2049 InitializationSequence InitSeq(Self, Entity, Kind, &E, 1); 2050 Sema::OwningExprResult Result = InitSeq.Perform(Self, Entity, Kind, 2051 Sema::MultiExprArg(Self, (void **)&E, 1)); 2052 if (Result.isInvalid()) 2053 return true; 2054 2055 E = Result.takeAs<Expr>(); 2056 return false; 2057} 2058 2059/// \brief Check the operands of ?: under C++ semantics. 2060/// 2061/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y 2062/// extension. In this case, LHS == Cond. (But they're not aliases.) 2063QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, 2064 SourceLocation QuestionLoc) { 2065 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++ 2066 // interface pointers. 2067 2068 // C++0x 5.16p1 2069 // The first expression is contextually converted to bool. 2070 if (!Cond->isTypeDependent()) { 2071 if (CheckCXXBooleanCondition(Cond)) 2072 return QualType(); 2073 } 2074 2075 // Either of the arguments dependent? 2076 if (LHS->isTypeDependent() || RHS->isTypeDependent()) 2077 return Context.DependentTy; 2078 2079 CheckSignCompare(LHS, RHS, QuestionLoc); 2080 2081 // C++0x 5.16p2 2082 // If either the second or the third operand has type (cv) void, ... 2083 QualType LTy = LHS->getType(); 2084 QualType RTy = RHS->getType(); 2085 bool LVoid = LTy->isVoidType(); 2086 bool RVoid = RTy->isVoidType(); 2087 if (LVoid || RVoid) { 2088 // ... then the [l2r] conversions are performed on the second and third 2089 // operands ... 2090 DefaultFunctionArrayLvalueConversion(LHS); 2091 DefaultFunctionArrayLvalueConversion(RHS); 2092 LTy = LHS->getType(); 2093 RTy = RHS->getType(); 2094 2095 // ... and one of the following shall hold: 2096 // -- The second or the third operand (but not both) is a throw- 2097 // expression; the result is of the type of the other and is an rvalue. 2098 bool LThrow = isa<CXXThrowExpr>(LHS); 2099 bool RThrow = isa<CXXThrowExpr>(RHS); 2100 if (LThrow && !RThrow) 2101 return RTy; 2102 if (RThrow && !LThrow) 2103 return LTy; 2104 2105 // -- Both the second and third operands have type void; the result is of 2106 // type void and is an rvalue. 2107 if (LVoid && RVoid) 2108 return Context.VoidTy; 2109 2110 // Neither holds, error. 2111 Diag(QuestionLoc, diag::err_conditional_void_nonvoid) 2112 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1) 2113 << LHS->getSourceRange() << RHS->getSourceRange(); 2114 return QualType(); 2115 } 2116 2117 // Neither is void. 2118 2119 // C++0x 5.16p3 2120 // Otherwise, if the second and third operand have different types, and 2121 // either has (cv) class type, and attempt is made to convert each of those 2122 // operands to the other. 2123 if (!Context.hasSameType(LTy, RTy) && 2124 (LTy->isRecordType() || RTy->isRecordType())) { 2125 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft; 2126 // These return true if a single direction is already ambiguous. 2127 QualType L2RType, R2LType; 2128 bool HaveL2R, HaveR2L; 2129 if (TryClassUnification(*this, LHS, RHS, QuestionLoc, HaveL2R, L2RType)) 2130 return QualType(); 2131 if (TryClassUnification(*this, RHS, LHS, QuestionLoc, HaveR2L, R2LType)) 2132 return QualType(); 2133 2134 // If both can be converted, [...] the program is ill-formed. 2135 if (HaveL2R && HaveR2L) { 2136 Diag(QuestionLoc, diag::err_conditional_ambiguous) 2137 << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange(); 2138 return QualType(); 2139 } 2140 2141 // If exactly one conversion is possible, that conversion is applied to 2142 // the chosen operand and the converted operands are used in place of the 2143 // original operands for the remainder of this section. 2144 if (HaveL2R) { 2145 if (ConvertForConditional(*this, LHS, L2RType)) 2146 return QualType(); 2147 LTy = LHS->getType(); 2148 } else if (HaveR2L) { 2149 if (ConvertForConditional(*this, RHS, R2LType)) 2150 return QualType(); 2151 RTy = RHS->getType(); 2152 } 2153 } 2154 2155 // C++0x 5.16p4 2156 // If the second and third operands are lvalues and have the same type, 2157 // the result is of that type [...] 2158 bool Same = Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy); 2159 if (Same && LHS->isLvalue(Context) == Expr::LV_Valid && 2160 RHS->isLvalue(Context) == Expr::LV_Valid) 2161 return LTy; 2162 2163 // C++0x 5.16p5 2164 // Otherwise, the result is an rvalue. If the second and third operands 2165 // do not have the same type, and either has (cv) class type, ... 2166 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) { 2167 // ... overload resolution is used to determine the conversions (if any) 2168 // to be applied to the operands. If the overload resolution fails, the 2169 // program is ill-formed. 2170 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc)) 2171 return QualType(); 2172 } 2173 2174 // C++0x 5.16p6 2175 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard 2176 // conversions are performed on the second and third operands. 2177 DefaultFunctionArrayLvalueConversion(LHS); 2178 DefaultFunctionArrayLvalueConversion(RHS); 2179 LTy = LHS->getType(); 2180 RTy = RHS->getType(); 2181 2182 // After those conversions, one of the following shall hold: 2183 // -- The second and third operands have the same type; the result 2184 // is of that type. 2185 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) 2186 return LTy; 2187 2188 // -- The second and third operands have arithmetic or enumeration type; 2189 // the usual arithmetic conversions are performed to bring them to a 2190 // common type, and the result is of that type. 2191 if (LTy->isArithmeticType() && RTy->isArithmeticType()) { 2192 UsualArithmeticConversions(LHS, RHS); 2193 return LHS->getType(); 2194 } 2195 2196 // -- The second and third operands have pointer type, or one has pointer 2197 // type and the other is a null pointer constant; pointer conversions 2198 // and qualification conversions are performed to bring them to their 2199 // composite pointer type. The result is of the composite pointer type. 2200 // -- The second and third operands have pointer to member type, or one has 2201 // pointer to member type and the other is a null pointer constant; 2202 // pointer to member conversions and qualification conversions are 2203 // performed to bring them to a common type, whose cv-qualification 2204 // shall match the cv-qualification of either the second or the third 2205 // operand. The result is of the common type. 2206 bool NonStandardCompositeType = false; 2207 QualType Composite = FindCompositePointerType(LHS, RHS, 2208 isSFINAEContext()? 0 : &NonStandardCompositeType); 2209 if (!Composite.isNull()) { 2210 if (NonStandardCompositeType) 2211 Diag(QuestionLoc, 2212 diag::ext_typecheck_cond_incompatible_operands_nonstandard) 2213 << LTy << RTy << Composite 2214 << LHS->getSourceRange() << RHS->getSourceRange(); 2215 2216 return Composite; 2217 } 2218 2219 // Similarly, attempt to find composite type of twp objective-c pointers. 2220 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc); 2221 if (!Composite.isNull()) 2222 return Composite; 2223 2224 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 2225 << LHS->getType() << RHS->getType() 2226 << LHS->getSourceRange() << RHS->getSourceRange(); 2227 return QualType(); 2228} 2229 2230/// \brief Find a merged pointer type and convert the two expressions to it. 2231/// 2232/// This finds the composite pointer type (or member pointer type) for @p E1 2233/// and @p E2 according to C++0x 5.9p2. It converts both expressions to this 2234/// type and returns it. 2235/// It does not emit diagnostics. 2236/// 2237/// If \p NonStandardCompositeType is non-NULL, then we are permitted to find 2238/// a non-standard (but still sane) composite type to which both expressions 2239/// can be converted. When such a type is chosen, \c *NonStandardCompositeType 2240/// will be set true. 2241QualType Sema::FindCompositePointerType(Expr *&E1, Expr *&E2, 2242 bool *NonStandardCompositeType) { 2243 if (NonStandardCompositeType) 2244 *NonStandardCompositeType = false; 2245 2246 assert(getLangOptions().CPlusPlus && "This function assumes C++"); 2247 QualType T1 = E1->getType(), T2 = E2->getType(); 2248 2249 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() && 2250 !T2->isAnyPointerType() && !T2->isMemberPointerType()) 2251 return QualType(); 2252 2253 // C++0x 5.9p2 2254 // Pointer conversions and qualification conversions are performed on 2255 // pointer operands to bring them to their composite pointer type. If 2256 // one operand is a null pointer constant, the composite pointer type is 2257 // the type of the other operand. 2258 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 2259 if (T2->isMemberPointerType()) 2260 ImpCastExprToType(E1, T2, CastExpr::CK_NullToMemberPointer); 2261 else 2262 ImpCastExprToType(E1, T2, CastExpr::CK_IntegralToPointer); 2263 return T2; 2264 } 2265 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 2266 if (T1->isMemberPointerType()) 2267 ImpCastExprToType(E2, T1, CastExpr::CK_NullToMemberPointer); 2268 else 2269 ImpCastExprToType(E2, T1, CastExpr::CK_IntegralToPointer); 2270 return T1; 2271 } 2272 2273 // Now both have to be pointers or member pointers. 2274 if ((!T1->isPointerType() && !T1->isMemberPointerType()) || 2275 (!T2->isPointerType() && !T2->isMemberPointerType())) 2276 return QualType(); 2277 2278 // Otherwise, of one of the operands has type "pointer to cv1 void," then 2279 // the other has type "pointer to cv2 T" and the composite pointer type is 2280 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2. 2281 // Otherwise, the composite pointer type is a pointer type similar to the 2282 // type of one of the operands, with a cv-qualification signature that is 2283 // the union of the cv-qualification signatures of the operand types. 2284 // In practice, the first part here is redundant; it's subsumed by the second. 2285 // What we do here is, we build the two possible composite types, and try the 2286 // conversions in both directions. If only one works, or if the two composite 2287 // types are the same, we have succeeded. 2288 // FIXME: extended qualifiers? 2289 typedef llvm::SmallVector<unsigned, 4> QualifierVector; 2290 QualifierVector QualifierUnion; 2291 typedef llvm::SmallVector<std::pair<const Type *, const Type *>, 4> 2292 ContainingClassVector; 2293 ContainingClassVector MemberOfClass; 2294 QualType Composite1 = Context.getCanonicalType(T1), 2295 Composite2 = Context.getCanonicalType(T2); 2296 unsigned NeedConstBefore = 0; 2297 do { 2298 const PointerType *Ptr1, *Ptr2; 2299 if ((Ptr1 = Composite1->getAs<PointerType>()) && 2300 (Ptr2 = Composite2->getAs<PointerType>())) { 2301 Composite1 = Ptr1->getPointeeType(); 2302 Composite2 = Ptr2->getPointeeType(); 2303 2304 // If we're allowed to create a non-standard composite type, keep track 2305 // of where we need to fill in additional 'const' qualifiers. 2306 if (NonStandardCompositeType && 2307 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 2308 NeedConstBefore = QualifierUnion.size(); 2309 2310 QualifierUnion.push_back( 2311 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 2312 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0)); 2313 continue; 2314 } 2315 2316 const MemberPointerType *MemPtr1, *MemPtr2; 2317 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) && 2318 (MemPtr2 = Composite2->getAs<MemberPointerType>())) { 2319 Composite1 = MemPtr1->getPointeeType(); 2320 Composite2 = MemPtr2->getPointeeType(); 2321 2322 // If we're allowed to create a non-standard composite type, keep track 2323 // of where we need to fill in additional 'const' qualifiers. 2324 if (NonStandardCompositeType && 2325 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 2326 NeedConstBefore = QualifierUnion.size(); 2327 2328 QualifierUnion.push_back( 2329 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 2330 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(), 2331 MemPtr2->getClass())); 2332 continue; 2333 } 2334 2335 // FIXME: block pointer types? 2336 2337 // Cannot unwrap any more types. 2338 break; 2339 } while (true); 2340 2341 if (NeedConstBefore && NonStandardCompositeType) { 2342 // Extension: Add 'const' to qualifiers that come before the first qualifier 2343 // mismatch, so that our (non-standard!) composite type meets the 2344 // requirements of C++ [conv.qual]p4 bullet 3. 2345 for (unsigned I = 0; I != NeedConstBefore; ++I) { 2346 if ((QualifierUnion[I] & Qualifiers::Const) == 0) { 2347 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const; 2348 *NonStandardCompositeType = true; 2349 } 2350 } 2351 } 2352 2353 // Rewrap the composites as pointers or member pointers with the union CVRs. 2354 ContainingClassVector::reverse_iterator MOC 2355 = MemberOfClass.rbegin(); 2356 for (QualifierVector::reverse_iterator 2357 I = QualifierUnion.rbegin(), 2358 E = QualifierUnion.rend(); 2359 I != E; (void)++I, ++MOC) { 2360 Qualifiers Quals = Qualifiers::fromCVRMask(*I); 2361 if (MOC->first && MOC->second) { 2362 // Rebuild member pointer type 2363 Composite1 = Context.getMemberPointerType( 2364 Context.getQualifiedType(Composite1, Quals), 2365 MOC->first); 2366 Composite2 = Context.getMemberPointerType( 2367 Context.getQualifiedType(Composite2, Quals), 2368 MOC->second); 2369 } else { 2370 // Rebuild pointer type 2371 Composite1 2372 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals)); 2373 Composite2 2374 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals)); 2375 } 2376 } 2377 2378 ImplicitConversionSequence E1ToC1 = 2379 TryImplicitConversion(E1, Composite1, 2380 /*SuppressUserConversions=*/false, 2381 /*AllowExplicit=*/false, 2382 /*ForceRValue=*/false, 2383 /*InOverloadResolution=*/false); 2384 ImplicitConversionSequence E2ToC1 = 2385 TryImplicitConversion(E2, Composite1, 2386 /*SuppressUserConversions=*/false, 2387 /*AllowExplicit=*/false, 2388 /*ForceRValue=*/false, 2389 /*InOverloadResolution=*/false); 2390 2391 bool ToC2Viable = false; 2392 ImplicitConversionSequence E1ToC2, E2ToC2; 2393 if (Context.getCanonicalType(Composite1) != 2394 Context.getCanonicalType(Composite2)) { 2395 E1ToC2 = TryImplicitConversion(E1, Composite2, 2396 /*SuppressUserConversions=*/false, 2397 /*AllowExplicit=*/false, 2398 /*ForceRValue=*/false, 2399 /*InOverloadResolution=*/false); 2400 E2ToC2 = TryImplicitConversion(E2, Composite2, 2401 /*SuppressUserConversions=*/false, 2402 /*AllowExplicit=*/false, 2403 /*ForceRValue=*/false, 2404 /*InOverloadResolution=*/false); 2405 ToC2Viable = !E1ToC2.isBad() && !E2ToC2.isBad(); 2406 } 2407 2408 bool ToC1Viable = !E1ToC1.isBad() && !E2ToC1.isBad(); 2409 if (ToC1Viable && !ToC2Viable) { 2410 if (!PerformImplicitConversion(E1, Composite1, E1ToC1, Sema::AA_Converting) && 2411 !PerformImplicitConversion(E2, Composite1, E2ToC1, Sema::AA_Converting)) 2412 return Composite1; 2413 } 2414 if (ToC2Viable && !ToC1Viable) { 2415 if (!PerformImplicitConversion(E1, Composite2, E1ToC2, Sema::AA_Converting) && 2416 !PerformImplicitConversion(E2, Composite2, E2ToC2, Sema::AA_Converting)) 2417 return Composite2; 2418 } 2419 return QualType(); 2420} 2421 2422Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) { 2423 if (!Context.getLangOptions().CPlusPlus) 2424 return Owned(E); 2425 2426 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?"); 2427 2428 const RecordType *RT = E->getType()->getAs<RecordType>(); 2429 if (!RT) 2430 return Owned(E); 2431 2432 // If this is the result of a call expression, our source might 2433 // actually be a reference, in which case we shouldn't bind. 2434 if (CallExpr *CE = dyn_cast<CallExpr>(E)) { 2435 QualType Ty = CE->getCallee()->getType(); 2436 if (const PointerType *PT = Ty->getAs<PointerType>()) 2437 Ty = PT->getPointeeType(); 2438 else if (const BlockPointerType *BPT = Ty->getAs<BlockPointerType>()) 2439 Ty = BPT->getPointeeType(); 2440 2441 const FunctionType *FTy = Ty->getAs<FunctionType>(); 2442 if (FTy->getResultType()->isReferenceType()) 2443 return Owned(E); 2444 } 2445 2446 // That should be enough to guarantee that this type is complete. 2447 // If it has a trivial destructor, we can avoid the extra copy. 2448 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 2449 if (RD->hasTrivialDestructor()) 2450 return Owned(E); 2451 2452 CXXTemporary *Temp = CXXTemporary::Create(Context, 2453 RD->getDestructor(Context)); 2454 ExprTemporaries.push_back(Temp); 2455 if (CXXDestructorDecl *Destructor = 2456 const_cast<CXXDestructorDecl*>(RD->getDestructor(Context))) 2457 MarkDeclarationReferenced(E->getExprLoc(), Destructor); 2458 // FIXME: Add the temporary to the temporaries vector. 2459 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E)); 2460} 2461 2462Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr) { 2463 assert(SubExpr && "sub expression can't be null!"); 2464 2465 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 2466 assert(ExprTemporaries.size() >= FirstTemporary); 2467 if (ExprTemporaries.size() == FirstTemporary) 2468 return SubExpr; 2469 2470 Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr, 2471 &ExprTemporaries[FirstTemporary], 2472 ExprTemporaries.size() - FirstTemporary); 2473 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 2474 ExprTemporaries.end()); 2475 2476 return E; 2477} 2478 2479Sema::OwningExprResult 2480Sema::MaybeCreateCXXExprWithTemporaries(OwningExprResult SubExpr) { 2481 if (SubExpr.isInvalid()) 2482 return ExprError(); 2483 2484 return Owned(MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>())); 2485} 2486 2487FullExpr Sema::CreateFullExpr(Expr *SubExpr) { 2488 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 2489 assert(ExprTemporaries.size() >= FirstTemporary); 2490 2491 unsigned NumTemporaries = ExprTemporaries.size() - FirstTemporary; 2492 CXXTemporary **Temporaries = 2493 NumTemporaries == 0 ? 0 : &ExprTemporaries[FirstTemporary]; 2494 2495 FullExpr E = FullExpr::Create(Context, SubExpr, Temporaries, NumTemporaries); 2496 2497 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 2498 ExprTemporaries.end()); 2499 2500 return E; 2501} 2502 2503Sema::OwningExprResult 2504Sema::ActOnStartCXXMemberReference(Scope *S, ExprArg Base, SourceLocation OpLoc, 2505 tok::TokenKind OpKind, TypeTy *&ObjectType, 2506 bool &MayBePseudoDestructor) { 2507 // Since this might be a postfix expression, get rid of ParenListExprs. 2508 Base = MaybeConvertParenListExprToParenExpr(S, move(Base)); 2509 2510 Expr *BaseExpr = (Expr*)Base.get(); 2511 assert(BaseExpr && "no record expansion"); 2512 2513 QualType BaseType = BaseExpr->getType(); 2514 MayBePseudoDestructor = false; 2515 if (BaseType->isDependentType()) { 2516 // If we have a pointer to a dependent type and are using the -> operator, 2517 // the object type is the type that the pointer points to. We might still 2518 // have enough information about that type to do something useful. 2519 if (OpKind == tok::arrow) 2520 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 2521 BaseType = Ptr->getPointeeType(); 2522 2523 ObjectType = BaseType.getAsOpaquePtr(); 2524 MayBePseudoDestructor = true; 2525 return move(Base); 2526 } 2527 2528 // C++ [over.match.oper]p8: 2529 // [...] When operator->returns, the operator-> is applied to the value 2530 // returned, with the original second operand. 2531 if (OpKind == tok::arrow) { 2532 // The set of types we've considered so far. 2533 llvm::SmallPtrSet<CanQualType,8> CTypes; 2534 llvm::SmallVector<SourceLocation, 8> Locations; 2535 CTypes.insert(Context.getCanonicalType(BaseType)); 2536 2537 while (BaseType->isRecordType()) { 2538 Base = BuildOverloadedArrowExpr(S, move(Base), OpLoc); 2539 BaseExpr = (Expr*)Base.get(); 2540 if (BaseExpr == NULL) 2541 return ExprError(); 2542 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(BaseExpr)) 2543 Locations.push_back(OpCall->getDirectCallee()->getLocation()); 2544 BaseType = BaseExpr->getType(); 2545 CanQualType CBaseType = Context.getCanonicalType(BaseType); 2546 if (!CTypes.insert(CBaseType)) { 2547 Diag(OpLoc, diag::err_operator_arrow_circular); 2548 for (unsigned i = 0; i < Locations.size(); i++) 2549 Diag(Locations[i], diag::note_declared_at); 2550 return ExprError(); 2551 } 2552 } 2553 2554 if (BaseType->isPointerType()) 2555 BaseType = BaseType->getPointeeType(); 2556 } 2557 2558 // We could end up with various non-record types here, such as extended 2559 // vector types or Objective-C interfaces. Just return early and let 2560 // ActOnMemberReferenceExpr do the work. 2561 if (!BaseType->isRecordType()) { 2562 // C++ [basic.lookup.classref]p2: 2563 // [...] If the type of the object expression is of pointer to scalar 2564 // type, the unqualified-id is looked up in the context of the complete 2565 // postfix-expression. 2566 // 2567 // This also indicates that we should be parsing a 2568 // pseudo-destructor-name. 2569 ObjectType = 0; 2570 MayBePseudoDestructor = true; 2571 return move(Base); 2572 } 2573 2574 // The object type must be complete (or dependent). 2575 if (!BaseType->isDependentType() && 2576 RequireCompleteType(OpLoc, BaseType, 2577 PDiag(diag::err_incomplete_member_access))) 2578 return ExprError(); 2579 2580 // C++ [basic.lookup.classref]p2: 2581 // If the id-expression in a class member access (5.2.5) is an 2582 // unqualified-id, and the type of the object expression is of a class 2583 // type C (or of pointer to a class type C), the unqualified-id is looked 2584 // up in the scope of class C. [...] 2585 ObjectType = BaseType.getAsOpaquePtr(); 2586 return move(Base); 2587} 2588 2589Sema::OwningExprResult Sema::DiagnoseDtorReference(SourceLocation NameLoc, 2590 ExprArg MemExpr) { 2591 Expr *E = (Expr *) MemExpr.get(); 2592 SourceLocation ExpectedLParenLoc = PP.getLocForEndOfToken(NameLoc); 2593 Diag(E->getLocStart(), diag::err_dtor_expr_without_call) 2594 << isa<CXXPseudoDestructorExpr>(E) 2595 << CodeModificationHint::CreateInsertion(ExpectedLParenLoc, "()"); 2596 2597 return ActOnCallExpr(/*Scope*/ 0, 2598 move(MemExpr), 2599 /*LPLoc*/ ExpectedLParenLoc, 2600 Sema::MultiExprArg(*this, 0, 0), 2601 /*CommaLocs*/ 0, 2602 /*RPLoc*/ ExpectedLParenLoc); 2603} 2604 2605Sema::OwningExprResult Sema::BuildPseudoDestructorExpr(ExprArg Base, 2606 SourceLocation OpLoc, 2607 tok::TokenKind OpKind, 2608 const CXXScopeSpec &SS, 2609 TypeSourceInfo *ScopeTypeInfo, 2610 SourceLocation CCLoc, 2611 SourceLocation TildeLoc, 2612 PseudoDestructorTypeStorage Destructed, 2613 bool HasTrailingLParen) { 2614 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo(); 2615 2616 // C++ [expr.pseudo]p2: 2617 // The left-hand side of the dot operator shall be of scalar type. The 2618 // left-hand side of the arrow operator shall be of pointer to scalar type. 2619 // This scalar type is the object type. 2620 Expr *BaseE = (Expr *)Base.get(); 2621 QualType ObjectType = BaseE->getType(); 2622 if (OpKind == tok::arrow) { 2623 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 2624 ObjectType = Ptr->getPointeeType(); 2625 } else if (!BaseE->isTypeDependent()) { 2626 // The user wrote "p->" when she probably meant "p."; fix it. 2627 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 2628 << ObjectType << true 2629 << CodeModificationHint::CreateReplacement(OpLoc, "."); 2630 if (isSFINAEContext()) 2631 return ExprError(); 2632 2633 OpKind = tok::period; 2634 } 2635 } 2636 2637 if (!ObjectType->isDependentType() && !ObjectType->isScalarType()) { 2638 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar) 2639 << ObjectType << BaseE->getSourceRange(); 2640 return ExprError(); 2641 } 2642 2643 // C++ [expr.pseudo]p2: 2644 // [...] The cv-unqualified versions of the object type and of the type 2645 // designated by the pseudo-destructor-name shall be the same type. 2646 if (DestructedTypeInfo) { 2647 QualType DestructedType = DestructedTypeInfo->getType(); 2648 SourceLocation DestructedTypeStart 2649 = DestructedTypeInfo->getTypeLoc().getSourceRange().getBegin(); 2650 if (!DestructedType->isDependentType() && !ObjectType->isDependentType() && 2651 !Context.hasSameUnqualifiedType(DestructedType, ObjectType)) { 2652 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch) 2653 << ObjectType << DestructedType << BaseE->getSourceRange() 2654 << DestructedTypeInfo->getTypeLoc().getSourceRange(); 2655 2656 // Recover by setting the destructed type to the object type. 2657 DestructedType = ObjectType; 2658 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType, 2659 DestructedTypeStart); 2660 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 2661 } 2662 } 2663 2664 // C++ [expr.pseudo]p2: 2665 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the 2666 // form 2667 // 2668 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name 2669 // 2670 // shall designate the same scalar type. 2671 if (ScopeTypeInfo) { 2672 QualType ScopeType = ScopeTypeInfo->getType(); 2673 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() && 2674 !Context.hasSameType(ScopeType, ObjectType)) { 2675 2676 Diag(ScopeTypeInfo->getTypeLoc().getSourceRange().getBegin(), 2677 diag::err_pseudo_dtor_type_mismatch) 2678 << ObjectType << ScopeType << BaseE->getSourceRange() 2679 << ScopeTypeInfo->getTypeLoc().getSourceRange(); 2680 2681 ScopeType = QualType(); 2682 ScopeTypeInfo = 0; 2683 } 2684 } 2685 2686 OwningExprResult Result 2687 = Owned(new (Context) CXXPseudoDestructorExpr(Context, 2688 Base.takeAs<Expr>(), 2689 OpKind == tok::arrow, 2690 OpLoc, 2691 (NestedNameSpecifier *) SS.getScopeRep(), 2692 SS.getRange(), 2693 ScopeTypeInfo, 2694 CCLoc, 2695 TildeLoc, 2696 Destructed)); 2697 2698 if (HasTrailingLParen) 2699 return move(Result); 2700 2701 return DiagnoseDtorReference(Destructed.getLocation(), move(Result)); 2702} 2703 2704Sema::OwningExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, ExprArg Base, 2705 SourceLocation OpLoc, 2706 tok::TokenKind OpKind, 2707 const CXXScopeSpec &SS, 2708 UnqualifiedId &FirstTypeName, 2709 SourceLocation CCLoc, 2710 SourceLocation TildeLoc, 2711 UnqualifiedId &SecondTypeName, 2712 bool HasTrailingLParen) { 2713 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2714 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) && 2715 "Invalid first type name in pseudo-destructor"); 2716 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2717 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) && 2718 "Invalid second type name in pseudo-destructor"); 2719 2720 Expr *BaseE = (Expr *)Base.get(); 2721 2722 // C++ [expr.pseudo]p2: 2723 // The left-hand side of the dot operator shall be of scalar type. The 2724 // left-hand side of the arrow operator shall be of pointer to scalar type. 2725 // This scalar type is the object type. 2726 QualType ObjectType = BaseE->getType(); 2727 if (OpKind == tok::arrow) { 2728 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 2729 ObjectType = Ptr->getPointeeType(); 2730 } else if (!ObjectType->isDependentType()) { 2731 // The user wrote "p->" when she probably meant "p."; fix it. 2732 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 2733 << ObjectType << true 2734 << CodeModificationHint::CreateReplacement(OpLoc, "."); 2735 if (isSFINAEContext()) 2736 return ExprError(); 2737 2738 OpKind = tok::period; 2739 } 2740 } 2741 2742 // Compute the object type that we should use for name lookup purposes. Only 2743 // record types and dependent types matter. 2744 void *ObjectTypePtrForLookup = 0; 2745 if (!SS.isSet()) { 2746 ObjectTypePtrForLookup = (void *)ObjectType->getAs<RecordType>(); 2747 if (!ObjectTypePtrForLookup && ObjectType->isDependentType()) 2748 ObjectTypePtrForLookup = Context.DependentTy.getAsOpaquePtr(); 2749 } 2750 2751 // Convert the name of the type being destructed (following the ~) into a 2752 // type (with source-location information). 2753 QualType DestructedType; 2754 TypeSourceInfo *DestructedTypeInfo = 0; 2755 PseudoDestructorTypeStorage Destructed; 2756 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) { 2757 TypeTy *T = getTypeName(*SecondTypeName.Identifier, 2758 SecondTypeName.StartLocation, 2759 S, &SS, true, ObjectTypePtrForLookup); 2760 if (!T && 2761 ((SS.isSet() && !computeDeclContext(SS, false)) || 2762 (!SS.isSet() && ObjectType->isDependentType()))) { 2763 // The name of the type being destroyed is a dependent name, and we 2764 // couldn't find anything useful in scope. Just store the identifier and 2765 // it's location, and we'll perform (qualified) name lookup again at 2766 // template instantiation time. 2767 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier, 2768 SecondTypeName.StartLocation); 2769 } else if (!T) { 2770 Diag(SecondTypeName.StartLocation, 2771 diag::err_pseudo_dtor_destructor_non_type) 2772 << SecondTypeName.Identifier << ObjectType; 2773 if (isSFINAEContext()) 2774 return ExprError(); 2775 2776 // Recover by assuming we had the right type all along. 2777 DestructedType = ObjectType; 2778 } else 2779 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo); 2780 } else { 2781 // Resolve the template-id to a type. 2782 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId; 2783 ASTTemplateArgsPtr TemplateArgsPtr(*this, 2784 TemplateId->getTemplateArgs(), 2785 TemplateId->NumArgs); 2786 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template), 2787 TemplateId->TemplateNameLoc, 2788 TemplateId->LAngleLoc, 2789 TemplateArgsPtr, 2790 TemplateId->RAngleLoc); 2791 if (T.isInvalid() || !T.get()) { 2792 // Recover by assuming we had the right type all along. 2793 DestructedType = ObjectType; 2794 } else 2795 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo); 2796 } 2797 2798 // If we've performed some kind of recovery, (re-)build the type source 2799 // information. 2800 if (!DestructedType.isNull()) { 2801 if (!DestructedTypeInfo) 2802 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType, 2803 SecondTypeName.StartLocation); 2804 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 2805 } 2806 2807 // Convert the name of the scope type (the type prior to '::') into a type. 2808 TypeSourceInfo *ScopeTypeInfo = 0; 2809 QualType ScopeType; 2810 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2811 FirstTypeName.Identifier) { 2812 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) { 2813 TypeTy *T = getTypeName(*FirstTypeName.Identifier, 2814 FirstTypeName.StartLocation, 2815 S, &SS, false, ObjectTypePtrForLookup); 2816 if (!T) { 2817 Diag(FirstTypeName.StartLocation, 2818 diag::err_pseudo_dtor_destructor_non_type) 2819 << FirstTypeName.Identifier << ObjectType; 2820 2821 if (isSFINAEContext()) 2822 return ExprError(); 2823 2824 // Just drop this type. It's unnecessary anyway. 2825 ScopeType = QualType(); 2826 } else 2827 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo); 2828 } else { 2829 // Resolve the template-id to a type. 2830 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId; 2831 ASTTemplateArgsPtr TemplateArgsPtr(*this, 2832 TemplateId->getTemplateArgs(), 2833 TemplateId->NumArgs); 2834 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template), 2835 TemplateId->TemplateNameLoc, 2836 TemplateId->LAngleLoc, 2837 TemplateArgsPtr, 2838 TemplateId->RAngleLoc); 2839 if (T.isInvalid() || !T.get()) { 2840 // Recover by dropping this type. 2841 ScopeType = QualType(); 2842 } else 2843 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo); 2844 } 2845 } 2846 2847 if (!ScopeType.isNull() && !ScopeTypeInfo) 2848 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType, 2849 FirstTypeName.StartLocation); 2850 2851 2852 return BuildPseudoDestructorExpr(move(Base), OpLoc, OpKind, SS, 2853 ScopeTypeInfo, CCLoc, TildeLoc, 2854 Destructed, HasTrailingLParen); 2855} 2856 2857CXXMemberCallExpr *Sema::BuildCXXMemberCallExpr(Expr *Exp, 2858 CXXMethodDecl *Method) { 2859 if (PerformObjectArgumentInitialization(Exp, /*Qualifier=*/0, Method)) 2860 assert(0 && "Calling BuildCXXMemberCallExpr with invalid call?"); 2861 2862 MemberExpr *ME = 2863 new (Context) MemberExpr(Exp, /*IsArrow=*/false, Method, 2864 SourceLocation(), Method->getType()); 2865 QualType ResultType = Method->getResultType().getNonReferenceType(); 2866 MarkDeclarationReferenced(Exp->getLocStart(), Method); 2867 CXXMemberCallExpr *CE = 2868 new (Context) CXXMemberCallExpr(Context, ME, 0, 0, ResultType, 2869 Exp->getLocEnd()); 2870 return CE; 2871} 2872 2873Sema::OwningExprResult Sema::BuildCXXCastArgument(SourceLocation CastLoc, 2874 QualType Ty, 2875 CastExpr::CastKind Kind, 2876 CXXMethodDecl *Method, 2877 ExprArg Arg) { 2878 Expr *From = Arg.takeAs<Expr>(); 2879 2880 switch (Kind) { 2881 default: assert(0 && "Unhandled cast kind!"); 2882 case CastExpr::CK_ConstructorConversion: { 2883 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this); 2884 2885 if (CompleteConstructorCall(cast<CXXConstructorDecl>(Method), 2886 MultiExprArg(*this, (void **)&From, 1), 2887 CastLoc, ConstructorArgs)) 2888 return ExprError(); 2889 2890 OwningExprResult Result = 2891 BuildCXXConstructExpr(CastLoc, Ty, cast<CXXConstructorDecl>(Method), 2892 move_arg(ConstructorArgs)); 2893 if (Result.isInvalid()) 2894 return ExprError(); 2895 2896 return MaybeBindToTemporary(Result.takeAs<Expr>()); 2897 } 2898 2899 case CastExpr::CK_UserDefinedConversion: { 2900 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!"); 2901 2902 // Create an implicit call expr that calls it. 2903 CXXMemberCallExpr *CE = BuildCXXMemberCallExpr(From, Method); 2904 return MaybeBindToTemporary(CE); 2905 } 2906 } 2907} 2908 2909Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) { 2910 Expr *FullExpr = Arg.takeAs<Expr>(); 2911 if (FullExpr) 2912 FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr); 2913 2914 return Owned(FullExpr); 2915} 2916