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