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