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