SemaExprCXX.cpp revision 207619
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 CheckSignCompare(LHS, RHS, QuestionLoc); 2117 2118 // C++0x 5.16p2 2119 // If either the second or the third operand has type (cv) void, ... 2120 QualType LTy = LHS->getType(); 2121 QualType RTy = RHS->getType(); 2122 bool LVoid = LTy->isVoidType(); 2123 bool RVoid = RTy->isVoidType(); 2124 if (LVoid || RVoid) { 2125 // ... then the [l2r] conversions are performed on the second and third 2126 // operands ... 2127 DefaultFunctionArrayLvalueConversion(LHS); 2128 DefaultFunctionArrayLvalueConversion(RHS); 2129 LTy = LHS->getType(); 2130 RTy = RHS->getType(); 2131 2132 // ... and one of the following shall hold: 2133 // -- The second or the third operand (but not both) is a throw- 2134 // expression; the result is of the type of the other and is an rvalue. 2135 bool LThrow = isa<CXXThrowExpr>(LHS); 2136 bool RThrow = isa<CXXThrowExpr>(RHS); 2137 if (LThrow && !RThrow) 2138 return RTy; 2139 if (RThrow && !LThrow) 2140 return LTy; 2141 2142 // -- Both the second and third operands have type void; the result is of 2143 // type void and is an rvalue. 2144 if (LVoid && RVoid) 2145 return Context.VoidTy; 2146 2147 // Neither holds, error. 2148 Diag(QuestionLoc, diag::err_conditional_void_nonvoid) 2149 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1) 2150 << LHS->getSourceRange() << RHS->getSourceRange(); 2151 return QualType(); 2152 } 2153 2154 // Neither is void. 2155 2156 // C++0x 5.16p3 2157 // Otherwise, if the second and third operand have different types, and 2158 // either has (cv) class type, and attempt is made to convert each of those 2159 // operands to the other. 2160 if (!Context.hasSameType(LTy, RTy) && 2161 (LTy->isRecordType() || RTy->isRecordType())) { 2162 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft; 2163 // These return true if a single direction is already ambiguous. 2164 QualType L2RType, R2LType; 2165 bool HaveL2R, HaveR2L; 2166 if (TryClassUnification(*this, LHS, RHS, QuestionLoc, HaveL2R, L2RType)) 2167 return QualType(); 2168 if (TryClassUnification(*this, RHS, LHS, QuestionLoc, HaveR2L, R2LType)) 2169 return QualType(); 2170 2171 // If both can be converted, [...] the program is ill-formed. 2172 if (HaveL2R && HaveR2L) { 2173 Diag(QuestionLoc, diag::err_conditional_ambiguous) 2174 << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange(); 2175 return QualType(); 2176 } 2177 2178 // If exactly one conversion is possible, that conversion is applied to 2179 // the chosen operand and the converted operands are used in place of the 2180 // original operands for the remainder of this section. 2181 if (HaveL2R) { 2182 if (ConvertForConditional(*this, LHS, L2RType)) 2183 return QualType(); 2184 LTy = LHS->getType(); 2185 } else if (HaveR2L) { 2186 if (ConvertForConditional(*this, RHS, R2LType)) 2187 return QualType(); 2188 RTy = RHS->getType(); 2189 } 2190 } 2191 2192 // C++0x 5.16p4 2193 // If the second and third operands are lvalues and have the same type, 2194 // the result is of that type [...] 2195 bool Same = Context.hasSameType(LTy, RTy); 2196 if (Same && LHS->isLvalue(Context) == Expr::LV_Valid && 2197 RHS->isLvalue(Context) == Expr::LV_Valid) 2198 return LTy; 2199 2200 // C++0x 5.16p5 2201 // Otherwise, the result is an rvalue. If the second and third operands 2202 // do not have the same type, and either has (cv) class type, ... 2203 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) { 2204 // ... overload resolution is used to determine the conversions (if any) 2205 // to be applied to the operands. If the overload resolution fails, the 2206 // program is ill-formed. 2207 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc)) 2208 return QualType(); 2209 } 2210 2211 // C++0x 5.16p6 2212 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard 2213 // conversions are performed on the second and third operands. 2214 DefaultFunctionArrayLvalueConversion(LHS); 2215 DefaultFunctionArrayLvalueConversion(RHS); 2216 LTy = LHS->getType(); 2217 RTy = RHS->getType(); 2218 2219 // After those conversions, one of the following shall hold: 2220 // -- The second and third operands have the same type; the result 2221 // is of that type. 2222 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) 2223 return LTy; 2224 2225 // -- The second and third operands have arithmetic or enumeration type; 2226 // the usual arithmetic conversions are performed to bring them to a 2227 // common type, and the result is of that type. 2228 if (LTy->isArithmeticType() && RTy->isArithmeticType()) { 2229 UsualArithmeticConversions(LHS, RHS); 2230 return LHS->getType(); 2231 } 2232 2233 // -- The second and third operands have pointer type, or one has pointer 2234 // type and the other is a null pointer constant; pointer conversions 2235 // and qualification conversions are performed to bring them to their 2236 // composite pointer type. The result is of the composite pointer type. 2237 // -- The second and third operands have pointer to member type, or one has 2238 // pointer to member type and the other is a null pointer constant; 2239 // pointer to member conversions and qualification conversions are 2240 // performed to bring them to a common type, whose cv-qualification 2241 // shall match the cv-qualification of either the second or the third 2242 // operand. The result is of the common type. 2243 bool NonStandardCompositeType = false; 2244 QualType Composite = FindCompositePointerType(QuestionLoc, LHS, RHS, 2245 isSFINAEContext()? 0 : &NonStandardCompositeType); 2246 if (!Composite.isNull()) { 2247 if (NonStandardCompositeType) 2248 Diag(QuestionLoc, 2249 diag::ext_typecheck_cond_incompatible_operands_nonstandard) 2250 << LTy << RTy << Composite 2251 << LHS->getSourceRange() << RHS->getSourceRange(); 2252 2253 return Composite; 2254 } 2255 2256 // Similarly, attempt to find composite type of two objective-c pointers. 2257 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc); 2258 if (!Composite.isNull()) 2259 return Composite; 2260 2261 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 2262 << LHS->getType() << RHS->getType() 2263 << LHS->getSourceRange() << RHS->getSourceRange(); 2264 return QualType(); 2265} 2266 2267/// \brief Find a merged pointer type and convert the two expressions to it. 2268/// 2269/// This finds the composite pointer type (or member pointer type) for @p E1 2270/// and @p E2 according to C++0x 5.9p2. It converts both expressions to this 2271/// type and returns it. 2272/// It does not emit diagnostics. 2273/// 2274/// \param Loc The location of the operator requiring these two expressions to 2275/// be converted to the composite pointer type. 2276/// 2277/// If \p NonStandardCompositeType is non-NULL, then we are permitted to find 2278/// a non-standard (but still sane) composite type to which both expressions 2279/// can be converted. When such a type is chosen, \c *NonStandardCompositeType 2280/// will be set true. 2281QualType Sema::FindCompositePointerType(SourceLocation Loc, 2282 Expr *&E1, Expr *&E2, 2283 bool *NonStandardCompositeType) { 2284 if (NonStandardCompositeType) 2285 *NonStandardCompositeType = false; 2286 2287 assert(getLangOptions().CPlusPlus && "This function assumes C++"); 2288 QualType T1 = E1->getType(), T2 = E2->getType(); 2289 2290 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() && 2291 !T2->isAnyPointerType() && !T2->isMemberPointerType()) 2292 return QualType(); 2293 2294 // C++0x 5.9p2 2295 // Pointer conversions and qualification conversions are performed on 2296 // pointer operands to bring them to their composite pointer type. If 2297 // one operand is a null pointer constant, the composite pointer type is 2298 // the type of the other operand. 2299 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 2300 if (T2->isMemberPointerType()) 2301 ImpCastExprToType(E1, T2, CastExpr::CK_NullToMemberPointer); 2302 else 2303 ImpCastExprToType(E1, T2, CastExpr::CK_IntegralToPointer); 2304 return T2; 2305 } 2306 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 2307 if (T1->isMemberPointerType()) 2308 ImpCastExprToType(E2, T1, CastExpr::CK_NullToMemberPointer); 2309 else 2310 ImpCastExprToType(E2, T1, CastExpr::CK_IntegralToPointer); 2311 return T1; 2312 } 2313 2314 // Now both have to be pointers or member pointers. 2315 if ((!T1->isPointerType() && !T1->isMemberPointerType()) || 2316 (!T2->isPointerType() && !T2->isMemberPointerType())) 2317 return QualType(); 2318 2319 // Otherwise, of one of the operands has type "pointer to cv1 void," then 2320 // the other has type "pointer to cv2 T" and the composite pointer type is 2321 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2. 2322 // Otherwise, the composite pointer type is a pointer type similar to the 2323 // type of one of the operands, with a cv-qualification signature that is 2324 // the union of the cv-qualification signatures of the operand types. 2325 // In practice, the first part here is redundant; it's subsumed by the second. 2326 // What we do here is, we build the two possible composite types, and try the 2327 // conversions in both directions. If only one works, or if the two composite 2328 // types are the same, we have succeeded. 2329 // FIXME: extended qualifiers? 2330 typedef llvm::SmallVector<unsigned, 4> QualifierVector; 2331 QualifierVector QualifierUnion; 2332 typedef llvm::SmallVector<std::pair<const Type *, const Type *>, 4> 2333 ContainingClassVector; 2334 ContainingClassVector MemberOfClass; 2335 QualType Composite1 = Context.getCanonicalType(T1), 2336 Composite2 = Context.getCanonicalType(T2); 2337 unsigned NeedConstBefore = 0; 2338 do { 2339 const PointerType *Ptr1, *Ptr2; 2340 if ((Ptr1 = Composite1->getAs<PointerType>()) && 2341 (Ptr2 = Composite2->getAs<PointerType>())) { 2342 Composite1 = Ptr1->getPointeeType(); 2343 Composite2 = Ptr2->getPointeeType(); 2344 2345 // If we're allowed to create a non-standard composite type, keep track 2346 // of where we need to fill in additional 'const' qualifiers. 2347 if (NonStandardCompositeType && 2348 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 2349 NeedConstBefore = QualifierUnion.size(); 2350 2351 QualifierUnion.push_back( 2352 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 2353 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0)); 2354 continue; 2355 } 2356 2357 const MemberPointerType *MemPtr1, *MemPtr2; 2358 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) && 2359 (MemPtr2 = Composite2->getAs<MemberPointerType>())) { 2360 Composite1 = MemPtr1->getPointeeType(); 2361 Composite2 = MemPtr2->getPointeeType(); 2362 2363 // If we're allowed to create a non-standard composite type, keep track 2364 // of where we need to fill in additional 'const' qualifiers. 2365 if (NonStandardCompositeType && 2366 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 2367 NeedConstBefore = QualifierUnion.size(); 2368 2369 QualifierUnion.push_back( 2370 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 2371 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(), 2372 MemPtr2->getClass())); 2373 continue; 2374 } 2375 2376 // FIXME: block pointer types? 2377 2378 // Cannot unwrap any more types. 2379 break; 2380 } while (true); 2381 2382 if (NeedConstBefore && NonStandardCompositeType) { 2383 // Extension: Add 'const' to qualifiers that come before the first qualifier 2384 // mismatch, so that our (non-standard!) composite type meets the 2385 // requirements of C++ [conv.qual]p4 bullet 3. 2386 for (unsigned I = 0; I != NeedConstBefore; ++I) { 2387 if ((QualifierUnion[I] & Qualifiers::Const) == 0) { 2388 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const; 2389 *NonStandardCompositeType = true; 2390 } 2391 } 2392 } 2393 2394 // Rewrap the composites as pointers or member pointers with the union CVRs. 2395 ContainingClassVector::reverse_iterator MOC 2396 = MemberOfClass.rbegin(); 2397 for (QualifierVector::reverse_iterator 2398 I = QualifierUnion.rbegin(), 2399 E = QualifierUnion.rend(); 2400 I != E; (void)++I, ++MOC) { 2401 Qualifiers Quals = Qualifiers::fromCVRMask(*I); 2402 if (MOC->first && MOC->second) { 2403 // Rebuild member pointer type 2404 Composite1 = Context.getMemberPointerType( 2405 Context.getQualifiedType(Composite1, Quals), 2406 MOC->first); 2407 Composite2 = Context.getMemberPointerType( 2408 Context.getQualifiedType(Composite2, Quals), 2409 MOC->second); 2410 } else { 2411 // Rebuild pointer type 2412 Composite1 2413 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals)); 2414 Composite2 2415 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals)); 2416 } 2417 } 2418 2419 // Try to convert to the first composite pointer type. 2420 InitializedEntity Entity1 2421 = InitializedEntity::InitializeTemporary(Composite1); 2422 InitializationKind Kind 2423 = InitializationKind::CreateCopy(Loc, SourceLocation()); 2424 InitializationSequence E1ToC1(*this, Entity1, Kind, &E1, 1); 2425 InitializationSequence E2ToC1(*this, Entity1, Kind, &E2, 1); 2426 2427 if (E1ToC1 && E2ToC1) { 2428 // Conversion to Composite1 is viable. 2429 if (!Context.hasSameType(Composite1, Composite2)) { 2430 // Composite2 is a different type from Composite1. Check whether 2431 // Composite2 is also viable. 2432 InitializedEntity Entity2 2433 = InitializedEntity::InitializeTemporary(Composite2); 2434 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1); 2435 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1); 2436 if (E1ToC2 && E2ToC2) { 2437 // Both Composite1 and Composite2 are viable and are different; 2438 // this is an ambiguity. 2439 return QualType(); 2440 } 2441 } 2442 2443 // Convert E1 to Composite1 2444 OwningExprResult E1Result 2445 = E1ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,(void**)&E1,1)); 2446 if (E1Result.isInvalid()) 2447 return QualType(); 2448 E1 = E1Result.takeAs<Expr>(); 2449 2450 // Convert E2 to Composite1 2451 OwningExprResult E2Result 2452 = E2ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,(void**)&E2,1)); 2453 if (E2Result.isInvalid()) 2454 return QualType(); 2455 E2 = E2Result.takeAs<Expr>(); 2456 2457 return Composite1; 2458 } 2459 2460 // Check whether Composite2 is viable. 2461 InitializedEntity Entity2 2462 = InitializedEntity::InitializeTemporary(Composite2); 2463 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1); 2464 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1); 2465 if (!E1ToC2 || !E2ToC2) 2466 return QualType(); 2467 2468 // Convert E1 to Composite2 2469 OwningExprResult E1Result 2470 = E1ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, (void**)&E1, 1)); 2471 if (E1Result.isInvalid()) 2472 return QualType(); 2473 E1 = E1Result.takeAs<Expr>(); 2474 2475 // Convert E2 to Composite2 2476 OwningExprResult E2Result 2477 = E2ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, (void**)&E2, 1)); 2478 if (E2Result.isInvalid()) 2479 return QualType(); 2480 E2 = E2Result.takeAs<Expr>(); 2481 2482 return Composite2; 2483} 2484 2485Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) { 2486 if (!Context.getLangOptions().CPlusPlus) 2487 return Owned(E); 2488 2489 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?"); 2490 2491 const RecordType *RT = E->getType()->getAs<RecordType>(); 2492 if (!RT) 2493 return Owned(E); 2494 2495 // If this is the result of a call expression, our source might 2496 // actually be a reference, in which case we shouldn't bind. 2497 if (CallExpr *CE = dyn_cast<CallExpr>(E)) { 2498 QualType Ty = CE->getCallee()->getType(); 2499 if (const PointerType *PT = Ty->getAs<PointerType>()) 2500 Ty = PT->getPointeeType(); 2501 else if (const BlockPointerType *BPT = Ty->getAs<BlockPointerType>()) 2502 Ty = BPT->getPointeeType(); 2503 2504 const FunctionType *FTy = Ty->getAs<FunctionType>(); 2505 if (FTy->getResultType()->isReferenceType()) 2506 return Owned(E); 2507 } 2508 2509 // That should be enough to guarantee that this type is complete. 2510 // If it has a trivial destructor, we can avoid the extra copy. 2511 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 2512 if (RD->hasTrivialDestructor()) 2513 return Owned(E); 2514 2515 CXXTemporary *Temp = CXXTemporary::Create(Context, 2516 RD->getDestructor(Context)); 2517 ExprTemporaries.push_back(Temp); 2518 if (CXXDestructorDecl *Destructor = 2519 const_cast<CXXDestructorDecl*>(RD->getDestructor(Context))) { 2520 MarkDeclarationReferenced(E->getExprLoc(), Destructor); 2521 CheckDestructorAccess(E->getExprLoc(), Destructor, 2522 PDiag(diag::err_access_dtor_temp) 2523 << E->getType()); 2524 } 2525 // FIXME: Add the temporary to the temporaries vector. 2526 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E)); 2527} 2528 2529Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr) { 2530 assert(SubExpr && "sub expression can't be null!"); 2531 2532 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 2533 assert(ExprTemporaries.size() >= FirstTemporary); 2534 if (ExprTemporaries.size() == FirstTemporary) 2535 return SubExpr; 2536 2537 Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr, 2538 &ExprTemporaries[FirstTemporary], 2539 ExprTemporaries.size() - FirstTemporary); 2540 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 2541 ExprTemporaries.end()); 2542 2543 return E; 2544} 2545 2546Sema::OwningExprResult 2547Sema::MaybeCreateCXXExprWithTemporaries(OwningExprResult SubExpr) { 2548 if (SubExpr.isInvalid()) 2549 return ExprError(); 2550 2551 return Owned(MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>())); 2552} 2553 2554FullExpr Sema::CreateFullExpr(Expr *SubExpr) { 2555 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 2556 assert(ExprTemporaries.size() >= FirstTemporary); 2557 2558 unsigned NumTemporaries = ExprTemporaries.size() - FirstTemporary; 2559 CXXTemporary **Temporaries = 2560 NumTemporaries == 0 ? 0 : &ExprTemporaries[FirstTemporary]; 2561 2562 FullExpr E = FullExpr::Create(Context, SubExpr, Temporaries, NumTemporaries); 2563 2564 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 2565 ExprTemporaries.end()); 2566 2567 return E; 2568} 2569 2570Sema::OwningExprResult 2571Sema::ActOnStartCXXMemberReference(Scope *S, ExprArg Base, SourceLocation OpLoc, 2572 tok::TokenKind OpKind, TypeTy *&ObjectType, 2573 bool &MayBePseudoDestructor) { 2574 // Since this might be a postfix expression, get rid of ParenListExprs. 2575 Base = MaybeConvertParenListExprToParenExpr(S, move(Base)); 2576 2577 Expr *BaseExpr = (Expr*)Base.get(); 2578 assert(BaseExpr && "no record expansion"); 2579 2580 QualType BaseType = BaseExpr->getType(); 2581 MayBePseudoDestructor = false; 2582 if (BaseType->isDependentType()) { 2583 // If we have a pointer to a dependent type and are using the -> operator, 2584 // the object type is the type that the pointer points to. We might still 2585 // have enough information about that type to do something useful. 2586 if (OpKind == tok::arrow) 2587 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 2588 BaseType = Ptr->getPointeeType(); 2589 2590 ObjectType = BaseType.getAsOpaquePtr(); 2591 MayBePseudoDestructor = true; 2592 return move(Base); 2593 } 2594 2595 // C++ [over.match.oper]p8: 2596 // [...] When operator->returns, the operator-> is applied to the value 2597 // returned, with the original second operand. 2598 if (OpKind == tok::arrow) { 2599 // The set of types we've considered so far. 2600 llvm::SmallPtrSet<CanQualType,8> CTypes; 2601 llvm::SmallVector<SourceLocation, 8> Locations; 2602 CTypes.insert(Context.getCanonicalType(BaseType)); 2603 2604 while (BaseType->isRecordType()) { 2605 Base = BuildOverloadedArrowExpr(S, move(Base), OpLoc); 2606 BaseExpr = (Expr*)Base.get(); 2607 if (BaseExpr == NULL) 2608 return ExprError(); 2609 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(BaseExpr)) 2610 Locations.push_back(OpCall->getDirectCallee()->getLocation()); 2611 BaseType = BaseExpr->getType(); 2612 CanQualType CBaseType = Context.getCanonicalType(BaseType); 2613 if (!CTypes.insert(CBaseType)) { 2614 Diag(OpLoc, diag::err_operator_arrow_circular); 2615 for (unsigned i = 0; i < Locations.size(); i++) 2616 Diag(Locations[i], diag::note_declared_at); 2617 return ExprError(); 2618 } 2619 } 2620 2621 if (BaseType->isPointerType()) 2622 BaseType = BaseType->getPointeeType(); 2623 } 2624 2625 // We could end up with various non-record types here, such as extended 2626 // vector types or Objective-C interfaces. Just return early and let 2627 // ActOnMemberReferenceExpr do the work. 2628 if (!BaseType->isRecordType()) { 2629 // C++ [basic.lookup.classref]p2: 2630 // [...] If the type of the object expression is of pointer to scalar 2631 // type, the unqualified-id is looked up in the context of the complete 2632 // postfix-expression. 2633 // 2634 // This also indicates that we should be parsing a 2635 // pseudo-destructor-name. 2636 ObjectType = 0; 2637 MayBePseudoDestructor = true; 2638 return move(Base); 2639 } 2640 2641 // The object type must be complete (or dependent). 2642 if (!BaseType->isDependentType() && 2643 RequireCompleteType(OpLoc, BaseType, 2644 PDiag(diag::err_incomplete_member_access))) 2645 return ExprError(); 2646 2647 // C++ [basic.lookup.classref]p2: 2648 // If the id-expression in a class member access (5.2.5) is an 2649 // unqualified-id, and the type of the object expression is of a class 2650 // type C (or of pointer to a class type C), the unqualified-id is looked 2651 // up in the scope of class C. [...] 2652 ObjectType = BaseType.getAsOpaquePtr(); 2653 return move(Base); 2654} 2655 2656Sema::OwningExprResult Sema::DiagnoseDtorReference(SourceLocation NameLoc, 2657 ExprArg MemExpr) { 2658 Expr *E = (Expr *) MemExpr.get(); 2659 SourceLocation ExpectedLParenLoc = PP.getLocForEndOfToken(NameLoc); 2660 Diag(E->getLocStart(), diag::err_dtor_expr_without_call) 2661 << isa<CXXPseudoDestructorExpr>(E) 2662 << FixItHint::CreateInsertion(ExpectedLParenLoc, "()"); 2663 2664 return ActOnCallExpr(/*Scope*/ 0, 2665 move(MemExpr), 2666 /*LPLoc*/ ExpectedLParenLoc, 2667 Sema::MultiExprArg(*this, 0, 0), 2668 /*CommaLocs*/ 0, 2669 /*RPLoc*/ ExpectedLParenLoc); 2670} 2671 2672Sema::OwningExprResult Sema::BuildPseudoDestructorExpr(ExprArg Base, 2673 SourceLocation OpLoc, 2674 tok::TokenKind OpKind, 2675 const CXXScopeSpec &SS, 2676 TypeSourceInfo *ScopeTypeInfo, 2677 SourceLocation CCLoc, 2678 SourceLocation TildeLoc, 2679 PseudoDestructorTypeStorage Destructed, 2680 bool HasTrailingLParen) { 2681 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo(); 2682 2683 // C++ [expr.pseudo]p2: 2684 // The left-hand side of the dot operator shall be of scalar type. The 2685 // left-hand side of the arrow operator shall be of pointer to scalar type. 2686 // This scalar type is the object type. 2687 Expr *BaseE = (Expr *)Base.get(); 2688 QualType ObjectType = BaseE->getType(); 2689 if (OpKind == tok::arrow) { 2690 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 2691 ObjectType = Ptr->getPointeeType(); 2692 } else if (!BaseE->isTypeDependent()) { 2693 // The user wrote "p->" when she probably meant "p."; fix it. 2694 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 2695 << ObjectType << true 2696 << FixItHint::CreateReplacement(OpLoc, "."); 2697 if (isSFINAEContext()) 2698 return ExprError(); 2699 2700 OpKind = tok::period; 2701 } 2702 } 2703 2704 if (!ObjectType->isDependentType() && !ObjectType->isScalarType()) { 2705 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar) 2706 << ObjectType << BaseE->getSourceRange(); 2707 return ExprError(); 2708 } 2709 2710 // C++ [expr.pseudo]p2: 2711 // [...] The cv-unqualified versions of the object type and of the type 2712 // designated by the pseudo-destructor-name shall be the same type. 2713 if (DestructedTypeInfo) { 2714 QualType DestructedType = DestructedTypeInfo->getType(); 2715 SourceLocation DestructedTypeStart 2716 = DestructedTypeInfo->getTypeLoc().getSourceRange().getBegin(); 2717 if (!DestructedType->isDependentType() && !ObjectType->isDependentType() && 2718 !Context.hasSameUnqualifiedType(DestructedType, ObjectType)) { 2719 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch) 2720 << ObjectType << DestructedType << BaseE->getSourceRange() 2721 << DestructedTypeInfo->getTypeLoc().getSourceRange(); 2722 2723 // Recover by setting the destructed type to the object type. 2724 DestructedType = ObjectType; 2725 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType, 2726 DestructedTypeStart); 2727 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 2728 } 2729 } 2730 2731 // C++ [expr.pseudo]p2: 2732 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the 2733 // form 2734 // 2735 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name 2736 // 2737 // shall designate the same scalar type. 2738 if (ScopeTypeInfo) { 2739 QualType ScopeType = ScopeTypeInfo->getType(); 2740 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() && 2741 !Context.hasSameType(ScopeType, ObjectType)) { 2742 2743 Diag(ScopeTypeInfo->getTypeLoc().getSourceRange().getBegin(), 2744 diag::err_pseudo_dtor_type_mismatch) 2745 << ObjectType << ScopeType << BaseE->getSourceRange() 2746 << ScopeTypeInfo->getTypeLoc().getSourceRange(); 2747 2748 ScopeType = QualType(); 2749 ScopeTypeInfo = 0; 2750 } 2751 } 2752 2753 OwningExprResult Result 2754 = Owned(new (Context) CXXPseudoDestructorExpr(Context, 2755 Base.takeAs<Expr>(), 2756 OpKind == tok::arrow, 2757 OpLoc, 2758 (NestedNameSpecifier *) SS.getScopeRep(), 2759 SS.getRange(), 2760 ScopeTypeInfo, 2761 CCLoc, 2762 TildeLoc, 2763 Destructed)); 2764 2765 if (HasTrailingLParen) 2766 return move(Result); 2767 2768 return DiagnoseDtorReference(Destructed.getLocation(), move(Result)); 2769} 2770 2771Sema::OwningExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, ExprArg Base, 2772 SourceLocation OpLoc, 2773 tok::TokenKind OpKind, 2774 CXXScopeSpec &SS, 2775 UnqualifiedId &FirstTypeName, 2776 SourceLocation CCLoc, 2777 SourceLocation TildeLoc, 2778 UnqualifiedId &SecondTypeName, 2779 bool HasTrailingLParen) { 2780 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2781 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) && 2782 "Invalid first type name in pseudo-destructor"); 2783 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2784 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) && 2785 "Invalid second type name in pseudo-destructor"); 2786 2787 Expr *BaseE = (Expr *)Base.get(); 2788 2789 // C++ [expr.pseudo]p2: 2790 // The left-hand side of the dot operator shall be of scalar type. The 2791 // left-hand side of the arrow operator shall be of pointer to scalar type. 2792 // This scalar type is the object type. 2793 QualType ObjectType = BaseE->getType(); 2794 if (OpKind == tok::arrow) { 2795 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 2796 ObjectType = Ptr->getPointeeType(); 2797 } else if (!ObjectType->isDependentType()) { 2798 // The user wrote "p->" when she probably meant "p."; fix it. 2799 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 2800 << ObjectType << true 2801 << FixItHint::CreateReplacement(OpLoc, "."); 2802 if (isSFINAEContext()) 2803 return ExprError(); 2804 2805 OpKind = tok::period; 2806 } 2807 } 2808 2809 // Compute the object type that we should use for name lookup purposes. Only 2810 // record types and dependent types matter. 2811 void *ObjectTypePtrForLookup = 0; 2812 if (!SS.isSet()) { 2813 ObjectTypePtrForLookup = (void *)ObjectType->getAs<RecordType>(); 2814 if (!ObjectTypePtrForLookup && ObjectType->isDependentType()) 2815 ObjectTypePtrForLookup = Context.DependentTy.getAsOpaquePtr(); 2816 } 2817 2818 // Convert the name of the type being destructed (following the ~) into a 2819 // type (with source-location information). 2820 QualType DestructedType; 2821 TypeSourceInfo *DestructedTypeInfo = 0; 2822 PseudoDestructorTypeStorage Destructed; 2823 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) { 2824 TypeTy *T = getTypeName(*SecondTypeName.Identifier, 2825 SecondTypeName.StartLocation, 2826 S, &SS, true, ObjectTypePtrForLookup); 2827 if (!T && 2828 ((SS.isSet() && !computeDeclContext(SS, false)) || 2829 (!SS.isSet() && ObjectType->isDependentType()))) { 2830 // The name of the type being destroyed is a dependent name, and we 2831 // couldn't find anything useful in scope. Just store the identifier and 2832 // it's location, and we'll perform (qualified) name lookup again at 2833 // template instantiation time. 2834 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier, 2835 SecondTypeName.StartLocation); 2836 } else if (!T) { 2837 Diag(SecondTypeName.StartLocation, 2838 diag::err_pseudo_dtor_destructor_non_type) 2839 << SecondTypeName.Identifier << ObjectType; 2840 if (isSFINAEContext()) 2841 return ExprError(); 2842 2843 // Recover by assuming we had the right type all along. 2844 DestructedType = ObjectType; 2845 } else 2846 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo); 2847 } else { 2848 // Resolve the template-id to a type. 2849 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId; 2850 ASTTemplateArgsPtr TemplateArgsPtr(*this, 2851 TemplateId->getTemplateArgs(), 2852 TemplateId->NumArgs); 2853 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template), 2854 TemplateId->TemplateNameLoc, 2855 TemplateId->LAngleLoc, 2856 TemplateArgsPtr, 2857 TemplateId->RAngleLoc); 2858 if (T.isInvalid() || !T.get()) { 2859 // Recover by assuming we had the right type all along. 2860 DestructedType = ObjectType; 2861 } else 2862 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo); 2863 } 2864 2865 // If we've performed some kind of recovery, (re-)build the type source 2866 // information. 2867 if (!DestructedType.isNull()) { 2868 if (!DestructedTypeInfo) 2869 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType, 2870 SecondTypeName.StartLocation); 2871 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 2872 } 2873 2874 // Convert the name of the scope type (the type prior to '::') into a type. 2875 TypeSourceInfo *ScopeTypeInfo = 0; 2876 QualType ScopeType; 2877 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2878 FirstTypeName.Identifier) { 2879 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) { 2880 TypeTy *T = getTypeName(*FirstTypeName.Identifier, 2881 FirstTypeName.StartLocation, 2882 S, &SS, false, ObjectTypePtrForLookup); 2883 if (!T) { 2884 Diag(FirstTypeName.StartLocation, 2885 diag::err_pseudo_dtor_destructor_non_type) 2886 << FirstTypeName.Identifier << ObjectType; 2887 2888 if (isSFINAEContext()) 2889 return ExprError(); 2890 2891 // Just drop this type. It's unnecessary anyway. 2892 ScopeType = QualType(); 2893 } else 2894 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo); 2895 } else { 2896 // Resolve the template-id to a type. 2897 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId; 2898 ASTTemplateArgsPtr TemplateArgsPtr(*this, 2899 TemplateId->getTemplateArgs(), 2900 TemplateId->NumArgs); 2901 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template), 2902 TemplateId->TemplateNameLoc, 2903 TemplateId->LAngleLoc, 2904 TemplateArgsPtr, 2905 TemplateId->RAngleLoc); 2906 if (T.isInvalid() || !T.get()) { 2907 // Recover by dropping this type. 2908 ScopeType = QualType(); 2909 } else 2910 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo); 2911 } 2912 } 2913 2914 if (!ScopeType.isNull() && !ScopeTypeInfo) 2915 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType, 2916 FirstTypeName.StartLocation); 2917 2918 2919 return BuildPseudoDestructorExpr(move(Base), OpLoc, OpKind, SS, 2920 ScopeTypeInfo, CCLoc, TildeLoc, 2921 Destructed, HasTrailingLParen); 2922} 2923 2924CXXMemberCallExpr *Sema::BuildCXXMemberCallExpr(Expr *Exp, 2925 NamedDecl *FoundDecl, 2926 CXXMethodDecl *Method) { 2927 if (PerformObjectArgumentInitialization(Exp, /*Qualifier=*/0, 2928 FoundDecl, Method)) 2929 assert(0 && "Calling BuildCXXMemberCallExpr with invalid call?"); 2930 2931 MemberExpr *ME = 2932 new (Context) MemberExpr(Exp, /*IsArrow=*/false, Method, 2933 SourceLocation(), Method->getType()); 2934 QualType ResultType = Method->getResultType().getNonReferenceType(); 2935 MarkDeclarationReferenced(Exp->getLocStart(), Method); 2936 CXXMemberCallExpr *CE = 2937 new (Context) CXXMemberCallExpr(Context, ME, 0, 0, ResultType, 2938 Exp->getLocEnd()); 2939 return CE; 2940} 2941 2942Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) { 2943 Expr *FullExpr = Arg.takeAs<Expr>(); 2944 if (FullExpr) 2945 FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr); 2946 2947 return Owned(FullExpr); 2948} 2949