SemaExprCXX.cpp revision 323ed74658bc8375278eabf074b4777458376540
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 QualType T = ConditionVar->getType(); 1442 1443 // C++ [stmt.select]p2: 1444 // The declarator shall not specify a function or an array. 1445 if (T->isFunctionType()) 1446 return ExprError(Diag(ConditionVar->getLocation(), 1447 diag::err_invalid_use_of_function_type) 1448 << ConditionVar->getSourceRange()); 1449 else if (T->isArrayType()) 1450 return ExprError(Diag(ConditionVar->getLocation(), 1451 diag::err_invalid_use_of_array_type) 1452 << ConditionVar->getSourceRange()); 1453 1454 return Owned(DeclRefExpr::Create(Context, 0, SourceRange(), ConditionVar, 1455 ConditionVar->getLocation(), 1456 ConditionVar->getType().getNonReferenceType())); 1457} 1458 1459/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid. 1460bool Sema::CheckCXXBooleanCondition(Expr *&CondExpr) { 1461 // C++ 6.4p4: 1462 // The value of a condition that is an initialized declaration in a statement 1463 // other than a switch statement is the value of the declared variable 1464 // implicitly converted to type bool. If that conversion is ill-formed, the 1465 // program is ill-formed. 1466 // The value of a condition that is an expression is the value of the 1467 // expression, implicitly converted to bool. 1468 // 1469 return PerformContextuallyConvertToBool(CondExpr); 1470} 1471 1472/// Helper function to determine whether this is the (deprecated) C++ 1473/// conversion from a string literal to a pointer to non-const char or 1474/// non-const wchar_t (for narrow and wide string literals, 1475/// respectively). 1476bool 1477Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) { 1478 // Look inside the implicit cast, if it exists. 1479 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From)) 1480 From = Cast->getSubExpr(); 1481 1482 // A string literal (2.13.4) that is not a wide string literal can 1483 // be converted to an rvalue of type "pointer to char"; a wide 1484 // string literal can be converted to an rvalue of type "pointer 1485 // to wchar_t" (C++ 4.2p2). 1486 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From)) 1487 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) 1488 if (const BuiltinType *ToPointeeType 1489 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) { 1490 // This conversion is considered only when there is an 1491 // explicit appropriate pointer target type (C++ 4.2p2). 1492 if (!ToPtrType->getPointeeType().hasQualifiers() && 1493 ((StrLit->isWide() && ToPointeeType->isWideCharType()) || 1494 (!StrLit->isWide() && 1495 (ToPointeeType->getKind() == BuiltinType::Char_U || 1496 ToPointeeType->getKind() == BuiltinType::Char_S)))) 1497 return true; 1498 } 1499 1500 return false; 1501} 1502 1503static Sema::OwningExprResult BuildCXXCastArgument(Sema &S, 1504 SourceLocation CastLoc, 1505 QualType Ty, 1506 CastExpr::CastKind Kind, 1507 CXXMethodDecl *Method, 1508 Sema::ExprArg Arg) { 1509 Expr *From = Arg.takeAs<Expr>(); 1510 1511 switch (Kind) { 1512 default: assert(0 && "Unhandled cast kind!"); 1513 case CastExpr::CK_ConstructorConversion: { 1514 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(S); 1515 1516 if (S.CompleteConstructorCall(cast<CXXConstructorDecl>(Method), 1517 Sema::MultiExprArg(S, (void **)&From, 1), 1518 CastLoc, ConstructorArgs)) 1519 return S.ExprError(); 1520 1521 Sema::OwningExprResult Result = 1522 S.BuildCXXConstructExpr(CastLoc, Ty, cast<CXXConstructorDecl>(Method), 1523 move_arg(ConstructorArgs)); 1524 if (Result.isInvalid()) 1525 return S.ExprError(); 1526 1527 return S.MaybeBindToTemporary(Result.takeAs<Expr>()); 1528 } 1529 1530 case CastExpr::CK_UserDefinedConversion: { 1531 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!"); 1532 1533 // Create an implicit call expr that calls it. 1534 // FIXME: pass the FoundDecl for the user-defined conversion here 1535 CXXMemberCallExpr *CE = S.BuildCXXMemberCallExpr(From, Method, Method); 1536 return S.MaybeBindToTemporary(CE); 1537 } 1538 } 1539} 1540 1541/// PerformImplicitConversion - Perform an implicit conversion of the 1542/// expression From to the type ToType using the pre-computed implicit 1543/// conversion sequence ICS. Returns true if there was an error, false 1544/// otherwise. The expression From is replaced with the converted 1545/// expression. Action is the kind of conversion we're performing, 1546/// used in the error message. 1547bool 1548Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1549 const ImplicitConversionSequence &ICS, 1550 AssignmentAction Action, bool IgnoreBaseAccess) { 1551 switch (ICS.getKind()) { 1552 case ImplicitConversionSequence::StandardConversion: 1553 if (PerformImplicitConversion(From, ToType, ICS.Standard, Action, 1554 IgnoreBaseAccess)) 1555 return true; 1556 break; 1557 1558 case ImplicitConversionSequence::UserDefinedConversion: { 1559 1560 FunctionDecl *FD = ICS.UserDefined.ConversionFunction; 1561 CastExpr::CastKind CastKind = CastExpr::CK_Unknown; 1562 QualType BeforeToType; 1563 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) { 1564 CastKind = CastExpr::CK_UserDefinedConversion; 1565 1566 // If the user-defined conversion is specified by a conversion function, 1567 // the initial standard conversion sequence converts the source type to 1568 // the implicit object parameter of the conversion function. 1569 BeforeToType = Context.getTagDeclType(Conv->getParent()); 1570 } else if (const CXXConstructorDecl *Ctor = 1571 dyn_cast<CXXConstructorDecl>(FD)) { 1572 CastKind = CastExpr::CK_ConstructorConversion; 1573 // Do no conversion if dealing with ... for the first conversion. 1574 if (!ICS.UserDefined.EllipsisConversion) { 1575 // If the user-defined conversion is specified by a constructor, the 1576 // initial standard conversion sequence converts the source type to the 1577 // type required by the argument of the constructor 1578 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType(); 1579 } 1580 } 1581 else 1582 assert(0 && "Unknown conversion function kind!"); 1583 // Whatch out for elipsis conversion. 1584 if (!ICS.UserDefined.EllipsisConversion) { 1585 if (PerformImplicitConversion(From, BeforeToType, 1586 ICS.UserDefined.Before, AA_Converting, 1587 IgnoreBaseAccess)) 1588 return true; 1589 } 1590 1591 OwningExprResult CastArg 1592 = BuildCXXCastArgument(*this, 1593 From->getLocStart(), 1594 ToType.getNonReferenceType(), 1595 CastKind, cast<CXXMethodDecl>(FD), 1596 Owned(From)); 1597 1598 if (CastArg.isInvalid()) 1599 return true; 1600 1601 From = CastArg.takeAs<Expr>(); 1602 1603 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After, 1604 AA_Converting, IgnoreBaseAccess); 1605 } 1606 1607 case ImplicitConversionSequence::AmbiguousConversion: 1608 DiagnoseAmbiguousConversion(ICS, From->getExprLoc(), 1609 PDiag(diag::err_typecheck_ambiguous_condition) 1610 << From->getSourceRange()); 1611 return true; 1612 1613 case ImplicitConversionSequence::EllipsisConversion: 1614 assert(false && "Cannot perform an ellipsis conversion"); 1615 return false; 1616 1617 case ImplicitConversionSequence::BadConversion: 1618 return true; 1619 } 1620 1621 // Everything went well. 1622 return false; 1623} 1624 1625/// PerformImplicitConversion - Perform an implicit conversion of the 1626/// expression From to the type ToType by following the standard 1627/// conversion sequence SCS. Returns true if there was an error, false 1628/// otherwise. The expression From is replaced with the converted 1629/// expression. Flavor is the context in which we're performing this 1630/// conversion, for use in error messages. 1631bool 1632Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1633 const StandardConversionSequence& SCS, 1634 AssignmentAction Action, bool IgnoreBaseAccess) { 1635 // Overall FIXME: we are recomputing too many types here and doing far too 1636 // much extra work. What this means is that we need to keep track of more 1637 // information that is computed when we try the implicit conversion initially, 1638 // so that we don't need to recompute anything here. 1639 QualType FromType = From->getType(); 1640 1641 if (SCS.CopyConstructor) { 1642 // FIXME: When can ToType be a reference type? 1643 assert(!ToType->isReferenceType()); 1644 if (SCS.Second == ICK_Derived_To_Base) { 1645 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this); 1646 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor), 1647 MultiExprArg(*this, (void **)&From, 1), 1648 /*FIXME:ConstructLoc*/SourceLocation(), 1649 ConstructorArgs)) 1650 return true; 1651 OwningExprResult FromResult = 1652 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 1653 ToType, SCS.CopyConstructor, 1654 move_arg(ConstructorArgs)); 1655 if (FromResult.isInvalid()) 1656 return true; 1657 From = FromResult.takeAs<Expr>(); 1658 return false; 1659 } 1660 OwningExprResult FromResult = 1661 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 1662 ToType, SCS.CopyConstructor, 1663 MultiExprArg(*this, (void**)&From, 1)); 1664 1665 if (FromResult.isInvalid()) 1666 return true; 1667 1668 From = FromResult.takeAs<Expr>(); 1669 return false; 1670 } 1671 1672 // Resolve overloaded function references. 1673 if (Context.hasSameType(FromType, Context.OverloadTy)) { 1674 DeclAccessPair Found; 1675 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, 1676 true, Found); 1677 if (!Fn) 1678 return true; 1679 1680 if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin())) 1681 return true; 1682 1683 From = FixOverloadedFunctionReference(From, Found, Fn); 1684 FromType = From->getType(); 1685 } 1686 1687 // Perform the first implicit conversion. 1688 switch (SCS.First) { 1689 case ICK_Identity: 1690 case ICK_Lvalue_To_Rvalue: 1691 // Nothing to do. 1692 break; 1693 1694 case ICK_Array_To_Pointer: 1695 FromType = Context.getArrayDecayedType(FromType); 1696 ImpCastExprToType(From, FromType, CastExpr::CK_ArrayToPointerDecay); 1697 break; 1698 1699 case ICK_Function_To_Pointer: 1700 FromType = Context.getPointerType(FromType); 1701 ImpCastExprToType(From, FromType, CastExpr::CK_FunctionToPointerDecay); 1702 break; 1703 1704 default: 1705 assert(false && "Improper first standard conversion"); 1706 break; 1707 } 1708 1709 // Perform the second implicit conversion 1710 switch (SCS.Second) { 1711 case ICK_Identity: 1712 // If both sides are functions (or pointers/references to them), there could 1713 // be incompatible exception declarations. 1714 if (CheckExceptionSpecCompatibility(From, ToType)) 1715 return true; 1716 // Nothing else to do. 1717 break; 1718 1719 case ICK_NoReturn_Adjustment: 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 1725 ImpCastExprToType(From, Context.getNoReturnType(From->getType(), false), 1726 CastExpr::CK_NoOp); 1727 break; 1728 1729 case ICK_Integral_Promotion: 1730 case ICK_Integral_Conversion: 1731 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralCast); 1732 break; 1733 1734 case ICK_Floating_Promotion: 1735 case ICK_Floating_Conversion: 1736 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingCast); 1737 break; 1738 1739 case ICK_Complex_Promotion: 1740 case ICK_Complex_Conversion: 1741 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown); 1742 break; 1743 1744 case ICK_Floating_Integral: 1745 if (ToType->isFloatingType()) 1746 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralToFloating); 1747 else 1748 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingToIntegral); 1749 break; 1750 1751 case ICK_Complex_Real: 1752 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown); 1753 break; 1754 1755 case ICK_Compatible_Conversion: 1756 ImpCastExprToType(From, ToType, CastExpr::CK_NoOp); 1757 break; 1758 1759 case ICK_Pointer_Conversion: { 1760 if (SCS.IncompatibleObjC) { 1761 // Diagnose incompatible Objective-C conversions 1762 Diag(From->getSourceRange().getBegin(), 1763 diag::ext_typecheck_convert_incompatible_pointer) 1764 << From->getType() << ToType << Action 1765 << From->getSourceRange(); 1766 } 1767 1768 1769 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1770 CXXBaseSpecifierArray BasePath; 1771 if (CheckPointerConversion(From, ToType, Kind, BasePath, IgnoreBaseAccess)) 1772 return true; 1773 ImpCastExprToType(From, ToType, Kind, /*isLvalue=*/false, BasePath); 1774 break; 1775 } 1776 1777 case ICK_Pointer_Member: { 1778 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1779 CXXBaseSpecifierArray BasePath; 1780 if (CheckMemberPointerConversion(From, ToType, Kind, BasePath, 1781 IgnoreBaseAccess)) 1782 return true; 1783 if (CheckExceptionSpecCompatibility(From, ToType)) 1784 return true; 1785 ImpCastExprToType(From, ToType, Kind, /*isLvalue=*/false, BasePath); 1786 break; 1787 } 1788 case ICK_Boolean_Conversion: { 1789 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1790 if (FromType->isMemberPointerType()) 1791 Kind = CastExpr::CK_MemberPointerToBoolean; 1792 1793 ImpCastExprToType(From, Context.BoolTy, Kind); 1794 break; 1795 } 1796 1797 case ICK_Derived_To_Base: 1798 if (CheckDerivedToBaseConversion(From->getType(), 1799 ToType.getNonReferenceType(), 1800 From->getLocStart(), 1801 From->getSourceRange(), 0, 1802 IgnoreBaseAccess)) 1803 return true; 1804 ImpCastExprToType(From, ToType.getNonReferenceType(), 1805 CastExpr::CK_DerivedToBase); 1806 break; 1807 1808 default: 1809 assert(false && "Improper second standard conversion"); 1810 break; 1811 } 1812 1813 switch (SCS.Third) { 1814 case ICK_Identity: 1815 // Nothing to do. 1816 break; 1817 1818 case ICK_Qualification: 1819 // FIXME: Not sure about lvalue vs rvalue here in the presence of rvalue 1820 // references. 1821 ImpCastExprToType(From, ToType.getNonReferenceType(), 1822 CastExpr::CK_NoOp, ToType->isLValueReferenceType()); 1823 1824 if (SCS.DeprecatedStringLiteralToCharPtr) 1825 Diag(From->getLocStart(), diag::warn_deprecated_string_literal_conversion) 1826 << ToType.getNonReferenceType(); 1827 1828 break; 1829 1830 default: 1831 assert(false && "Improper second standard conversion"); 1832 break; 1833 } 1834 1835 return false; 1836} 1837 1838Sema::OwningExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait OTT, 1839 SourceLocation KWLoc, 1840 SourceLocation LParen, 1841 TypeTy *Ty, 1842 SourceLocation RParen) { 1843 QualType T = GetTypeFromParser(Ty); 1844 1845 // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html 1846 // all traits except __is_class, __is_enum and __is_union require a the type 1847 // to be complete. 1848 if (OTT != UTT_IsClass && OTT != UTT_IsEnum && OTT != UTT_IsUnion) { 1849 if (RequireCompleteType(KWLoc, T, 1850 diag::err_incomplete_type_used_in_type_trait_expr)) 1851 return ExprError(); 1852 } 1853 1854 // There is no point in eagerly computing the value. The traits are designed 1855 // to be used from type trait templates, so Ty will be a template parameter 1856 // 99% of the time. 1857 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, OTT, T, 1858 RParen, Context.BoolTy)); 1859} 1860 1861QualType Sema::CheckPointerToMemberOperands( 1862 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isIndirect) { 1863 const char *OpSpelling = isIndirect ? "->*" : ".*"; 1864 // C++ 5.5p2 1865 // The binary operator .* [p3: ->*] binds its second operand, which shall 1866 // be of type "pointer to member of T" (where T is a completely-defined 1867 // class type) [...] 1868 QualType RType = rex->getType(); 1869 const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>(); 1870 if (!MemPtr) { 1871 Diag(Loc, diag::err_bad_memptr_rhs) 1872 << OpSpelling << RType << rex->getSourceRange(); 1873 return QualType(); 1874 } 1875 1876 QualType Class(MemPtr->getClass(), 0); 1877 1878 if (RequireCompleteType(Loc, Class, diag::err_memptr_rhs_to_incomplete)) 1879 return QualType(); 1880 1881 // C++ 5.5p2 1882 // [...] to its first operand, which shall be of class T or of a class of 1883 // which T is an unambiguous and accessible base class. [p3: a pointer to 1884 // such a class] 1885 QualType LType = lex->getType(); 1886 if (isIndirect) { 1887 if (const PointerType *Ptr = LType->getAs<PointerType>()) 1888 LType = Ptr->getPointeeType().getNonReferenceType(); 1889 else { 1890 Diag(Loc, diag::err_bad_memptr_lhs) 1891 << OpSpelling << 1 << LType 1892 << FixItHint::CreateReplacement(SourceRange(Loc), ".*"); 1893 return QualType(); 1894 } 1895 } 1896 1897 if (!Context.hasSameUnqualifiedType(Class, LType)) { 1898 // If we want to check the hierarchy, we need a complete type. 1899 if (RequireCompleteType(Loc, LType, PDiag(diag::err_bad_memptr_lhs) 1900 << OpSpelling << (int)isIndirect)) { 1901 return QualType(); 1902 } 1903 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 1904 /*DetectVirtual=*/false); 1905 // FIXME: Would it be useful to print full ambiguity paths, or is that 1906 // overkill? 1907 if (!IsDerivedFrom(LType, Class, Paths) || 1908 Paths.isAmbiguous(Context.getCanonicalType(Class))) { 1909 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling 1910 << (int)isIndirect << lex->getType(); 1911 return QualType(); 1912 } 1913 // Cast LHS to type of use. 1914 QualType UseType = isIndirect ? Context.getPointerType(Class) : Class; 1915 bool isLValue = !isIndirect && lex->isLvalue(Context) == Expr::LV_Valid; 1916 1917 CXXBaseSpecifierArray BasePath; 1918 BuildBasePathArray(Paths, BasePath); 1919 ImpCastExprToType(lex, UseType, CastExpr::CK_DerivedToBase, isLValue, 1920 BasePath); 1921 } 1922 1923 if (isa<CXXZeroInitValueExpr>(rex->IgnoreParens())) { 1924 // Diagnose use of pointer-to-member type which when used as 1925 // the functional cast in a pointer-to-member expression. 1926 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect; 1927 return QualType(); 1928 } 1929 // C++ 5.5p2 1930 // The result is an object or a function of the type specified by the 1931 // second operand. 1932 // The cv qualifiers are the union of those in the pointer and the left side, 1933 // in accordance with 5.5p5 and 5.2.5. 1934 // FIXME: This returns a dereferenced member function pointer as a normal 1935 // function type. However, the only operation valid on such functions is 1936 // calling them. There's also a GCC extension to get a function pointer to the 1937 // thing, which is another complication, because this type - unlike the type 1938 // that is the result of this expression - takes the class as the first 1939 // argument. 1940 // We probably need a "MemberFunctionClosureType" or something like that. 1941 QualType Result = MemPtr->getPointeeType(); 1942 Result = Context.getCVRQualifiedType(Result, LType.getCVRQualifiers()); 1943 return Result; 1944} 1945 1946/// \brief Try to convert a type to another according to C++0x 5.16p3. 1947/// 1948/// This is part of the parameter validation for the ? operator. If either 1949/// value operand is a class type, the two operands are attempted to be 1950/// converted to each other. This function does the conversion in one direction. 1951/// It returns true if the program is ill-formed and has already been diagnosed 1952/// as such. 1953static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, 1954 SourceLocation QuestionLoc, 1955 bool &HaveConversion, 1956 QualType &ToType) { 1957 HaveConversion = false; 1958 ToType = To->getType(); 1959 1960 InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(), 1961 SourceLocation()); 1962 // C++0x 5.16p3 1963 // The process for determining whether an operand expression E1 of type T1 1964 // can be converted to match an operand expression E2 of type T2 is defined 1965 // as follows: 1966 // -- If E2 is an lvalue: 1967 bool ToIsLvalue = (To->isLvalue(Self.Context) == Expr::LV_Valid); 1968 if (ToIsLvalue) { 1969 // E1 can be converted to match E2 if E1 can be implicitly converted to 1970 // type "lvalue reference to T2", subject to the constraint that in the 1971 // conversion the reference must bind directly to E1. 1972 QualType T = Self.Context.getLValueReferenceType(ToType); 1973 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 1974 1975 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 1976 if (InitSeq.isDirectReferenceBinding()) { 1977 ToType = T; 1978 HaveConversion = true; 1979 return false; 1980 } 1981 1982 if (InitSeq.isAmbiguous()) 1983 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 1984 } 1985 1986 // -- If E2 is an rvalue, or if the conversion above cannot be done: 1987 // -- if E1 and E2 have class type, and the underlying class types are 1988 // the same or one is a base class of the other: 1989 QualType FTy = From->getType(); 1990 QualType TTy = To->getType(); 1991 const RecordType *FRec = FTy->getAs<RecordType>(); 1992 const RecordType *TRec = TTy->getAs<RecordType>(); 1993 bool FDerivedFromT = FRec && TRec && FRec != TRec && 1994 Self.IsDerivedFrom(FTy, TTy); 1995 if (FRec && TRec && 1996 (FRec == TRec || FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) { 1997 // E1 can be converted to match E2 if the class of T2 is the 1998 // same type as, or a base class of, the class of T1, and 1999 // [cv2 > cv1]. 2000 if (FRec == TRec || FDerivedFromT) { 2001 if (TTy.isAtLeastAsQualifiedAs(FTy)) { 2002 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 2003 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 2004 if (InitSeq.getKind() != InitializationSequence::FailedSequence) { 2005 HaveConversion = true; 2006 return false; 2007 } 2008 2009 if (InitSeq.isAmbiguous()) 2010 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 2011 } 2012 } 2013 2014 return false; 2015 } 2016 2017 // -- Otherwise: E1 can be converted to match E2 if E1 can be 2018 // implicitly converted to the type that expression E2 would have 2019 // if E2 were converted to an rvalue (or the type it has, if E2 is 2020 // an rvalue). 2021 // 2022 // This actually refers very narrowly to the lvalue-to-rvalue conversion, not 2023 // to the array-to-pointer or function-to-pointer conversions. 2024 if (!TTy->getAs<TagType>()) 2025 TTy = TTy.getUnqualifiedType(); 2026 2027 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 2028 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 2029 HaveConversion = InitSeq.getKind() != InitializationSequence::FailedSequence; 2030 ToType = TTy; 2031 if (InitSeq.isAmbiguous()) 2032 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 2033 2034 return false; 2035} 2036 2037/// \brief Try to find a common type for two according to C++0x 5.16p5. 2038/// 2039/// This is part of the parameter validation for the ? operator. If either 2040/// value operand is a class type, overload resolution is used to find a 2041/// conversion to a common type. 2042static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS, 2043 SourceLocation Loc) { 2044 Expr *Args[2] = { LHS, RHS }; 2045 OverloadCandidateSet CandidateSet(Loc); 2046 Self.AddBuiltinOperatorCandidates(OO_Conditional, Loc, Args, 2, CandidateSet); 2047 2048 OverloadCandidateSet::iterator Best; 2049 switch (Self.BestViableFunction(CandidateSet, Loc, Best)) { 2050 case OR_Success: 2051 // We found a match. Perform the conversions on the arguments and move on. 2052 if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0], 2053 Best->Conversions[0], Sema::AA_Converting) || 2054 Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1], 2055 Best->Conversions[1], Sema::AA_Converting)) 2056 break; 2057 return false; 2058 2059 case OR_No_Viable_Function: 2060 Self.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 2061 << LHS->getType() << RHS->getType() 2062 << LHS->getSourceRange() << RHS->getSourceRange(); 2063 return true; 2064 2065 case OR_Ambiguous: 2066 Self.Diag(Loc, diag::err_conditional_ambiguous_ovl) 2067 << LHS->getType() << RHS->getType() 2068 << LHS->getSourceRange() << RHS->getSourceRange(); 2069 // FIXME: Print the possible common types by printing the return types of 2070 // the viable candidates. 2071 break; 2072 2073 case OR_Deleted: 2074 assert(false && "Conditional operator has only built-in overloads"); 2075 break; 2076 } 2077 return true; 2078} 2079 2080/// \brief Perform an "extended" implicit conversion as returned by 2081/// TryClassUnification. 2082static bool ConvertForConditional(Sema &Self, Expr *&E, QualType T) { 2083 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 2084 InitializationKind Kind = InitializationKind::CreateCopy(E->getLocStart(), 2085 SourceLocation()); 2086 InitializationSequence InitSeq(Self, Entity, Kind, &E, 1); 2087 Sema::OwningExprResult Result = InitSeq.Perform(Self, Entity, Kind, 2088 Sema::MultiExprArg(Self, (void **)&E, 1)); 2089 if (Result.isInvalid()) 2090 return true; 2091 2092 E = Result.takeAs<Expr>(); 2093 return false; 2094} 2095 2096/// \brief Check the operands of ?: under C++ semantics. 2097/// 2098/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y 2099/// extension. In this case, LHS == Cond. (But they're not aliases.) 2100QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, 2101 SourceLocation QuestionLoc) { 2102 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++ 2103 // interface pointers. 2104 2105 // C++0x 5.16p1 2106 // The first expression is contextually converted to bool. 2107 if (!Cond->isTypeDependent()) { 2108 if (CheckCXXBooleanCondition(Cond)) 2109 return QualType(); 2110 } 2111 2112 // Either of the arguments dependent? 2113 if (LHS->isTypeDependent() || RHS->isTypeDependent()) 2114 return Context.DependentTy; 2115 2116 // C++0x 5.16p2 2117 // If either the second or the third operand has type (cv) void, ... 2118 QualType LTy = LHS->getType(); 2119 QualType RTy = RHS->getType(); 2120 bool LVoid = LTy->isVoidType(); 2121 bool RVoid = RTy->isVoidType(); 2122 if (LVoid || RVoid) { 2123 // ... then the [l2r] conversions are performed on the second and third 2124 // operands ... 2125 DefaultFunctionArrayLvalueConversion(LHS); 2126 DefaultFunctionArrayLvalueConversion(RHS); 2127 LTy = LHS->getType(); 2128 RTy = RHS->getType(); 2129 2130 // ... and one of the following shall hold: 2131 // -- The second or the third operand (but not both) is a throw- 2132 // expression; the result is of the type of the other and is an rvalue. 2133 bool LThrow = isa<CXXThrowExpr>(LHS); 2134 bool RThrow = isa<CXXThrowExpr>(RHS); 2135 if (LThrow && !RThrow) 2136 return RTy; 2137 if (RThrow && !LThrow) 2138 return LTy; 2139 2140 // -- Both the second and third operands have type void; the result is of 2141 // type void and is an rvalue. 2142 if (LVoid && RVoid) 2143 return Context.VoidTy; 2144 2145 // Neither holds, error. 2146 Diag(QuestionLoc, diag::err_conditional_void_nonvoid) 2147 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1) 2148 << LHS->getSourceRange() << RHS->getSourceRange(); 2149 return QualType(); 2150 } 2151 2152 // Neither is void. 2153 2154 // C++0x 5.16p3 2155 // Otherwise, if the second and third operand have different types, and 2156 // either has (cv) class type, and attempt is made to convert each of those 2157 // operands to the other. 2158 if (!Context.hasSameType(LTy, RTy) && 2159 (LTy->isRecordType() || RTy->isRecordType())) { 2160 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft; 2161 // These return true if a single direction is already ambiguous. 2162 QualType L2RType, R2LType; 2163 bool HaveL2R, HaveR2L; 2164 if (TryClassUnification(*this, LHS, RHS, QuestionLoc, HaveL2R, L2RType)) 2165 return QualType(); 2166 if (TryClassUnification(*this, RHS, LHS, QuestionLoc, HaveR2L, R2LType)) 2167 return QualType(); 2168 2169 // If both can be converted, [...] the program is ill-formed. 2170 if (HaveL2R && HaveR2L) { 2171 Diag(QuestionLoc, diag::err_conditional_ambiguous) 2172 << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange(); 2173 return QualType(); 2174 } 2175 2176 // If exactly one conversion is possible, that conversion is applied to 2177 // the chosen operand and the converted operands are used in place of the 2178 // original operands for the remainder of this section. 2179 if (HaveL2R) { 2180 if (ConvertForConditional(*this, LHS, L2RType)) 2181 return QualType(); 2182 LTy = LHS->getType(); 2183 } else if (HaveR2L) { 2184 if (ConvertForConditional(*this, RHS, R2LType)) 2185 return QualType(); 2186 RTy = RHS->getType(); 2187 } 2188 } 2189 2190 // C++0x 5.16p4 2191 // If the second and third operands are lvalues and have the same type, 2192 // the result is of that type [...] 2193 bool Same = Context.hasSameType(LTy, RTy); 2194 if (Same && LHS->isLvalue(Context) == Expr::LV_Valid && 2195 RHS->isLvalue(Context) == Expr::LV_Valid) 2196 return LTy; 2197 2198 // C++0x 5.16p5 2199 // Otherwise, the result is an rvalue. If the second and third operands 2200 // do not have the same type, and either has (cv) class type, ... 2201 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) { 2202 // ... overload resolution is used to determine the conversions (if any) 2203 // to be applied to the operands. If the overload resolution fails, the 2204 // program is ill-formed. 2205 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc)) 2206 return QualType(); 2207 } 2208 2209 // C++0x 5.16p6 2210 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard 2211 // conversions are performed on the second and third operands. 2212 DefaultFunctionArrayLvalueConversion(LHS); 2213 DefaultFunctionArrayLvalueConversion(RHS); 2214 LTy = LHS->getType(); 2215 RTy = RHS->getType(); 2216 2217 // After those conversions, one of the following shall hold: 2218 // -- The second and third operands have the same type; the result 2219 // is of that type. 2220 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) 2221 return LTy; 2222 2223 // -- The second and third operands have arithmetic or enumeration type; 2224 // the usual arithmetic conversions are performed to bring them to a 2225 // common type, and the result is of that type. 2226 if (LTy->isArithmeticType() && RTy->isArithmeticType()) { 2227 UsualArithmeticConversions(LHS, RHS); 2228 return LHS->getType(); 2229 } 2230 2231 // -- The second and third operands have pointer type, or one has pointer 2232 // type and the other is a null pointer constant; pointer conversions 2233 // and qualification conversions are performed to bring them to their 2234 // composite pointer type. The result is of the composite pointer type. 2235 // -- The second and third operands have pointer to member type, or one has 2236 // pointer to member type and the other is a null pointer constant; 2237 // pointer to member conversions and qualification conversions are 2238 // performed to bring them to a common type, whose cv-qualification 2239 // shall match the cv-qualification of either the second or the third 2240 // operand. The result is of the common type. 2241 bool NonStandardCompositeType = false; 2242 QualType Composite = FindCompositePointerType(QuestionLoc, LHS, RHS, 2243 isSFINAEContext()? 0 : &NonStandardCompositeType); 2244 if (!Composite.isNull()) { 2245 if (NonStandardCompositeType) 2246 Diag(QuestionLoc, 2247 diag::ext_typecheck_cond_incompatible_operands_nonstandard) 2248 << LTy << RTy << Composite 2249 << LHS->getSourceRange() << RHS->getSourceRange(); 2250 2251 return Composite; 2252 } 2253 2254 // Similarly, attempt to find composite type of two objective-c pointers. 2255 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc); 2256 if (!Composite.isNull()) 2257 return Composite; 2258 2259 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 2260 << LHS->getType() << RHS->getType() 2261 << LHS->getSourceRange() << RHS->getSourceRange(); 2262 return QualType(); 2263} 2264 2265/// \brief Find a merged pointer type and convert the two expressions to it. 2266/// 2267/// This finds the composite pointer type (or member pointer type) for @p E1 2268/// and @p E2 according to C++0x 5.9p2. It converts both expressions to this 2269/// type and returns it. 2270/// It does not emit diagnostics. 2271/// 2272/// \param Loc The location of the operator requiring these two expressions to 2273/// be converted to the composite pointer type. 2274/// 2275/// If \p NonStandardCompositeType is non-NULL, then we are permitted to find 2276/// a non-standard (but still sane) composite type to which both expressions 2277/// can be converted. When such a type is chosen, \c *NonStandardCompositeType 2278/// will be set true. 2279QualType Sema::FindCompositePointerType(SourceLocation Loc, 2280 Expr *&E1, Expr *&E2, 2281 bool *NonStandardCompositeType) { 2282 if (NonStandardCompositeType) 2283 *NonStandardCompositeType = false; 2284 2285 assert(getLangOptions().CPlusPlus && "This function assumes C++"); 2286 QualType T1 = E1->getType(), T2 = E2->getType(); 2287 2288 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() && 2289 !T2->isAnyPointerType() && !T2->isMemberPointerType()) 2290 return QualType(); 2291 2292 // C++0x 5.9p2 2293 // Pointer conversions and qualification conversions are performed on 2294 // pointer operands to bring them to their composite pointer type. If 2295 // one operand is a null pointer constant, the composite pointer type is 2296 // the type of the other operand. 2297 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 2298 if (T2->isMemberPointerType()) 2299 ImpCastExprToType(E1, T2, CastExpr::CK_NullToMemberPointer); 2300 else 2301 ImpCastExprToType(E1, T2, CastExpr::CK_IntegralToPointer); 2302 return T2; 2303 } 2304 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 2305 if (T1->isMemberPointerType()) 2306 ImpCastExprToType(E2, T1, CastExpr::CK_NullToMemberPointer); 2307 else 2308 ImpCastExprToType(E2, T1, CastExpr::CK_IntegralToPointer); 2309 return T1; 2310 } 2311 2312 // Now both have to be pointers or member pointers. 2313 if ((!T1->isPointerType() && !T1->isMemberPointerType()) || 2314 (!T2->isPointerType() && !T2->isMemberPointerType())) 2315 return QualType(); 2316 2317 // Otherwise, of one of the operands has type "pointer to cv1 void," then 2318 // the other has type "pointer to cv2 T" and the composite pointer type is 2319 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2. 2320 // Otherwise, the composite pointer type is a pointer type similar to the 2321 // type of one of the operands, with a cv-qualification signature that is 2322 // the union of the cv-qualification signatures of the operand types. 2323 // In practice, the first part here is redundant; it's subsumed by the second. 2324 // What we do here is, we build the two possible composite types, and try the 2325 // conversions in both directions. If only one works, or if the two composite 2326 // types are the same, we have succeeded. 2327 // FIXME: extended qualifiers? 2328 typedef llvm::SmallVector<unsigned, 4> QualifierVector; 2329 QualifierVector QualifierUnion; 2330 typedef llvm::SmallVector<std::pair<const Type *, const Type *>, 4> 2331 ContainingClassVector; 2332 ContainingClassVector MemberOfClass; 2333 QualType Composite1 = Context.getCanonicalType(T1), 2334 Composite2 = Context.getCanonicalType(T2); 2335 unsigned NeedConstBefore = 0; 2336 do { 2337 const PointerType *Ptr1, *Ptr2; 2338 if ((Ptr1 = Composite1->getAs<PointerType>()) && 2339 (Ptr2 = Composite2->getAs<PointerType>())) { 2340 Composite1 = Ptr1->getPointeeType(); 2341 Composite2 = Ptr2->getPointeeType(); 2342 2343 // If we're allowed to create a non-standard composite type, keep track 2344 // of where we need to fill in additional 'const' qualifiers. 2345 if (NonStandardCompositeType && 2346 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 2347 NeedConstBefore = QualifierUnion.size(); 2348 2349 QualifierUnion.push_back( 2350 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 2351 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0)); 2352 continue; 2353 } 2354 2355 const MemberPointerType *MemPtr1, *MemPtr2; 2356 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) && 2357 (MemPtr2 = Composite2->getAs<MemberPointerType>())) { 2358 Composite1 = MemPtr1->getPointeeType(); 2359 Composite2 = MemPtr2->getPointeeType(); 2360 2361 // If we're allowed to create a non-standard composite type, keep track 2362 // of where we need to fill in additional 'const' qualifiers. 2363 if (NonStandardCompositeType && 2364 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 2365 NeedConstBefore = QualifierUnion.size(); 2366 2367 QualifierUnion.push_back( 2368 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 2369 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(), 2370 MemPtr2->getClass())); 2371 continue; 2372 } 2373 2374 // FIXME: block pointer types? 2375 2376 // Cannot unwrap any more types. 2377 break; 2378 } while (true); 2379 2380 if (NeedConstBefore && NonStandardCompositeType) { 2381 // Extension: Add 'const' to qualifiers that come before the first qualifier 2382 // mismatch, so that our (non-standard!) composite type meets the 2383 // requirements of C++ [conv.qual]p4 bullet 3. 2384 for (unsigned I = 0; I != NeedConstBefore; ++I) { 2385 if ((QualifierUnion[I] & Qualifiers::Const) == 0) { 2386 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const; 2387 *NonStandardCompositeType = true; 2388 } 2389 } 2390 } 2391 2392 // Rewrap the composites as pointers or member pointers with the union CVRs. 2393 ContainingClassVector::reverse_iterator MOC 2394 = MemberOfClass.rbegin(); 2395 for (QualifierVector::reverse_iterator 2396 I = QualifierUnion.rbegin(), 2397 E = QualifierUnion.rend(); 2398 I != E; (void)++I, ++MOC) { 2399 Qualifiers Quals = Qualifiers::fromCVRMask(*I); 2400 if (MOC->first && MOC->second) { 2401 // Rebuild member pointer type 2402 Composite1 = Context.getMemberPointerType( 2403 Context.getQualifiedType(Composite1, Quals), 2404 MOC->first); 2405 Composite2 = Context.getMemberPointerType( 2406 Context.getQualifiedType(Composite2, Quals), 2407 MOC->second); 2408 } else { 2409 // Rebuild pointer type 2410 Composite1 2411 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals)); 2412 Composite2 2413 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals)); 2414 } 2415 } 2416 2417 // Try to convert to the first composite pointer type. 2418 InitializedEntity Entity1 2419 = InitializedEntity::InitializeTemporary(Composite1); 2420 InitializationKind Kind 2421 = InitializationKind::CreateCopy(Loc, SourceLocation()); 2422 InitializationSequence E1ToC1(*this, Entity1, Kind, &E1, 1); 2423 InitializationSequence E2ToC1(*this, Entity1, Kind, &E2, 1); 2424 2425 if (E1ToC1 && E2ToC1) { 2426 // Conversion to Composite1 is viable. 2427 if (!Context.hasSameType(Composite1, Composite2)) { 2428 // Composite2 is a different type from Composite1. Check whether 2429 // Composite2 is also viable. 2430 InitializedEntity Entity2 2431 = InitializedEntity::InitializeTemporary(Composite2); 2432 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1); 2433 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1); 2434 if (E1ToC2 && E2ToC2) { 2435 // Both Composite1 and Composite2 are viable and are different; 2436 // this is an ambiguity. 2437 return QualType(); 2438 } 2439 } 2440 2441 // Convert E1 to Composite1 2442 OwningExprResult E1Result 2443 = E1ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,(void**)&E1,1)); 2444 if (E1Result.isInvalid()) 2445 return QualType(); 2446 E1 = E1Result.takeAs<Expr>(); 2447 2448 // Convert E2 to Composite1 2449 OwningExprResult E2Result 2450 = E2ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,(void**)&E2,1)); 2451 if (E2Result.isInvalid()) 2452 return QualType(); 2453 E2 = E2Result.takeAs<Expr>(); 2454 2455 return Composite1; 2456 } 2457 2458 // Check whether Composite2 is viable. 2459 InitializedEntity Entity2 2460 = InitializedEntity::InitializeTemporary(Composite2); 2461 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1); 2462 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1); 2463 if (!E1ToC2 || !E2ToC2) 2464 return QualType(); 2465 2466 // Convert E1 to Composite2 2467 OwningExprResult E1Result 2468 = E1ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, (void**)&E1, 1)); 2469 if (E1Result.isInvalid()) 2470 return QualType(); 2471 E1 = E1Result.takeAs<Expr>(); 2472 2473 // Convert E2 to Composite2 2474 OwningExprResult E2Result 2475 = E2ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, (void**)&E2, 1)); 2476 if (E2Result.isInvalid()) 2477 return QualType(); 2478 E2 = E2Result.takeAs<Expr>(); 2479 2480 return Composite2; 2481} 2482 2483Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) { 2484 if (!Context.getLangOptions().CPlusPlus) 2485 return Owned(E); 2486 2487 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?"); 2488 2489 const RecordType *RT = E->getType()->getAs<RecordType>(); 2490 if (!RT) 2491 return Owned(E); 2492 2493 // If this is the result of a call expression, our source might 2494 // actually be a reference, in which case we shouldn't bind. 2495 if (CallExpr *CE = dyn_cast<CallExpr>(E)) { 2496 QualType Ty = CE->getCallee()->getType(); 2497 if (const PointerType *PT = Ty->getAs<PointerType>()) 2498 Ty = PT->getPointeeType(); 2499 else if (const BlockPointerType *BPT = Ty->getAs<BlockPointerType>()) 2500 Ty = BPT->getPointeeType(); 2501 2502 const FunctionType *FTy = Ty->getAs<FunctionType>(); 2503 if (FTy->getResultType()->isReferenceType()) 2504 return Owned(E); 2505 } 2506 2507 // That should be enough to guarantee that this type is complete. 2508 // If it has a trivial destructor, we can avoid the extra copy. 2509 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 2510 if (RD->hasTrivialDestructor()) 2511 return Owned(E); 2512 2513 CXXTemporary *Temp = CXXTemporary::Create(Context, 2514 RD->getDestructor(Context)); 2515 ExprTemporaries.push_back(Temp); 2516 if (CXXDestructorDecl *Destructor = 2517 const_cast<CXXDestructorDecl*>(RD->getDestructor(Context))) { 2518 MarkDeclarationReferenced(E->getExprLoc(), Destructor); 2519 CheckDestructorAccess(E->getExprLoc(), Destructor, 2520 PDiag(diag::err_access_dtor_temp) 2521 << E->getType()); 2522 } 2523 // FIXME: Add the temporary to the temporaries vector. 2524 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E)); 2525} 2526 2527Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr) { 2528 assert(SubExpr && "sub expression can't be null!"); 2529 2530 // Check any implicit conversions within the expression. 2531 CheckImplicitConversions(SubExpr); 2532 2533 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 2534 assert(ExprTemporaries.size() >= FirstTemporary); 2535 if (ExprTemporaries.size() == FirstTemporary) 2536 return SubExpr; 2537 2538 Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr, 2539 &ExprTemporaries[FirstTemporary], 2540 ExprTemporaries.size() - FirstTemporary); 2541 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 2542 ExprTemporaries.end()); 2543 2544 return E; 2545} 2546 2547Sema::OwningExprResult 2548Sema::MaybeCreateCXXExprWithTemporaries(OwningExprResult SubExpr) { 2549 if (SubExpr.isInvalid()) 2550 return ExprError(); 2551 2552 return Owned(MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>())); 2553} 2554 2555FullExpr Sema::CreateFullExpr(Expr *SubExpr) { 2556 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 2557 assert(ExprTemporaries.size() >= FirstTemporary); 2558 2559 unsigned NumTemporaries = ExprTemporaries.size() - FirstTemporary; 2560 CXXTemporary **Temporaries = 2561 NumTemporaries == 0 ? 0 : &ExprTemporaries[FirstTemporary]; 2562 2563 FullExpr E = FullExpr::Create(Context, SubExpr, Temporaries, NumTemporaries); 2564 2565 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 2566 ExprTemporaries.end()); 2567 2568 return E; 2569} 2570 2571Sema::OwningExprResult 2572Sema::ActOnStartCXXMemberReference(Scope *S, ExprArg Base, SourceLocation OpLoc, 2573 tok::TokenKind OpKind, TypeTy *&ObjectType, 2574 bool &MayBePseudoDestructor) { 2575 // Since this might be a postfix expression, get rid of ParenListExprs. 2576 Base = MaybeConvertParenListExprToParenExpr(S, move(Base)); 2577 2578 Expr *BaseExpr = (Expr*)Base.get(); 2579 assert(BaseExpr && "no record expansion"); 2580 2581 QualType BaseType = BaseExpr->getType(); 2582 MayBePseudoDestructor = false; 2583 if (BaseType->isDependentType()) { 2584 // If we have a pointer to a dependent type and are using the -> operator, 2585 // the object type is the type that the pointer points to. We might still 2586 // have enough information about that type to do something useful. 2587 if (OpKind == tok::arrow) 2588 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 2589 BaseType = Ptr->getPointeeType(); 2590 2591 ObjectType = BaseType.getAsOpaquePtr(); 2592 MayBePseudoDestructor = true; 2593 return move(Base); 2594 } 2595 2596 // C++ [over.match.oper]p8: 2597 // [...] When operator->returns, the operator-> is applied to the value 2598 // returned, with the original second operand. 2599 if (OpKind == tok::arrow) { 2600 // The set of types we've considered so far. 2601 llvm::SmallPtrSet<CanQualType,8> CTypes; 2602 llvm::SmallVector<SourceLocation, 8> Locations; 2603 CTypes.insert(Context.getCanonicalType(BaseType)); 2604 2605 while (BaseType->isRecordType()) { 2606 Base = BuildOverloadedArrowExpr(S, move(Base), OpLoc); 2607 BaseExpr = (Expr*)Base.get(); 2608 if (BaseExpr == NULL) 2609 return ExprError(); 2610 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(BaseExpr)) 2611 Locations.push_back(OpCall->getDirectCallee()->getLocation()); 2612 BaseType = BaseExpr->getType(); 2613 CanQualType CBaseType = Context.getCanonicalType(BaseType); 2614 if (!CTypes.insert(CBaseType)) { 2615 Diag(OpLoc, diag::err_operator_arrow_circular); 2616 for (unsigned i = 0; i < Locations.size(); i++) 2617 Diag(Locations[i], diag::note_declared_at); 2618 return ExprError(); 2619 } 2620 } 2621 2622 if (BaseType->isPointerType()) 2623 BaseType = BaseType->getPointeeType(); 2624 } 2625 2626 // We could end up with various non-record types here, such as extended 2627 // vector types or Objective-C interfaces. Just return early and let 2628 // ActOnMemberReferenceExpr do the work. 2629 if (!BaseType->isRecordType()) { 2630 // C++ [basic.lookup.classref]p2: 2631 // [...] If the type of the object expression is of pointer to scalar 2632 // type, the unqualified-id is looked up in the context of the complete 2633 // postfix-expression. 2634 // 2635 // This also indicates that we should be parsing a 2636 // pseudo-destructor-name. 2637 ObjectType = 0; 2638 MayBePseudoDestructor = true; 2639 return move(Base); 2640 } 2641 2642 // The object type must be complete (or dependent). 2643 if (!BaseType->isDependentType() && 2644 RequireCompleteType(OpLoc, BaseType, 2645 PDiag(diag::err_incomplete_member_access))) 2646 return ExprError(); 2647 2648 // C++ [basic.lookup.classref]p2: 2649 // If the id-expression in a class member access (5.2.5) is an 2650 // unqualified-id, and the type of the object expression is of a class 2651 // type C (or of pointer to a class type C), the unqualified-id is looked 2652 // up in the scope of class C. [...] 2653 ObjectType = BaseType.getAsOpaquePtr(); 2654 return move(Base); 2655} 2656 2657Sema::OwningExprResult Sema::DiagnoseDtorReference(SourceLocation NameLoc, 2658 ExprArg MemExpr) { 2659 Expr *E = (Expr *) MemExpr.get(); 2660 SourceLocation ExpectedLParenLoc = PP.getLocForEndOfToken(NameLoc); 2661 Diag(E->getLocStart(), diag::err_dtor_expr_without_call) 2662 << isa<CXXPseudoDestructorExpr>(E) 2663 << FixItHint::CreateInsertion(ExpectedLParenLoc, "()"); 2664 2665 return ActOnCallExpr(/*Scope*/ 0, 2666 move(MemExpr), 2667 /*LPLoc*/ ExpectedLParenLoc, 2668 Sema::MultiExprArg(*this, 0, 0), 2669 /*CommaLocs*/ 0, 2670 /*RPLoc*/ ExpectedLParenLoc); 2671} 2672 2673Sema::OwningExprResult Sema::BuildPseudoDestructorExpr(ExprArg Base, 2674 SourceLocation OpLoc, 2675 tok::TokenKind OpKind, 2676 const CXXScopeSpec &SS, 2677 TypeSourceInfo *ScopeTypeInfo, 2678 SourceLocation CCLoc, 2679 SourceLocation TildeLoc, 2680 PseudoDestructorTypeStorage Destructed, 2681 bool HasTrailingLParen) { 2682 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo(); 2683 2684 // C++ [expr.pseudo]p2: 2685 // The left-hand side of the dot operator shall be of scalar type. The 2686 // left-hand side of the arrow operator shall be of pointer to scalar type. 2687 // This scalar type is the object type. 2688 Expr *BaseE = (Expr *)Base.get(); 2689 QualType ObjectType = BaseE->getType(); 2690 if (OpKind == tok::arrow) { 2691 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 2692 ObjectType = Ptr->getPointeeType(); 2693 } else if (!BaseE->isTypeDependent()) { 2694 // The user wrote "p->" when she probably meant "p."; fix it. 2695 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 2696 << ObjectType << true 2697 << FixItHint::CreateReplacement(OpLoc, "."); 2698 if (isSFINAEContext()) 2699 return ExprError(); 2700 2701 OpKind = tok::period; 2702 } 2703 } 2704 2705 if (!ObjectType->isDependentType() && !ObjectType->isScalarType()) { 2706 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar) 2707 << ObjectType << BaseE->getSourceRange(); 2708 return ExprError(); 2709 } 2710 2711 // C++ [expr.pseudo]p2: 2712 // [...] The cv-unqualified versions of the object type and of the type 2713 // designated by the pseudo-destructor-name shall be the same type. 2714 if (DestructedTypeInfo) { 2715 QualType DestructedType = DestructedTypeInfo->getType(); 2716 SourceLocation DestructedTypeStart 2717 = DestructedTypeInfo->getTypeLoc().getSourceRange().getBegin(); 2718 if (!DestructedType->isDependentType() && !ObjectType->isDependentType() && 2719 !Context.hasSameUnqualifiedType(DestructedType, ObjectType)) { 2720 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch) 2721 << ObjectType << DestructedType << BaseE->getSourceRange() 2722 << DestructedTypeInfo->getTypeLoc().getSourceRange(); 2723 2724 // Recover by setting the destructed type to the object type. 2725 DestructedType = ObjectType; 2726 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType, 2727 DestructedTypeStart); 2728 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 2729 } 2730 } 2731 2732 // C++ [expr.pseudo]p2: 2733 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the 2734 // form 2735 // 2736 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name 2737 // 2738 // shall designate the same scalar type. 2739 if (ScopeTypeInfo) { 2740 QualType ScopeType = ScopeTypeInfo->getType(); 2741 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() && 2742 !Context.hasSameType(ScopeType, ObjectType)) { 2743 2744 Diag(ScopeTypeInfo->getTypeLoc().getSourceRange().getBegin(), 2745 diag::err_pseudo_dtor_type_mismatch) 2746 << ObjectType << ScopeType << BaseE->getSourceRange() 2747 << ScopeTypeInfo->getTypeLoc().getSourceRange(); 2748 2749 ScopeType = QualType(); 2750 ScopeTypeInfo = 0; 2751 } 2752 } 2753 2754 OwningExprResult Result 2755 = Owned(new (Context) CXXPseudoDestructorExpr(Context, 2756 Base.takeAs<Expr>(), 2757 OpKind == tok::arrow, 2758 OpLoc, 2759 (NestedNameSpecifier *) SS.getScopeRep(), 2760 SS.getRange(), 2761 ScopeTypeInfo, 2762 CCLoc, 2763 TildeLoc, 2764 Destructed)); 2765 2766 if (HasTrailingLParen) 2767 return move(Result); 2768 2769 return DiagnoseDtorReference(Destructed.getLocation(), move(Result)); 2770} 2771 2772Sema::OwningExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, ExprArg Base, 2773 SourceLocation OpLoc, 2774 tok::TokenKind OpKind, 2775 CXXScopeSpec &SS, 2776 UnqualifiedId &FirstTypeName, 2777 SourceLocation CCLoc, 2778 SourceLocation TildeLoc, 2779 UnqualifiedId &SecondTypeName, 2780 bool HasTrailingLParen) { 2781 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2782 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) && 2783 "Invalid first type name in pseudo-destructor"); 2784 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2785 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) && 2786 "Invalid second type name in pseudo-destructor"); 2787 2788 Expr *BaseE = (Expr *)Base.get(); 2789 2790 // C++ [expr.pseudo]p2: 2791 // The left-hand side of the dot operator shall be of scalar type. The 2792 // left-hand side of the arrow operator shall be of pointer to scalar type. 2793 // This scalar type is the object type. 2794 QualType ObjectType = BaseE->getType(); 2795 if (OpKind == tok::arrow) { 2796 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 2797 ObjectType = Ptr->getPointeeType(); 2798 } else if (!ObjectType->isDependentType()) { 2799 // The user wrote "p->" when she probably meant "p."; fix it. 2800 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 2801 << ObjectType << true 2802 << FixItHint::CreateReplacement(OpLoc, "."); 2803 if (isSFINAEContext()) 2804 return ExprError(); 2805 2806 OpKind = tok::period; 2807 } 2808 } 2809 2810 // Compute the object type that we should use for name lookup purposes. Only 2811 // record types and dependent types matter. 2812 void *ObjectTypePtrForLookup = 0; 2813 if (!SS.isSet()) { 2814 ObjectTypePtrForLookup = (void *)ObjectType->getAs<RecordType>(); 2815 if (!ObjectTypePtrForLookup && ObjectType->isDependentType()) 2816 ObjectTypePtrForLookup = Context.DependentTy.getAsOpaquePtr(); 2817 } 2818 2819 // Convert the name of the type being destructed (following the ~) into a 2820 // type (with source-location information). 2821 QualType DestructedType; 2822 TypeSourceInfo *DestructedTypeInfo = 0; 2823 PseudoDestructorTypeStorage Destructed; 2824 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) { 2825 TypeTy *T = getTypeName(*SecondTypeName.Identifier, 2826 SecondTypeName.StartLocation, 2827 S, &SS, true, ObjectTypePtrForLookup); 2828 if (!T && 2829 ((SS.isSet() && !computeDeclContext(SS, false)) || 2830 (!SS.isSet() && ObjectType->isDependentType()))) { 2831 // The name of the type being destroyed is a dependent name, and we 2832 // couldn't find anything useful in scope. Just store the identifier and 2833 // it's location, and we'll perform (qualified) name lookup again at 2834 // template instantiation time. 2835 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier, 2836 SecondTypeName.StartLocation); 2837 } else if (!T) { 2838 Diag(SecondTypeName.StartLocation, 2839 diag::err_pseudo_dtor_destructor_non_type) 2840 << SecondTypeName.Identifier << ObjectType; 2841 if (isSFINAEContext()) 2842 return ExprError(); 2843 2844 // Recover by assuming we had the right type all along. 2845 DestructedType = ObjectType; 2846 } else 2847 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo); 2848 } else { 2849 // Resolve the template-id to a type. 2850 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId; 2851 ASTTemplateArgsPtr TemplateArgsPtr(*this, 2852 TemplateId->getTemplateArgs(), 2853 TemplateId->NumArgs); 2854 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template), 2855 TemplateId->TemplateNameLoc, 2856 TemplateId->LAngleLoc, 2857 TemplateArgsPtr, 2858 TemplateId->RAngleLoc); 2859 if (T.isInvalid() || !T.get()) { 2860 // Recover by assuming we had the right type all along. 2861 DestructedType = ObjectType; 2862 } else 2863 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo); 2864 } 2865 2866 // If we've performed some kind of recovery, (re-)build the type source 2867 // information. 2868 if (!DestructedType.isNull()) { 2869 if (!DestructedTypeInfo) 2870 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType, 2871 SecondTypeName.StartLocation); 2872 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 2873 } 2874 2875 // Convert the name of the scope type (the type prior to '::') into a type. 2876 TypeSourceInfo *ScopeTypeInfo = 0; 2877 QualType ScopeType; 2878 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2879 FirstTypeName.Identifier) { 2880 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) { 2881 TypeTy *T = getTypeName(*FirstTypeName.Identifier, 2882 FirstTypeName.StartLocation, 2883 S, &SS, false, ObjectTypePtrForLookup); 2884 if (!T) { 2885 Diag(FirstTypeName.StartLocation, 2886 diag::err_pseudo_dtor_destructor_non_type) 2887 << FirstTypeName.Identifier << ObjectType; 2888 2889 if (isSFINAEContext()) 2890 return ExprError(); 2891 2892 // Just drop this type. It's unnecessary anyway. 2893 ScopeType = QualType(); 2894 } else 2895 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo); 2896 } else { 2897 // Resolve the template-id to a type. 2898 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId; 2899 ASTTemplateArgsPtr TemplateArgsPtr(*this, 2900 TemplateId->getTemplateArgs(), 2901 TemplateId->NumArgs); 2902 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template), 2903 TemplateId->TemplateNameLoc, 2904 TemplateId->LAngleLoc, 2905 TemplateArgsPtr, 2906 TemplateId->RAngleLoc); 2907 if (T.isInvalid() || !T.get()) { 2908 // Recover by dropping this type. 2909 ScopeType = QualType(); 2910 } else 2911 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo); 2912 } 2913 } 2914 2915 if (!ScopeType.isNull() && !ScopeTypeInfo) 2916 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType, 2917 FirstTypeName.StartLocation); 2918 2919 2920 return BuildPseudoDestructorExpr(move(Base), OpLoc, OpKind, SS, 2921 ScopeTypeInfo, CCLoc, TildeLoc, 2922 Destructed, HasTrailingLParen); 2923} 2924 2925CXXMemberCallExpr *Sema::BuildCXXMemberCallExpr(Expr *Exp, 2926 NamedDecl *FoundDecl, 2927 CXXMethodDecl *Method) { 2928 if (PerformObjectArgumentInitialization(Exp, /*Qualifier=*/0, 2929 FoundDecl, Method)) 2930 assert(0 && "Calling BuildCXXMemberCallExpr with invalid call?"); 2931 2932 MemberExpr *ME = 2933 new (Context) MemberExpr(Exp, /*IsArrow=*/false, Method, 2934 SourceLocation(), Method->getType()); 2935 QualType ResultType = Method->getResultType().getNonReferenceType(); 2936 MarkDeclarationReferenced(Exp->getLocStart(), Method); 2937 CXXMemberCallExpr *CE = 2938 new (Context) CXXMemberCallExpr(Context, ME, 0, 0, ResultType, 2939 Exp->getLocEnd()); 2940 return CE; 2941} 2942 2943Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) { 2944 Expr *FullExpr = Arg.takeAs<Expr>(); 2945 if (FullExpr) 2946 FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr); 2947 2948 return Owned(FullExpr); 2949} 2950