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