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