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