SemaExprCXX.cpp revision 206084
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, 952 FunctionType::ExtInfo()); 953 } 954 955 for (LookupResult::iterator D = FoundDelete.begin(), 956 DEnd = FoundDelete.end(); 957 D != DEnd; ++D) { 958 FunctionDecl *Fn = 0; 959 if (FunctionTemplateDecl *FnTmpl 960 = dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) { 961 // Perform template argument deduction to try to match the 962 // expected function type. 963 TemplateDeductionInfo Info(Context, StartLoc); 964 if (DeduceTemplateArguments(FnTmpl, 0, ExpectedFunctionType, Fn, Info)) 965 continue; 966 } else 967 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl()); 968 969 if (Context.hasSameType(Fn->getType(), ExpectedFunctionType)) 970 Matches.push_back(std::make_pair(D.getPair(), Fn)); 971 } 972 } else { 973 // C++ [expr.new]p20: 974 // [...] Any non-placement deallocation function matches a 975 // non-placement allocation function. [...] 976 for (LookupResult::iterator D = FoundDelete.begin(), 977 DEnd = FoundDelete.end(); 978 D != DEnd; ++D) { 979 if (FunctionDecl *Fn = dyn_cast<FunctionDecl>((*D)->getUnderlyingDecl())) 980 if (isNonPlacementDeallocationFunction(Fn)) 981 Matches.push_back(std::make_pair(D.getPair(), Fn)); 982 } 983 } 984 985 // C++ [expr.new]p20: 986 // [...] If the lookup finds a single matching deallocation 987 // function, that function will be called; otherwise, no 988 // deallocation function will be called. 989 if (Matches.size() == 1) { 990 OperatorDelete = Matches[0].second; 991 992 // C++0x [expr.new]p20: 993 // If the lookup finds the two-parameter form of a usual 994 // deallocation function (3.7.4.2) and that function, considered 995 // as a placement deallocation function, would have been 996 // selected as a match for the allocation function, the program 997 // is ill-formed. 998 if (NumPlaceArgs && getLangOptions().CPlusPlus0x && 999 isNonPlacementDeallocationFunction(OperatorDelete)) { 1000 Diag(StartLoc, diag::err_placement_new_non_placement_delete) 1001 << SourceRange(PlaceArgs[0]->getLocStart(), 1002 PlaceArgs[NumPlaceArgs - 1]->getLocEnd()); 1003 Diag(OperatorDelete->getLocation(), diag::note_previous_decl) 1004 << DeleteName; 1005 } else { 1006 CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(), 1007 Matches[0].first); 1008 } 1009 } 1010 1011 return false; 1012} 1013 1014/// FindAllocationOverload - Find an fitting overload for the allocation 1015/// function in the specified scope. 1016bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range, 1017 DeclarationName Name, Expr** Args, 1018 unsigned NumArgs, DeclContext *Ctx, 1019 bool AllowMissing, FunctionDecl *&Operator) { 1020 LookupResult R(*this, Name, StartLoc, LookupOrdinaryName); 1021 LookupQualifiedName(R, Ctx); 1022 if (R.empty()) { 1023 if (AllowMissing) 1024 return false; 1025 return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call) 1026 << Name << Range; 1027 } 1028 1029 if (R.isAmbiguous()) 1030 return true; 1031 1032 R.suppressDiagnostics(); 1033 1034 OverloadCandidateSet Candidates(StartLoc); 1035 for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end(); 1036 Alloc != AllocEnd; ++Alloc) { 1037 // Even member operator new/delete are implicitly treated as 1038 // static, so don't use AddMemberCandidate. 1039 NamedDecl *D = (*Alloc)->getUnderlyingDecl(); 1040 1041 if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) { 1042 AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(), 1043 /*ExplicitTemplateArgs=*/0, Args, NumArgs, 1044 Candidates, 1045 /*SuppressUserConversions=*/false); 1046 continue; 1047 } 1048 1049 FunctionDecl *Fn = cast<FunctionDecl>(D); 1050 AddOverloadCandidate(Fn, Alloc.getPair(), Args, NumArgs, Candidates, 1051 /*SuppressUserConversions=*/false); 1052 } 1053 1054 // Do the resolution. 1055 OverloadCandidateSet::iterator Best; 1056 switch(BestViableFunction(Candidates, StartLoc, Best)) { 1057 case OR_Success: { 1058 // Got one! 1059 FunctionDecl *FnDecl = Best->Function; 1060 // The first argument is size_t, and the first parameter must be size_t, 1061 // too. This is checked on declaration and can be assumed. (It can't be 1062 // asserted on, though, since invalid decls are left in there.) 1063 // Watch out for variadic allocator function. 1064 unsigned NumArgsInFnDecl = FnDecl->getNumParams(); 1065 for (unsigned i = 0; (i < NumArgs && i < NumArgsInFnDecl); ++i) { 1066 OwningExprResult Result 1067 = PerformCopyInitialization(InitializedEntity::InitializeParameter( 1068 FnDecl->getParamDecl(i)), 1069 SourceLocation(), 1070 Owned(Args[i]->Retain())); 1071 if (Result.isInvalid()) 1072 return true; 1073 1074 Args[i] = Result.takeAs<Expr>(); 1075 } 1076 Operator = FnDecl; 1077 CheckAllocationAccess(StartLoc, Range, R.getNamingClass(), Best->FoundDecl); 1078 return false; 1079 } 1080 1081 case OR_No_Viable_Function: 1082 Diag(StartLoc, diag::err_ovl_no_viable_function_in_call) 1083 << Name << Range; 1084 PrintOverloadCandidates(Candidates, OCD_AllCandidates, Args, NumArgs); 1085 return true; 1086 1087 case OR_Ambiguous: 1088 Diag(StartLoc, diag::err_ovl_ambiguous_call) 1089 << Name << Range; 1090 PrintOverloadCandidates(Candidates, OCD_ViableCandidates, Args, NumArgs); 1091 return true; 1092 1093 case OR_Deleted: 1094 Diag(StartLoc, diag::err_ovl_deleted_call) 1095 << Best->Function->isDeleted() 1096 << Name << Range; 1097 PrintOverloadCandidates(Candidates, OCD_AllCandidates, Args, NumArgs); 1098 return true; 1099 } 1100 assert(false && "Unreachable, bad result from BestViableFunction"); 1101 return true; 1102} 1103 1104 1105/// DeclareGlobalNewDelete - Declare the global forms of operator new and 1106/// delete. These are: 1107/// @code 1108/// void* operator new(std::size_t) throw(std::bad_alloc); 1109/// void* operator new[](std::size_t) throw(std::bad_alloc); 1110/// void operator delete(void *) throw(); 1111/// void operator delete[](void *) throw(); 1112/// @endcode 1113/// Note that the placement and nothrow forms of new are *not* implicitly 1114/// declared. Their use requires including \<new\>. 1115void Sema::DeclareGlobalNewDelete() { 1116 if (GlobalNewDeleteDeclared) 1117 return; 1118 1119 // C++ [basic.std.dynamic]p2: 1120 // [...] The following allocation and deallocation functions (18.4) are 1121 // implicitly declared in global scope in each translation unit of a 1122 // program 1123 // 1124 // void* operator new(std::size_t) throw(std::bad_alloc); 1125 // void* operator new[](std::size_t) throw(std::bad_alloc); 1126 // void operator delete(void*) throw(); 1127 // void operator delete[](void*) throw(); 1128 // 1129 // These implicit declarations introduce only the function names operator 1130 // new, operator new[], operator delete, operator delete[]. 1131 // 1132 // Here, we need to refer to std::bad_alloc, so we will implicitly declare 1133 // "std" or "bad_alloc" as necessary to form the exception specification. 1134 // However, we do not make these implicit declarations visible to name 1135 // lookup. 1136 if (!StdNamespace) { 1137 // The "std" namespace has not yet been defined, so build one implicitly. 1138 StdNamespace = NamespaceDecl::Create(Context, 1139 Context.getTranslationUnitDecl(), 1140 SourceLocation(), 1141 &PP.getIdentifierTable().get("std")); 1142 StdNamespace->setImplicit(true); 1143 } 1144 1145 if (!StdBadAlloc) { 1146 // The "std::bad_alloc" class has not yet been declared, so build it 1147 // implicitly. 1148 StdBadAlloc = CXXRecordDecl::Create(Context, TagDecl::TK_class, 1149 StdNamespace, 1150 SourceLocation(), 1151 &PP.getIdentifierTable().get("bad_alloc"), 1152 SourceLocation(), 0); 1153 StdBadAlloc->setImplicit(true); 1154 } 1155 1156 GlobalNewDeleteDeclared = true; 1157 1158 QualType VoidPtr = Context.getPointerType(Context.VoidTy); 1159 QualType SizeT = Context.getSizeType(); 1160 bool AssumeSaneOperatorNew = getLangOptions().AssumeSaneOperatorNew; 1161 1162 DeclareGlobalAllocationFunction( 1163 Context.DeclarationNames.getCXXOperatorName(OO_New), 1164 VoidPtr, SizeT, AssumeSaneOperatorNew); 1165 DeclareGlobalAllocationFunction( 1166 Context.DeclarationNames.getCXXOperatorName(OO_Array_New), 1167 VoidPtr, SizeT, AssumeSaneOperatorNew); 1168 DeclareGlobalAllocationFunction( 1169 Context.DeclarationNames.getCXXOperatorName(OO_Delete), 1170 Context.VoidTy, VoidPtr); 1171 DeclareGlobalAllocationFunction( 1172 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete), 1173 Context.VoidTy, VoidPtr); 1174} 1175 1176/// DeclareGlobalAllocationFunction - Declares a single implicit global 1177/// allocation function if it doesn't already exist. 1178void Sema::DeclareGlobalAllocationFunction(DeclarationName Name, 1179 QualType Return, QualType Argument, 1180 bool AddMallocAttr) { 1181 DeclContext *GlobalCtx = Context.getTranslationUnitDecl(); 1182 1183 // Check if this function is already declared. 1184 { 1185 DeclContext::lookup_iterator Alloc, AllocEnd; 1186 for (llvm::tie(Alloc, AllocEnd) = GlobalCtx->lookup(Name); 1187 Alloc != AllocEnd; ++Alloc) { 1188 // Only look at non-template functions, as it is the predefined, 1189 // non-templated allocation function we are trying to declare here. 1190 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) { 1191 QualType InitialParamType = 1192 Context.getCanonicalType( 1193 Func->getParamDecl(0)->getType().getUnqualifiedType()); 1194 // FIXME: Do we need to check for default arguments here? 1195 if (Func->getNumParams() == 1 && InitialParamType == Argument) 1196 return; 1197 } 1198 } 1199 } 1200 1201 QualType BadAllocType; 1202 bool HasBadAllocExceptionSpec 1203 = (Name.getCXXOverloadedOperator() == OO_New || 1204 Name.getCXXOverloadedOperator() == OO_Array_New); 1205 if (HasBadAllocExceptionSpec) { 1206 assert(StdBadAlloc && "Must have std::bad_alloc declared"); 1207 BadAllocType = Context.getTypeDeclType(StdBadAlloc); 1208 } 1209 1210 QualType FnType = Context.getFunctionType(Return, &Argument, 1, false, 0, 1211 true, false, 1212 HasBadAllocExceptionSpec? 1 : 0, 1213 &BadAllocType, 1214 FunctionType::ExtInfo()); 1215 FunctionDecl *Alloc = 1216 FunctionDecl::Create(Context, GlobalCtx, SourceLocation(), Name, 1217 FnType, /*TInfo=*/0, FunctionDecl::None, false, true); 1218 Alloc->setImplicit(); 1219 1220 if (AddMallocAttr) 1221 Alloc->addAttr(::new (Context) MallocAttr()); 1222 1223 ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(), 1224 0, Argument, /*TInfo=*/0, 1225 VarDecl::None, 0); 1226 Alloc->setParams(&Param, 1); 1227 1228 // FIXME: Also add this declaration to the IdentifierResolver, but 1229 // make sure it is at the end of the chain to coincide with the 1230 // global scope. 1231 ((DeclContext *)TUScope->getEntity())->addDecl(Alloc); 1232} 1233 1234bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, 1235 DeclarationName Name, 1236 FunctionDecl* &Operator) { 1237 LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName); 1238 // Try to find operator delete/operator delete[] in class scope. 1239 LookupQualifiedName(Found, RD); 1240 1241 if (Found.isAmbiguous()) 1242 return true; 1243 1244 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end(); 1245 F != FEnd; ++F) { 1246 if (CXXMethodDecl *Delete = dyn_cast<CXXMethodDecl>(*F)) 1247 if (Delete->isUsualDeallocationFunction()) { 1248 Operator = Delete; 1249 return false; 1250 } 1251 } 1252 1253 // We did find operator delete/operator delete[] declarations, but 1254 // none of them were suitable. 1255 if (!Found.empty()) { 1256 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found) 1257 << Name << RD; 1258 1259 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end(); 1260 F != FEnd; ++F) { 1261 Diag((*F)->getLocation(), 1262 diag::note_delete_member_function_declared_here) 1263 << Name; 1264 } 1265 1266 return true; 1267 } 1268 1269 // Look for a global declaration. 1270 DeclareGlobalNewDelete(); 1271 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 1272 1273 CXXNullPtrLiteralExpr Null(Context.VoidPtrTy, SourceLocation()); 1274 Expr* DeallocArgs[1]; 1275 DeallocArgs[0] = &Null; 1276 if (FindAllocationOverload(StartLoc, SourceRange(), Name, 1277 DeallocArgs, 1, TUDecl, /*AllowMissing=*/false, 1278 Operator)) 1279 return true; 1280 1281 assert(Operator && "Did not find a deallocation function!"); 1282 return false; 1283} 1284 1285/// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in: 1286/// @code ::delete ptr; @endcode 1287/// or 1288/// @code delete [] ptr; @endcode 1289Action::OwningExprResult 1290Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, 1291 bool ArrayForm, ExprArg Operand) { 1292 // C++ [expr.delete]p1: 1293 // The operand shall have a pointer type, or a class type having a single 1294 // conversion function to a pointer type. The result has type void. 1295 // 1296 // DR599 amends "pointer type" to "pointer to object type" in both cases. 1297 1298 FunctionDecl *OperatorDelete = 0; 1299 1300 Expr *Ex = (Expr *)Operand.get(); 1301 if (!Ex->isTypeDependent()) { 1302 QualType Type = Ex->getType(); 1303 1304 if (const RecordType *Record = Type->getAs<RecordType>()) { 1305 llvm::SmallVector<CXXConversionDecl*, 4> ObjectPtrConversions; 1306 1307 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); 1308 const UnresolvedSetImpl *Conversions = RD->getVisibleConversionFunctions(); 1309 for (UnresolvedSetImpl::iterator I = Conversions->begin(), 1310 E = Conversions->end(); I != E; ++I) { 1311 NamedDecl *D = I.getDecl(); 1312 if (isa<UsingShadowDecl>(D)) 1313 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 1314 1315 // Skip over templated conversion functions; they aren't considered. 1316 if (isa<FunctionTemplateDecl>(D)) 1317 continue; 1318 1319 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D); 1320 1321 QualType ConvType = Conv->getConversionType().getNonReferenceType(); 1322 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>()) 1323 if (ConvPtrType->getPointeeType()->isObjectType()) 1324 ObjectPtrConversions.push_back(Conv); 1325 } 1326 if (ObjectPtrConversions.size() == 1) { 1327 // We have a single conversion to a pointer-to-object type. Perform 1328 // that conversion. 1329 // TODO: don't redo the conversion calculation. 1330 Operand.release(); 1331 if (!PerformImplicitConversion(Ex, 1332 ObjectPtrConversions.front()->getConversionType(), 1333 AA_Converting)) { 1334 Operand = Owned(Ex); 1335 Type = Ex->getType(); 1336 } 1337 } 1338 else if (ObjectPtrConversions.size() > 1) { 1339 Diag(StartLoc, diag::err_ambiguous_delete_operand) 1340 << Type << Ex->getSourceRange(); 1341 for (unsigned i= 0; i < ObjectPtrConversions.size(); i++) 1342 NoteOverloadCandidate(ObjectPtrConversions[i]); 1343 return ExprError(); 1344 } 1345 } 1346 1347 if (!Type->isPointerType()) 1348 return ExprError(Diag(StartLoc, diag::err_delete_operand) 1349 << Type << Ex->getSourceRange()); 1350 1351 QualType Pointee = Type->getAs<PointerType>()->getPointeeType(); 1352 if (Pointee->isFunctionType() || Pointee->isVoidType()) 1353 return ExprError(Diag(StartLoc, diag::err_delete_operand) 1354 << Type << Ex->getSourceRange()); 1355 else if (!Pointee->isDependentType() && 1356 RequireCompleteType(StartLoc, Pointee, 1357 PDiag(diag::warn_delete_incomplete) 1358 << Ex->getSourceRange())) 1359 return ExprError(); 1360 1361 // C++ [expr.delete]p2: 1362 // [Note: a pointer to a const type can be the operand of a 1363 // delete-expression; it is not necessary to cast away the constness 1364 // (5.2.11) of the pointer expression before it is used as the operand 1365 // of the delete-expression. ] 1366 ImpCastExprToType(Ex, Context.getPointerType(Context.VoidTy), 1367 CastExpr::CK_NoOp); 1368 1369 // Update the operand. 1370 Operand.take(); 1371 Operand = ExprArg(*this, Ex); 1372 1373 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName( 1374 ArrayForm ? OO_Array_Delete : OO_Delete); 1375 1376 if (const RecordType *RT = Pointee->getAs<RecordType>()) { 1377 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1378 1379 if (!UseGlobal && 1380 FindDeallocationFunction(StartLoc, RD, DeleteName, OperatorDelete)) 1381 return ExprError(); 1382 1383 if (!RD->hasTrivialDestructor()) 1384 if (const CXXDestructorDecl *Dtor = RD->getDestructor(Context)) 1385 MarkDeclarationReferenced(StartLoc, 1386 const_cast<CXXDestructorDecl*>(Dtor)); 1387 } 1388 1389 if (!OperatorDelete) { 1390 // Look for a global declaration. 1391 DeclareGlobalNewDelete(); 1392 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 1393 if (FindAllocationOverload(StartLoc, SourceRange(), DeleteName, 1394 &Ex, 1, TUDecl, /*AllowMissing=*/false, 1395 OperatorDelete)) 1396 return ExprError(); 1397 } 1398 1399 // FIXME: Check access and ambiguity of operator delete and destructor. 1400 } 1401 1402 Operand.release(); 1403 return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm, 1404 OperatorDelete, Ex, StartLoc)); 1405} 1406 1407/// \brief Check the use of the given variable as a C++ condition in an if, 1408/// while, do-while, or switch statement. 1409Action::OwningExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar) { 1410 QualType T = ConditionVar->getType(); 1411 1412 // C++ [stmt.select]p2: 1413 // The declarator shall not specify a function or an array. 1414 if (T->isFunctionType()) 1415 return ExprError(Diag(ConditionVar->getLocation(), 1416 diag::err_invalid_use_of_function_type) 1417 << ConditionVar->getSourceRange()); 1418 else if (T->isArrayType()) 1419 return ExprError(Diag(ConditionVar->getLocation(), 1420 diag::err_invalid_use_of_array_type) 1421 << ConditionVar->getSourceRange()); 1422 1423 return Owned(DeclRefExpr::Create(Context, 0, SourceRange(), ConditionVar, 1424 ConditionVar->getLocation(), 1425 ConditionVar->getType().getNonReferenceType())); 1426} 1427 1428/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid. 1429bool Sema::CheckCXXBooleanCondition(Expr *&CondExpr) { 1430 // C++ 6.4p4: 1431 // The value of a condition that is an initialized declaration in a statement 1432 // other than a switch statement is the value of the declared variable 1433 // implicitly converted to type bool. If that conversion is ill-formed, the 1434 // program is ill-formed. 1435 // The value of a condition that is an expression is the value of the 1436 // expression, implicitly converted to bool. 1437 // 1438 return PerformContextuallyConvertToBool(CondExpr); 1439} 1440 1441/// Helper function to determine whether this is the (deprecated) C++ 1442/// conversion from a string literal to a pointer to non-const char or 1443/// non-const wchar_t (for narrow and wide string literals, 1444/// respectively). 1445bool 1446Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) { 1447 // Look inside the implicit cast, if it exists. 1448 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From)) 1449 From = Cast->getSubExpr(); 1450 1451 // A string literal (2.13.4) that is not a wide string literal can 1452 // be converted to an rvalue of type "pointer to char"; a wide 1453 // string literal can be converted to an rvalue of type "pointer 1454 // to wchar_t" (C++ 4.2p2). 1455 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From)) 1456 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) 1457 if (const BuiltinType *ToPointeeType 1458 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) { 1459 // This conversion is considered only when there is an 1460 // explicit appropriate pointer target type (C++ 4.2p2). 1461 if (!ToPtrType->getPointeeType().hasQualifiers() && 1462 ((StrLit->isWide() && ToPointeeType->isWideCharType()) || 1463 (!StrLit->isWide() && 1464 (ToPointeeType->getKind() == BuiltinType::Char_U || 1465 ToPointeeType->getKind() == BuiltinType::Char_S)))) 1466 return true; 1467 } 1468 1469 return false; 1470} 1471 1472/// PerformImplicitConversion - Perform an implicit conversion of the 1473/// expression From to the type ToType. Returns true if there was an 1474/// error, false otherwise. The expression From is replaced with the 1475/// converted expression. Flavor is the kind of conversion we're 1476/// performing, used in the error message. If @p AllowExplicit, 1477/// explicit user-defined conversions are permitted. @p Elidable should be true 1478/// when called for copies which may be elided (C++ 12.8p15). C++0x overload 1479/// resolution works differently in that case. 1480bool 1481Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1482 AssignmentAction Action, bool AllowExplicit, 1483 bool Elidable) { 1484 ImplicitConversionSequence ICS; 1485 return PerformImplicitConversion(From, ToType, Action, AllowExplicit, 1486 Elidable, ICS); 1487} 1488 1489bool 1490Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1491 AssignmentAction Action, bool AllowExplicit, 1492 bool Elidable, 1493 ImplicitConversionSequence& ICS) { 1494 ICS.setBad(BadConversionSequence::no_conversion, From, ToType); 1495 if (Elidable && getLangOptions().CPlusPlus0x) { 1496 ICS = TryImplicitConversion(From, ToType, 1497 /*SuppressUserConversions=*/false, 1498 AllowExplicit, 1499 /*ForceRValue=*/true, 1500 /*InOverloadResolution=*/false); 1501 } 1502 if (ICS.isBad()) { 1503 ICS = TryImplicitConversion(From, ToType, 1504 /*SuppressUserConversions=*/false, 1505 AllowExplicit, 1506 /*ForceRValue=*/false, 1507 /*InOverloadResolution=*/false); 1508 } 1509 return PerformImplicitConversion(From, ToType, ICS, Action); 1510} 1511 1512/// PerformImplicitConversion - Perform an implicit conversion of the 1513/// expression From to the type ToType using the pre-computed implicit 1514/// conversion sequence ICS. Returns true if there was an error, false 1515/// otherwise. The expression From is replaced with the converted 1516/// expression. Action is the kind of conversion we're performing, 1517/// used in the error message. 1518bool 1519Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1520 const ImplicitConversionSequence &ICS, 1521 AssignmentAction Action, bool IgnoreBaseAccess) { 1522 switch (ICS.getKind()) { 1523 case ImplicitConversionSequence::StandardConversion: 1524 if (PerformImplicitConversion(From, ToType, ICS.Standard, Action, 1525 IgnoreBaseAccess)) 1526 return true; 1527 break; 1528 1529 case ImplicitConversionSequence::UserDefinedConversion: { 1530 1531 FunctionDecl *FD = ICS.UserDefined.ConversionFunction; 1532 CastExpr::CastKind CastKind = CastExpr::CK_Unknown; 1533 QualType BeforeToType; 1534 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) { 1535 CastKind = CastExpr::CK_UserDefinedConversion; 1536 1537 // If the user-defined conversion is specified by a conversion function, 1538 // the initial standard conversion sequence converts the source type to 1539 // the implicit object parameter of the conversion function. 1540 BeforeToType = Context.getTagDeclType(Conv->getParent()); 1541 } else if (const CXXConstructorDecl *Ctor = 1542 dyn_cast<CXXConstructorDecl>(FD)) { 1543 CastKind = CastExpr::CK_ConstructorConversion; 1544 // Do no conversion if dealing with ... for the first conversion. 1545 if (!ICS.UserDefined.EllipsisConversion) { 1546 // If the user-defined conversion is specified by a constructor, the 1547 // initial standard conversion sequence converts the source type to the 1548 // type required by the argument of the constructor 1549 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType(); 1550 } 1551 } 1552 else 1553 assert(0 && "Unknown conversion function kind!"); 1554 // Whatch out for elipsis conversion. 1555 if (!ICS.UserDefined.EllipsisConversion) { 1556 if (PerformImplicitConversion(From, BeforeToType, 1557 ICS.UserDefined.Before, AA_Converting, 1558 IgnoreBaseAccess)) 1559 return true; 1560 } 1561 1562 OwningExprResult CastArg 1563 = BuildCXXCastArgument(From->getLocStart(), 1564 ToType.getNonReferenceType(), 1565 CastKind, cast<CXXMethodDecl>(FD), 1566 Owned(From)); 1567 1568 if (CastArg.isInvalid()) 1569 return true; 1570 1571 From = CastArg.takeAs<Expr>(); 1572 1573 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After, 1574 AA_Converting, IgnoreBaseAccess); 1575 } 1576 1577 case ImplicitConversionSequence::AmbiguousConversion: 1578 DiagnoseAmbiguousConversion(ICS, From->getExprLoc(), 1579 PDiag(diag::err_typecheck_ambiguous_condition) 1580 << From->getSourceRange()); 1581 return true; 1582 1583 case ImplicitConversionSequence::EllipsisConversion: 1584 assert(false && "Cannot perform an ellipsis conversion"); 1585 return false; 1586 1587 case ImplicitConversionSequence::BadConversion: 1588 return true; 1589 } 1590 1591 // Everything went well. 1592 return false; 1593} 1594 1595/// PerformImplicitConversion - Perform an implicit conversion of the 1596/// expression From to the type ToType by following the standard 1597/// conversion sequence SCS. Returns true if there was an error, false 1598/// otherwise. The expression From is replaced with the converted 1599/// expression. Flavor is the context in which we're performing this 1600/// conversion, for use in error messages. 1601bool 1602Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1603 const StandardConversionSequence& SCS, 1604 AssignmentAction Action, bool IgnoreBaseAccess) { 1605 // Overall FIXME: we are recomputing too many types here and doing far too 1606 // much extra work. What this means is that we need to keep track of more 1607 // information that is computed when we try the implicit conversion initially, 1608 // so that we don't need to recompute anything here. 1609 QualType FromType = From->getType(); 1610 1611 if (SCS.CopyConstructor) { 1612 // FIXME: When can ToType be a reference type? 1613 assert(!ToType->isReferenceType()); 1614 if (SCS.Second == ICK_Derived_To_Base) { 1615 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this); 1616 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor), 1617 MultiExprArg(*this, (void **)&From, 1), 1618 /*FIXME:ConstructLoc*/SourceLocation(), 1619 ConstructorArgs)) 1620 return true; 1621 OwningExprResult FromResult = 1622 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 1623 ToType, SCS.CopyConstructor, 1624 move_arg(ConstructorArgs)); 1625 if (FromResult.isInvalid()) 1626 return true; 1627 From = FromResult.takeAs<Expr>(); 1628 return false; 1629 } 1630 OwningExprResult FromResult = 1631 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 1632 ToType, SCS.CopyConstructor, 1633 MultiExprArg(*this, (void**)&From, 1)); 1634 1635 if (FromResult.isInvalid()) 1636 return true; 1637 1638 From = FromResult.takeAs<Expr>(); 1639 return false; 1640 } 1641 1642 // Perform the first implicit conversion. 1643 switch (SCS.First) { 1644 case ICK_Identity: 1645 case ICK_Lvalue_To_Rvalue: 1646 // Nothing to do. 1647 break; 1648 1649 case ICK_Array_To_Pointer: 1650 FromType = Context.getArrayDecayedType(FromType); 1651 ImpCastExprToType(From, FromType, CastExpr::CK_ArrayToPointerDecay); 1652 break; 1653 1654 case ICK_Function_To_Pointer: 1655 if (Context.getCanonicalType(FromType) == Context.OverloadTy) { 1656 DeclAccessPair Found; 1657 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, 1658 true, Found); 1659 if (!Fn) 1660 return true; 1661 1662 if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin())) 1663 return true; 1664 1665 From = FixOverloadedFunctionReference(From, Found, Fn); 1666 FromType = From->getType(); 1667 1668 // If there's already an address-of operator in the expression, we have 1669 // the right type already, and the code below would just introduce an 1670 // invalid additional pointer level. 1671 if (FromType->isPointerType() || FromType->isMemberFunctionPointerType()) 1672 break; 1673 } 1674 FromType = Context.getPointerType(FromType); 1675 ImpCastExprToType(From, FromType, CastExpr::CK_FunctionToPointerDecay); 1676 break; 1677 1678 default: 1679 assert(false && "Improper first standard conversion"); 1680 break; 1681 } 1682 1683 // Perform the second implicit conversion 1684 switch (SCS.Second) { 1685 case ICK_Identity: 1686 // If both sides are functions (or pointers/references to them), there could 1687 // be incompatible exception declarations. 1688 if (CheckExceptionSpecCompatibility(From, ToType)) 1689 return true; 1690 // Nothing else to do. 1691 break; 1692 1693 case ICK_NoReturn_Adjustment: 1694 // If both sides are functions (or pointers/references to them), there could 1695 // be incompatible exception declarations. 1696 if (CheckExceptionSpecCompatibility(From, ToType)) 1697 return true; 1698 1699 ImpCastExprToType(From, Context.getNoReturnType(From->getType(), false), 1700 CastExpr::CK_NoOp); 1701 break; 1702 1703 case ICK_Integral_Promotion: 1704 case ICK_Integral_Conversion: 1705 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralCast); 1706 break; 1707 1708 case ICK_Floating_Promotion: 1709 case ICK_Floating_Conversion: 1710 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingCast); 1711 break; 1712 1713 case ICK_Complex_Promotion: 1714 case ICK_Complex_Conversion: 1715 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown); 1716 break; 1717 1718 case ICK_Floating_Integral: 1719 if (ToType->isFloatingType()) 1720 ImpCastExprToType(From, ToType, CastExpr::CK_IntegralToFloating); 1721 else 1722 ImpCastExprToType(From, ToType, CastExpr::CK_FloatingToIntegral); 1723 break; 1724 1725 case ICK_Complex_Real: 1726 ImpCastExprToType(From, ToType, CastExpr::CK_Unknown); 1727 break; 1728 1729 case ICK_Compatible_Conversion: 1730 ImpCastExprToType(From, ToType, CastExpr::CK_NoOp); 1731 break; 1732 1733 case ICK_Pointer_Conversion: { 1734 if (SCS.IncompatibleObjC) { 1735 // Diagnose incompatible Objective-C conversions 1736 Diag(From->getSourceRange().getBegin(), 1737 diag::ext_typecheck_convert_incompatible_pointer) 1738 << From->getType() << ToType << Action 1739 << From->getSourceRange(); 1740 } 1741 1742 1743 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1744 if (CheckPointerConversion(From, ToType, Kind, IgnoreBaseAccess)) 1745 return true; 1746 ImpCastExprToType(From, ToType, Kind); 1747 break; 1748 } 1749 1750 case ICK_Pointer_Member: { 1751 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1752 if (CheckMemberPointerConversion(From, ToType, Kind, IgnoreBaseAccess)) 1753 return true; 1754 if (CheckExceptionSpecCompatibility(From, ToType)) 1755 return true; 1756 ImpCastExprToType(From, ToType, Kind); 1757 break; 1758 } 1759 case ICK_Boolean_Conversion: { 1760 CastExpr::CastKind Kind = CastExpr::CK_Unknown; 1761 if (FromType->isMemberPointerType()) 1762 Kind = CastExpr::CK_MemberPointerToBoolean; 1763 1764 ImpCastExprToType(From, Context.BoolTy, Kind); 1765 break; 1766 } 1767 1768 case ICK_Derived_To_Base: 1769 if (CheckDerivedToBaseConversion(From->getType(), 1770 ToType.getNonReferenceType(), 1771 From->getLocStart(), 1772 From->getSourceRange(), 1773 IgnoreBaseAccess)) 1774 return true; 1775 ImpCastExprToType(From, ToType.getNonReferenceType(), 1776 CastExpr::CK_DerivedToBase); 1777 break; 1778 1779 default: 1780 assert(false && "Improper second standard conversion"); 1781 break; 1782 } 1783 1784 switch (SCS.Third) { 1785 case ICK_Identity: 1786 // Nothing to do. 1787 break; 1788 1789 case ICK_Qualification: 1790 // FIXME: Not sure about lvalue vs rvalue here in the presence of rvalue 1791 // references. 1792 ImpCastExprToType(From, ToType.getNonReferenceType(), 1793 CastExpr::CK_NoOp, 1794 ToType->isLValueReferenceType()); 1795 1796 if (SCS.DeprecatedStringLiteralToCharPtr) 1797 Diag(From->getLocStart(), diag::warn_deprecated_string_literal_conversion) 1798 << ToType.getNonReferenceType(); 1799 1800 break; 1801 1802 default: 1803 assert(false && "Improper second standard conversion"); 1804 break; 1805 } 1806 1807 return false; 1808} 1809 1810Sema::OwningExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait OTT, 1811 SourceLocation KWLoc, 1812 SourceLocation LParen, 1813 TypeTy *Ty, 1814 SourceLocation RParen) { 1815 QualType T = GetTypeFromParser(Ty); 1816 1817 // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html 1818 // all traits except __is_class, __is_enum and __is_union require a the type 1819 // to be complete. 1820 if (OTT != UTT_IsClass && OTT != UTT_IsEnum && OTT != UTT_IsUnion) { 1821 if (RequireCompleteType(KWLoc, T, 1822 diag::err_incomplete_type_used_in_type_trait_expr)) 1823 return ExprError(); 1824 } 1825 1826 // There is no point in eagerly computing the value. The traits are designed 1827 // to be used from type trait templates, so Ty will be a template parameter 1828 // 99% of the time. 1829 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, OTT, T, 1830 RParen, Context.BoolTy)); 1831} 1832 1833QualType Sema::CheckPointerToMemberOperands( 1834 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isIndirect) { 1835 const char *OpSpelling = isIndirect ? "->*" : ".*"; 1836 // C++ 5.5p2 1837 // The binary operator .* [p3: ->*] binds its second operand, which shall 1838 // be of type "pointer to member of T" (where T is a completely-defined 1839 // class type) [...] 1840 QualType RType = rex->getType(); 1841 const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>(); 1842 if (!MemPtr) { 1843 Diag(Loc, diag::err_bad_memptr_rhs) 1844 << OpSpelling << RType << rex->getSourceRange(); 1845 return QualType(); 1846 } 1847 1848 QualType Class(MemPtr->getClass(), 0); 1849 1850 // C++ 5.5p2 1851 // [...] to its first operand, which shall be of class T or of a class of 1852 // which T is an unambiguous and accessible base class. [p3: a pointer to 1853 // such a class] 1854 QualType LType = lex->getType(); 1855 if (isIndirect) { 1856 if (const PointerType *Ptr = LType->getAs<PointerType>()) 1857 LType = Ptr->getPointeeType().getNonReferenceType(); 1858 else { 1859 Diag(Loc, diag::err_bad_memptr_lhs) 1860 << OpSpelling << 1 << LType 1861 << FixItHint::CreateReplacement(SourceRange(Loc), ".*"); 1862 return QualType(); 1863 } 1864 } 1865 1866 if (!Context.hasSameUnqualifiedType(Class, LType)) { 1867 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false, 1868 /*DetectVirtual=*/false); 1869 // FIXME: Would it be useful to print full ambiguity paths, or is that 1870 // overkill? 1871 if (!IsDerivedFrom(LType, Class, Paths) || 1872 Paths.isAmbiguous(Context.getCanonicalType(Class))) { 1873 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling 1874 << (int)isIndirect << lex->getType(); 1875 return QualType(); 1876 } 1877 // Cast LHS to type of use. 1878 QualType UseType = isIndirect ? Context.getPointerType(Class) : Class; 1879 bool isLValue = !isIndirect && lex->isLvalue(Context) == Expr::LV_Valid; 1880 ImpCastExprToType(lex, UseType, CastExpr::CK_DerivedToBase, isLValue); 1881 } 1882 1883 if (isa<CXXZeroInitValueExpr>(rex->IgnoreParens())) { 1884 // Diagnose use of pointer-to-member type which when used as 1885 // the functional cast in a pointer-to-member expression. 1886 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect; 1887 return QualType(); 1888 } 1889 // C++ 5.5p2 1890 // The result is an object or a function of the type specified by the 1891 // second operand. 1892 // The cv qualifiers are the union of those in the pointer and the left side, 1893 // in accordance with 5.5p5 and 5.2.5. 1894 // FIXME: This returns a dereferenced member function pointer as a normal 1895 // function type. However, the only operation valid on such functions is 1896 // calling them. There's also a GCC extension to get a function pointer to the 1897 // thing, which is another complication, because this type - unlike the type 1898 // that is the result of this expression - takes the class as the first 1899 // argument. 1900 // We probably need a "MemberFunctionClosureType" or something like that. 1901 QualType Result = MemPtr->getPointeeType(); 1902 Result = Context.getCVRQualifiedType(Result, LType.getCVRQualifiers()); 1903 return Result; 1904} 1905 1906/// \brief Try to convert a type to another according to C++0x 5.16p3. 1907/// 1908/// This is part of the parameter validation for the ? operator. If either 1909/// value operand is a class type, the two operands are attempted to be 1910/// converted to each other. This function does the conversion in one direction. 1911/// It returns true if the program is ill-formed and has already been diagnosed 1912/// as such. 1913static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, 1914 SourceLocation QuestionLoc, 1915 bool &HaveConversion, 1916 QualType &ToType) { 1917 HaveConversion = false; 1918 ToType = To->getType(); 1919 1920 InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(), 1921 SourceLocation()); 1922 // C++0x 5.16p3 1923 // The process for determining whether an operand expression E1 of type T1 1924 // can be converted to match an operand expression E2 of type T2 is defined 1925 // as follows: 1926 // -- If E2 is an lvalue: 1927 bool ToIsLvalue = (To->isLvalue(Self.Context) == Expr::LV_Valid); 1928 if (ToIsLvalue) { 1929 // E1 can be converted to match E2 if E1 can be implicitly converted to 1930 // type "lvalue reference to T2", subject to the constraint that in the 1931 // conversion the reference must bind directly to E1. 1932 QualType T = Self.Context.getLValueReferenceType(ToType); 1933 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 1934 1935 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 1936 if (InitSeq.isDirectReferenceBinding()) { 1937 ToType = T; 1938 HaveConversion = true; 1939 return false; 1940 } 1941 1942 if (InitSeq.isAmbiguous()) 1943 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 1944 } 1945 1946 // -- If E2 is an rvalue, or if the conversion above cannot be done: 1947 // -- if E1 and E2 have class type, and the underlying class types are 1948 // the same or one is a base class of the other: 1949 QualType FTy = From->getType(); 1950 QualType TTy = To->getType(); 1951 const RecordType *FRec = FTy->getAs<RecordType>(); 1952 const RecordType *TRec = TTy->getAs<RecordType>(); 1953 bool FDerivedFromT = FRec && TRec && FRec != TRec && 1954 Self.IsDerivedFrom(FTy, TTy); 1955 if (FRec && TRec && 1956 (FRec == TRec || FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) { 1957 // E1 can be converted to match E2 if the class of T2 is the 1958 // same type as, or a base class of, the class of T1, and 1959 // [cv2 > cv1]. 1960 if (FRec == TRec || FDerivedFromT) { 1961 if (TTy.isAtLeastAsQualifiedAs(FTy)) { 1962 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 1963 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 1964 if (InitSeq.getKind() != InitializationSequence::FailedSequence) { 1965 HaveConversion = true; 1966 return false; 1967 } 1968 1969 if (InitSeq.isAmbiguous()) 1970 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 1971 } 1972 } 1973 1974 return false; 1975 } 1976 1977 // -- Otherwise: E1 can be converted to match E2 if E1 can be 1978 // implicitly converted to the type that expression E2 would have 1979 // if E2 were converted to an rvalue (or the type it has, if E2 is 1980 // an rvalue). 1981 // 1982 // This actually refers very narrowly to the lvalue-to-rvalue conversion, not 1983 // to the array-to-pointer or function-to-pointer conversions. 1984 if (!TTy->getAs<TagType>()) 1985 TTy = TTy.getUnqualifiedType(); 1986 1987 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 1988 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 1989 HaveConversion = InitSeq.getKind() != InitializationSequence::FailedSequence; 1990 ToType = TTy; 1991 if (InitSeq.isAmbiguous()) 1992 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 1993 1994 return false; 1995} 1996 1997/// \brief Try to find a common type for two according to C++0x 5.16p5. 1998/// 1999/// This is part of the parameter validation for the ? operator. If either 2000/// value operand is a class type, overload resolution is used to find a 2001/// conversion to a common type. 2002static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS, 2003 SourceLocation Loc) { 2004 Expr *Args[2] = { LHS, RHS }; 2005 OverloadCandidateSet CandidateSet(Loc); 2006 Self.AddBuiltinOperatorCandidates(OO_Conditional, Loc, Args, 2, CandidateSet); 2007 2008 OverloadCandidateSet::iterator Best; 2009 switch (Self.BestViableFunction(CandidateSet, Loc, Best)) { 2010 case OR_Success: 2011 // We found a match. Perform the conversions on the arguments and move on. 2012 if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0], 2013 Best->Conversions[0], Sema::AA_Converting) || 2014 Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1], 2015 Best->Conversions[1], Sema::AA_Converting)) 2016 break; 2017 return false; 2018 2019 case OR_No_Viable_Function: 2020 Self.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 2021 << LHS->getType() << RHS->getType() 2022 << LHS->getSourceRange() << RHS->getSourceRange(); 2023 return true; 2024 2025 case OR_Ambiguous: 2026 Self.Diag(Loc, diag::err_conditional_ambiguous_ovl) 2027 << LHS->getType() << RHS->getType() 2028 << LHS->getSourceRange() << RHS->getSourceRange(); 2029 // FIXME: Print the possible common types by printing the return types of 2030 // the viable candidates. 2031 break; 2032 2033 case OR_Deleted: 2034 assert(false && "Conditional operator has only built-in overloads"); 2035 break; 2036 } 2037 return true; 2038} 2039 2040/// \brief Perform an "extended" implicit conversion as returned by 2041/// TryClassUnification. 2042static bool ConvertForConditional(Sema &Self, Expr *&E, QualType T) { 2043 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 2044 InitializationKind Kind = InitializationKind::CreateCopy(E->getLocStart(), 2045 SourceLocation()); 2046 InitializationSequence InitSeq(Self, Entity, Kind, &E, 1); 2047 Sema::OwningExprResult Result = InitSeq.Perform(Self, Entity, Kind, 2048 Sema::MultiExprArg(Self, (void **)&E, 1)); 2049 if (Result.isInvalid()) 2050 return true; 2051 2052 E = Result.takeAs<Expr>(); 2053 return false; 2054} 2055 2056/// \brief Check the operands of ?: under C++ semantics. 2057/// 2058/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y 2059/// extension. In this case, LHS == Cond. (But they're not aliases.) 2060QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, 2061 SourceLocation QuestionLoc) { 2062 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++ 2063 // interface pointers. 2064 2065 // C++0x 5.16p1 2066 // The first expression is contextually converted to bool. 2067 if (!Cond->isTypeDependent()) { 2068 if (CheckCXXBooleanCondition(Cond)) 2069 return QualType(); 2070 } 2071 2072 // Either of the arguments dependent? 2073 if (LHS->isTypeDependent() || RHS->isTypeDependent()) 2074 return Context.DependentTy; 2075 2076 CheckSignCompare(LHS, RHS, QuestionLoc); 2077 2078 // C++0x 5.16p2 2079 // If either the second or the third operand has type (cv) void, ... 2080 QualType LTy = LHS->getType(); 2081 QualType RTy = RHS->getType(); 2082 bool LVoid = LTy->isVoidType(); 2083 bool RVoid = RTy->isVoidType(); 2084 if (LVoid || RVoid) { 2085 // ... then the [l2r] conversions are performed on the second and third 2086 // operands ... 2087 DefaultFunctionArrayLvalueConversion(LHS); 2088 DefaultFunctionArrayLvalueConversion(RHS); 2089 LTy = LHS->getType(); 2090 RTy = RHS->getType(); 2091 2092 // ... and one of the following shall hold: 2093 // -- The second or the third operand (but not both) is a throw- 2094 // expression; the result is of the type of the other and is an rvalue. 2095 bool LThrow = isa<CXXThrowExpr>(LHS); 2096 bool RThrow = isa<CXXThrowExpr>(RHS); 2097 if (LThrow && !RThrow) 2098 return RTy; 2099 if (RThrow && !LThrow) 2100 return LTy; 2101 2102 // -- Both the second and third operands have type void; the result is of 2103 // type void and is an rvalue. 2104 if (LVoid && RVoid) 2105 return Context.VoidTy; 2106 2107 // Neither holds, error. 2108 Diag(QuestionLoc, diag::err_conditional_void_nonvoid) 2109 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1) 2110 << LHS->getSourceRange() << RHS->getSourceRange(); 2111 return QualType(); 2112 } 2113 2114 // Neither is void. 2115 2116 // C++0x 5.16p3 2117 // Otherwise, if the second and third operand have different types, and 2118 // either has (cv) class type, and attempt is made to convert each of those 2119 // operands to the other. 2120 if (!Context.hasSameType(LTy, RTy) && 2121 (LTy->isRecordType() || RTy->isRecordType())) { 2122 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft; 2123 // These return true if a single direction is already ambiguous. 2124 QualType L2RType, R2LType; 2125 bool HaveL2R, HaveR2L; 2126 if (TryClassUnification(*this, LHS, RHS, QuestionLoc, HaveL2R, L2RType)) 2127 return QualType(); 2128 if (TryClassUnification(*this, RHS, LHS, QuestionLoc, HaveR2L, R2LType)) 2129 return QualType(); 2130 2131 // If both can be converted, [...] the program is ill-formed. 2132 if (HaveL2R && HaveR2L) { 2133 Diag(QuestionLoc, diag::err_conditional_ambiguous) 2134 << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange(); 2135 return QualType(); 2136 } 2137 2138 // If exactly one conversion is possible, that conversion is applied to 2139 // the chosen operand and the converted operands are used in place of the 2140 // original operands for the remainder of this section. 2141 if (HaveL2R) { 2142 if (ConvertForConditional(*this, LHS, L2RType)) 2143 return QualType(); 2144 LTy = LHS->getType(); 2145 } else if (HaveR2L) { 2146 if (ConvertForConditional(*this, RHS, R2LType)) 2147 return QualType(); 2148 RTy = RHS->getType(); 2149 } 2150 } 2151 2152 // C++0x 5.16p4 2153 // If the second and third operands are lvalues and have the same type, 2154 // the result is of that type [...] 2155 bool Same = Context.hasSameType(LTy, RTy); 2156 if (Same && LHS->isLvalue(Context) == Expr::LV_Valid && 2157 RHS->isLvalue(Context) == Expr::LV_Valid) 2158 return LTy; 2159 2160 // C++0x 5.16p5 2161 // Otherwise, the result is an rvalue. If the second and third operands 2162 // do not have the same type, and either has (cv) class type, ... 2163 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) { 2164 // ... overload resolution is used to determine the conversions (if any) 2165 // to be applied to the operands. If the overload resolution fails, the 2166 // program is ill-formed. 2167 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc)) 2168 return QualType(); 2169 } 2170 2171 // C++0x 5.16p6 2172 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard 2173 // conversions are performed on the second and third operands. 2174 DefaultFunctionArrayLvalueConversion(LHS); 2175 DefaultFunctionArrayLvalueConversion(RHS); 2176 LTy = LHS->getType(); 2177 RTy = RHS->getType(); 2178 2179 // After those conversions, one of the following shall hold: 2180 // -- The second and third operands have the same type; the result 2181 // is of that type. 2182 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) 2183 return LTy; 2184 2185 // -- The second and third operands have arithmetic or enumeration type; 2186 // the usual arithmetic conversions are performed to bring them to a 2187 // common type, and the result is of that type. 2188 if (LTy->isArithmeticType() && RTy->isArithmeticType()) { 2189 UsualArithmeticConversions(LHS, RHS); 2190 return LHS->getType(); 2191 } 2192 2193 // -- The second and third operands have pointer type, or one has pointer 2194 // type and the other is a null pointer constant; pointer conversions 2195 // and qualification conversions are performed to bring them to their 2196 // composite pointer type. The result is of the composite pointer type. 2197 // -- The second and third operands have pointer to member type, or one has 2198 // pointer to member type and the other is a null pointer constant; 2199 // pointer to member conversions and qualification conversions are 2200 // performed to bring them to a common type, whose cv-qualification 2201 // shall match the cv-qualification of either the second or the third 2202 // operand. The result is of the common type. 2203 bool NonStandardCompositeType = false; 2204 QualType Composite = FindCompositePointerType(LHS, RHS, 2205 isSFINAEContext()? 0 : &NonStandardCompositeType); 2206 if (!Composite.isNull()) { 2207 if (NonStandardCompositeType) 2208 Diag(QuestionLoc, 2209 diag::ext_typecheck_cond_incompatible_operands_nonstandard) 2210 << LTy << RTy << Composite 2211 << LHS->getSourceRange() << RHS->getSourceRange(); 2212 2213 return Composite; 2214 } 2215 2216 // Similarly, attempt to find composite type of two objective-c pointers. 2217 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc); 2218 if (!Composite.isNull()) 2219 return Composite; 2220 2221 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 2222 << LHS->getType() << RHS->getType() 2223 << LHS->getSourceRange() << RHS->getSourceRange(); 2224 return QualType(); 2225} 2226 2227/// \brief Find a merged pointer type and convert the two expressions to it. 2228/// 2229/// This finds the composite pointer type (or member pointer type) for @p E1 2230/// and @p E2 according to C++0x 5.9p2. It converts both expressions to this 2231/// type and returns it. 2232/// It does not emit diagnostics. 2233/// 2234/// If \p NonStandardCompositeType is non-NULL, then we are permitted to find 2235/// a non-standard (but still sane) composite type to which both expressions 2236/// can be converted. When such a type is chosen, \c *NonStandardCompositeType 2237/// will be set true. 2238QualType Sema::FindCompositePointerType(Expr *&E1, Expr *&E2, 2239 bool *NonStandardCompositeType) { 2240 if (NonStandardCompositeType) 2241 *NonStandardCompositeType = false; 2242 2243 assert(getLangOptions().CPlusPlus && "This function assumes C++"); 2244 QualType T1 = E1->getType(), T2 = E2->getType(); 2245 2246 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() && 2247 !T2->isAnyPointerType() && !T2->isMemberPointerType()) 2248 return QualType(); 2249 2250 // C++0x 5.9p2 2251 // Pointer conversions and qualification conversions are performed on 2252 // pointer operands to bring them to their composite pointer type. If 2253 // one operand is a null pointer constant, the composite pointer type is 2254 // the type of the other operand. 2255 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 2256 if (T2->isMemberPointerType()) 2257 ImpCastExprToType(E1, T2, CastExpr::CK_NullToMemberPointer); 2258 else 2259 ImpCastExprToType(E1, T2, CastExpr::CK_IntegralToPointer); 2260 return T2; 2261 } 2262 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 2263 if (T1->isMemberPointerType()) 2264 ImpCastExprToType(E2, T1, CastExpr::CK_NullToMemberPointer); 2265 else 2266 ImpCastExprToType(E2, T1, CastExpr::CK_IntegralToPointer); 2267 return T1; 2268 } 2269 2270 // Now both have to be pointers or member pointers. 2271 if ((!T1->isPointerType() && !T1->isMemberPointerType()) || 2272 (!T2->isPointerType() && !T2->isMemberPointerType())) 2273 return QualType(); 2274 2275 // Otherwise, of one of the operands has type "pointer to cv1 void," then 2276 // the other has type "pointer to cv2 T" and the composite pointer type is 2277 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2. 2278 // Otherwise, the composite pointer type is a pointer type similar to the 2279 // type of one of the operands, with a cv-qualification signature that is 2280 // the union of the cv-qualification signatures of the operand types. 2281 // In practice, the first part here is redundant; it's subsumed by the second. 2282 // What we do here is, we build the two possible composite types, and try the 2283 // conversions in both directions. If only one works, or if the two composite 2284 // types are the same, we have succeeded. 2285 // FIXME: extended qualifiers? 2286 typedef llvm::SmallVector<unsigned, 4> QualifierVector; 2287 QualifierVector QualifierUnion; 2288 typedef llvm::SmallVector<std::pair<const Type *, const Type *>, 4> 2289 ContainingClassVector; 2290 ContainingClassVector MemberOfClass; 2291 QualType Composite1 = Context.getCanonicalType(T1), 2292 Composite2 = Context.getCanonicalType(T2); 2293 unsigned NeedConstBefore = 0; 2294 do { 2295 const PointerType *Ptr1, *Ptr2; 2296 if ((Ptr1 = Composite1->getAs<PointerType>()) && 2297 (Ptr2 = Composite2->getAs<PointerType>())) { 2298 Composite1 = Ptr1->getPointeeType(); 2299 Composite2 = Ptr2->getPointeeType(); 2300 2301 // If we're allowed to create a non-standard composite type, keep track 2302 // of where we need to fill in additional 'const' qualifiers. 2303 if (NonStandardCompositeType && 2304 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 2305 NeedConstBefore = QualifierUnion.size(); 2306 2307 QualifierUnion.push_back( 2308 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 2309 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0)); 2310 continue; 2311 } 2312 2313 const MemberPointerType *MemPtr1, *MemPtr2; 2314 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) && 2315 (MemPtr2 = Composite2->getAs<MemberPointerType>())) { 2316 Composite1 = MemPtr1->getPointeeType(); 2317 Composite2 = MemPtr2->getPointeeType(); 2318 2319 // If we're allowed to create a non-standard composite type, keep track 2320 // of where we need to fill in additional 'const' qualifiers. 2321 if (NonStandardCompositeType && 2322 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 2323 NeedConstBefore = QualifierUnion.size(); 2324 2325 QualifierUnion.push_back( 2326 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 2327 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(), 2328 MemPtr2->getClass())); 2329 continue; 2330 } 2331 2332 // FIXME: block pointer types? 2333 2334 // Cannot unwrap any more types. 2335 break; 2336 } while (true); 2337 2338 if (NeedConstBefore && NonStandardCompositeType) { 2339 // Extension: Add 'const' to qualifiers that come before the first qualifier 2340 // mismatch, so that our (non-standard!) composite type meets the 2341 // requirements of C++ [conv.qual]p4 bullet 3. 2342 for (unsigned I = 0; I != NeedConstBefore; ++I) { 2343 if ((QualifierUnion[I] & Qualifiers::Const) == 0) { 2344 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const; 2345 *NonStandardCompositeType = true; 2346 } 2347 } 2348 } 2349 2350 // Rewrap the composites as pointers or member pointers with the union CVRs. 2351 ContainingClassVector::reverse_iterator MOC 2352 = MemberOfClass.rbegin(); 2353 for (QualifierVector::reverse_iterator 2354 I = QualifierUnion.rbegin(), 2355 E = QualifierUnion.rend(); 2356 I != E; (void)++I, ++MOC) { 2357 Qualifiers Quals = Qualifiers::fromCVRMask(*I); 2358 if (MOC->first && MOC->second) { 2359 // Rebuild member pointer type 2360 Composite1 = Context.getMemberPointerType( 2361 Context.getQualifiedType(Composite1, Quals), 2362 MOC->first); 2363 Composite2 = Context.getMemberPointerType( 2364 Context.getQualifiedType(Composite2, Quals), 2365 MOC->second); 2366 } else { 2367 // Rebuild pointer type 2368 Composite1 2369 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals)); 2370 Composite2 2371 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals)); 2372 } 2373 } 2374 2375 ImplicitConversionSequence E1ToC1 = 2376 TryImplicitConversion(E1, Composite1, 2377 /*SuppressUserConversions=*/false, 2378 /*AllowExplicit=*/false, 2379 /*ForceRValue=*/false, 2380 /*InOverloadResolution=*/false); 2381 ImplicitConversionSequence E2ToC1 = 2382 TryImplicitConversion(E2, Composite1, 2383 /*SuppressUserConversions=*/false, 2384 /*AllowExplicit=*/false, 2385 /*ForceRValue=*/false, 2386 /*InOverloadResolution=*/false); 2387 2388 bool ToC2Viable = false; 2389 ImplicitConversionSequence E1ToC2, E2ToC2; 2390 if (Context.getCanonicalType(Composite1) != 2391 Context.getCanonicalType(Composite2)) { 2392 E1ToC2 = TryImplicitConversion(E1, Composite2, 2393 /*SuppressUserConversions=*/false, 2394 /*AllowExplicit=*/false, 2395 /*ForceRValue=*/false, 2396 /*InOverloadResolution=*/false); 2397 E2ToC2 = TryImplicitConversion(E2, Composite2, 2398 /*SuppressUserConversions=*/false, 2399 /*AllowExplicit=*/false, 2400 /*ForceRValue=*/false, 2401 /*InOverloadResolution=*/false); 2402 ToC2Viable = !E1ToC2.isBad() && !E2ToC2.isBad(); 2403 } 2404 2405 bool ToC1Viable = !E1ToC1.isBad() && !E2ToC1.isBad(); 2406 if (ToC1Viable && !ToC2Viable) { 2407 if (!PerformImplicitConversion(E1, Composite1, E1ToC1, Sema::AA_Converting) && 2408 !PerformImplicitConversion(E2, Composite1, E2ToC1, Sema::AA_Converting)) 2409 return Composite1; 2410 } 2411 if (ToC2Viable && !ToC1Viable) { 2412 if (!PerformImplicitConversion(E1, Composite2, E1ToC2, Sema::AA_Converting) && 2413 !PerformImplicitConversion(E2, Composite2, E2ToC2, Sema::AA_Converting)) 2414 return Composite2; 2415 } 2416 return QualType(); 2417} 2418 2419Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) { 2420 if (!Context.getLangOptions().CPlusPlus) 2421 return Owned(E); 2422 2423 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?"); 2424 2425 const RecordType *RT = E->getType()->getAs<RecordType>(); 2426 if (!RT) 2427 return Owned(E); 2428 2429 // If this is the result of a call expression, our source might 2430 // actually be a reference, in which case we shouldn't bind. 2431 if (CallExpr *CE = dyn_cast<CallExpr>(E)) { 2432 QualType Ty = CE->getCallee()->getType(); 2433 if (const PointerType *PT = Ty->getAs<PointerType>()) 2434 Ty = PT->getPointeeType(); 2435 else if (const BlockPointerType *BPT = Ty->getAs<BlockPointerType>()) 2436 Ty = BPT->getPointeeType(); 2437 2438 const FunctionType *FTy = Ty->getAs<FunctionType>(); 2439 if (FTy->getResultType()->isReferenceType()) 2440 return Owned(E); 2441 } 2442 2443 // That should be enough to guarantee that this type is complete. 2444 // If it has a trivial destructor, we can avoid the extra copy. 2445 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 2446 if (RD->hasTrivialDestructor()) 2447 return Owned(E); 2448 2449 CXXTemporary *Temp = CXXTemporary::Create(Context, 2450 RD->getDestructor(Context)); 2451 ExprTemporaries.push_back(Temp); 2452 if (CXXDestructorDecl *Destructor = 2453 const_cast<CXXDestructorDecl*>(RD->getDestructor(Context))) 2454 MarkDeclarationReferenced(E->getExprLoc(), Destructor); 2455 // FIXME: Add the temporary to the temporaries vector. 2456 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E)); 2457} 2458 2459Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr) { 2460 assert(SubExpr && "sub expression can't be null!"); 2461 2462 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 2463 assert(ExprTemporaries.size() >= FirstTemporary); 2464 if (ExprTemporaries.size() == FirstTemporary) 2465 return SubExpr; 2466 2467 Expr *E = CXXExprWithTemporaries::Create(Context, SubExpr, 2468 &ExprTemporaries[FirstTemporary], 2469 ExprTemporaries.size() - FirstTemporary); 2470 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 2471 ExprTemporaries.end()); 2472 2473 return E; 2474} 2475 2476Sema::OwningExprResult 2477Sema::MaybeCreateCXXExprWithTemporaries(OwningExprResult SubExpr) { 2478 if (SubExpr.isInvalid()) 2479 return ExprError(); 2480 2481 return Owned(MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>())); 2482} 2483 2484FullExpr Sema::CreateFullExpr(Expr *SubExpr) { 2485 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 2486 assert(ExprTemporaries.size() >= FirstTemporary); 2487 2488 unsigned NumTemporaries = ExprTemporaries.size() - FirstTemporary; 2489 CXXTemporary **Temporaries = 2490 NumTemporaries == 0 ? 0 : &ExprTemporaries[FirstTemporary]; 2491 2492 FullExpr E = FullExpr::Create(Context, SubExpr, Temporaries, NumTemporaries); 2493 2494 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 2495 ExprTemporaries.end()); 2496 2497 return E; 2498} 2499 2500Sema::OwningExprResult 2501Sema::ActOnStartCXXMemberReference(Scope *S, ExprArg Base, SourceLocation OpLoc, 2502 tok::TokenKind OpKind, TypeTy *&ObjectType, 2503 bool &MayBePseudoDestructor) { 2504 // Since this might be a postfix expression, get rid of ParenListExprs. 2505 Base = MaybeConvertParenListExprToParenExpr(S, move(Base)); 2506 2507 Expr *BaseExpr = (Expr*)Base.get(); 2508 assert(BaseExpr && "no record expansion"); 2509 2510 QualType BaseType = BaseExpr->getType(); 2511 MayBePseudoDestructor = false; 2512 if (BaseType->isDependentType()) { 2513 // If we have a pointer to a dependent type and are using the -> operator, 2514 // the object type is the type that the pointer points to. We might still 2515 // have enough information about that type to do something useful. 2516 if (OpKind == tok::arrow) 2517 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 2518 BaseType = Ptr->getPointeeType(); 2519 2520 ObjectType = BaseType.getAsOpaquePtr(); 2521 MayBePseudoDestructor = true; 2522 return move(Base); 2523 } 2524 2525 // C++ [over.match.oper]p8: 2526 // [...] When operator->returns, the operator-> is applied to the value 2527 // returned, with the original second operand. 2528 if (OpKind == tok::arrow) { 2529 // The set of types we've considered so far. 2530 llvm::SmallPtrSet<CanQualType,8> CTypes; 2531 llvm::SmallVector<SourceLocation, 8> Locations; 2532 CTypes.insert(Context.getCanonicalType(BaseType)); 2533 2534 while (BaseType->isRecordType()) { 2535 Base = BuildOverloadedArrowExpr(S, move(Base), OpLoc); 2536 BaseExpr = (Expr*)Base.get(); 2537 if (BaseExpr == NULL) 2538 return ExprError(); 2539 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(BaseExpr)) 2540 Locations.push_back(OpCall->getDirectCallee()->getLocation()); 2541 BaseType = BaseExpr->getType(); 2542 CanQualType CBaseType = Context.getCanonicalType(BaseType); 2543 if (!CTypes.insert(CBaseType)) { 2544 Diag(OpLoc, diag::err_operator_arrow_circular); 2545 for (unsigned i = 0; i < Locations.size(); i++) 2546 Diag(Locations[i], diag::note_declared_at); 2547 return ExprError(); 2548 } 2549 } 2550 2551 if (BaseType->isPointerType()) 2552 BaseType = BaseType->getPointeeType(); 2553 } 2554 2555 // We could end up with various non-record types here, such as extended 2556 // vector types or Objective-C interfaces. Just return early and let 2557 // ActOnMemberReferenceExpr do the work. 2558 if (!BaseType->isRecordType()) { 2559 // C++ [basic.lookup.classref]p2: 2560 // [...] If the type of the object expression is of pointer to scalar 2561 // type, the unqualified-id is looked up in the context of the complete 2562 // postfix-expression. 2563 // 2564 // This also indicates that we should be parsing a 2565 // pseudo-destructor-name. 2566 ObjectType = 0; 2567 MayBePseudoDestructor = true; 2568 return move(Base); 2569 } 2570 2571 // The object type must be complete (or dependent). 2572 if (!BaseType->isDependentType() && 2573 RequireCompleteType(OpLoc, BaseType, 2574 PDiag(diag::err_incomplete_member_access))) 2575 return ExprError(); 2576 2577 // C++ [basic.lookup.classref]p2: 2578 // If the id-expression in a class member access (5.2.5) is an 2579 // unqualified-id, and the type of the object expression is of a class 2580 // type C (or of pointer to a class type C), the unqualified-id is looked 2581 // up in the scope of class C. [...] 2582 ObjectType = BaseType.getAsOpaquePtr(); 2583 return move(Base); 2584} 2585 2586Sema::OwningExprResult Sema::DiagnoseDtorReference(SourceLocation NameLoc, 2587 ExprArg MemExpr) { 2588 Expr *E = (Expr *) MemExpr.get(); 2589 SourceLocation ExpectedLParenLoc = PP.getLocForEndOfToken(NameLoc); 2590 Diag(E->getLocStart(), diag::err_dtor_expr_without_call) 2591 << isa<CXXPseudoDestructorExpr>(E) 2592 << FixItHint::CreateInsertion(ExpectedLParenLoc, "()"); 2593 2594 return ActOnCallExpr(/*Scope*/ 0, 2595 move(MemExpr), 2596 /*LPLoc*/ ExpectedLParenLoc, 2597 Sema::MultiExprArg(*this, 0, 0), 2598 /*CommaLocs*/ 0, 2599 /*RPLoc*/ ExpectedLParenLoc); 2600} 2601 2602Sema::OwningExprResult Sema::BuildPseudoDestructorExpr(ExprArg Base, 2603 SourceLocation OpLoc, 2604 tok::TokenKind OpKind, 2605 const CXXScopeSpec &SS, 2606 TypeSourceInfo *ScopeTypeInfo, 2607 SourceLocation CCLoc, 2608 SourceLocation TildeLoc, 2609 PseudoDestructorTypeStorage Destructed, 2610 bool HasTrailingLParen) { 2611 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo(); 2612 2613 // C++ [expr.pseudo]p2: 2614 // The left-hand side of the dot operator shall be of scalar type. The 2615 // left-hand side of the arrow operator shall be of pointer to scalar type. 2616 // This scalar type is the object type. 2617 Expr *BaseE = (Expr *)Base.get(); 2618 QualType ObjectType = BaseE->getType(); 2619 if (OpKind == tok::arrow) { 2620 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 2621 ObjectType = Ptr->getPointeeType(); 2622 } else if (!BaseE->isTypeDependent()) { 2623 // The user wrote "p->" when she probably meant "p."; fix it. 2624 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 2625 << ObjectType << true 2626 << FixItHint::CreateReplacement(OpLoc, "."); 2627 if (isSFINAEContext()) 2628 return ExprError(); 2629 2630 OpKind = tok::period; 2631 } 2632 } 2633 2634 if (!ObjectType->isDependentType() && !ObjectType->isScalarType()) { 2635 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar) 2636 << ObjectType << BaseE->getSourceRange(); 2637 return ExprError(); 2638 } 2639 2640 // C++ [expr.pseudo]p2: 2641 // [...] The cv-unqualified versions of the object type and of the type 2642 // designated by the pseudo-destructor-name shall be the same type. 2643 if (DestructedTypeInfo) { 2644 QualType DestructedType = DestructedTypeInfo->getType(); 2645 SourceLocation DestructedTypeStart 2646 = DestructedTypeInfo->getTypeLoc().getSourceRange().getBegin(); 2647 if (!DestructedType->isDependentType() && !ObjectType->isDependentType() && 2648 !Context.hasSameUnqualifiedType(DestructedType, ObjectType)) { 2649 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch) 2650 << ObjectType << DestructedType << BaseE->getSourceRange() 2651 << DestructedTypeInfo->getTypeLoc().getSourceRange(); 2652 2653 // Recover by setting the destructed type to the object type. 2654 DestructedType = ObjectType; 2655 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType, 2656 DestructedTypeStart); 2657 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 2658 } 2659 } 2660 2661 // C++ [expr.pseudo]p2: 2662 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the 2663 // form 2664 // 2665 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name 2666 // 2667 // shall designate the same scalar type. 2668 if (ScopeTypeInfo) { 2669 QualType ScopeType = ScopeTypeInfo->getType(); 2670 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() && 2671 !Context.hasSameType(ScopeType, ObjectType)) { 2672 2673 Diag(ScopeTypeInfo->getTypeLoc().getSourceRange().getBegin(), 2674 diag::err_pseudo_dtor_type_mismatch) 2675 << ObjectType << ScopeType << BaseE->getSourceRange() 2676 << ScopeTypeInfo->getTypeLoc().getSourceRange(); 2677 2678 ScopeType = QualType(); 2679 ScopeTypeInfo = 0; 2680 } 2681 } 2682 2683 OwningExprResult Result 2684 = Owned(new (Context) CXXPseudoDestructorExpr(Context, 2685 Base.takeAs<Expr>(), 2686 OpKind == tok::arrow, 2687 OpLoc, 2688 (NestedNameSpecifier *) SS.getScopeRep(), 2689 SS.getRange(), 2690 ScopeTypeInfo, 2691 CCLoc, 2692 TildeLoc, 2693 Destructed)); 2694 2695 if (HasTrailingLParen) 2696 return move(Result); 2697 2698 return DiagnoseDtorReference(Destructed.getLocation(), move(Result)); 2699} 2700 2701Sema::OwningExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, ExprArg Base, 2702 SourceLocation OpLoc, 2703 tok::TokenKind OpKind, 2704 const CXXScopeSpec &SS, 2705 UnqualifiedId &FirstTypeName, 2706 SourceLocation CCLoc, 2707 SourceLocation TildeLoc, 2708 UnqualifiedId &SecondTypeName, 2709 bool HasTrailingLParen) { 2710 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2711 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) && 2712 "Invalid first type name in pseudo-destructor"); 2713 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2714 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) && 2715 "Invalid second type name in pseudo-destructor"); 2716 2717 Expr *BaseE = (Expr *)Base.get(); 2718 2719 // C++ [expr.pseudo]p2: 2720 // The left-hand side of the dot operator shall be of scalar type. The 2721 // left-hand side of the arrow operator shall be of pointer to scalar type. 2722 // This scalar type is the object type. 2723 QualType ObjectType = BaseE->getType(); 2724 if (OpKind == tok::arrow) { 2725 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 2726 ObjectType = Ptr->getPointeeType(); 2727 } else if (!ObjectType->isDependentType()) { 2728 // The user wrote "p->" when she probably meant "p."; fix it. 2729 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 2730 << ObjectType << true 2731 << FixItHint::CreateReplacement(OpLoc, "."); 2732 if (isSFINAEContext()) 2733 return ExprError(); 2734 2735 OpKind = tok::period; 2736 } 2737 } 2738 2739 // Compute the object type that we should use for name lookup purposes. Only 2740 // record types and dependent types matter. 2741 void *ObjectTypePtrForLookup = 0; 2742 if (!SS.isSet()) { 2743 ObjectTypePtrForLookup = (void *)ObjectType->getAs<RecordType>(); 2744 if (!ObjectTypePtrForLookup && ObjectType->isDependentType()) 2745 ObjectTypePtrForLookup = Context.DependentTy.getAsOpaquePtr(); 2746 } 2747 2748 // Convert the name of the type being destructed (following the ~) into a 2749 // type (with source-location information). 2750 QualType DestructedType; 2751 TypeSourceInfo *DestructedTypeInfo = 0; 2752 PseudoDestructorTypeStorage Destructed; 2753 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) { 2754 TypeTy *T = getTypeName(*SecondTypeName.Identifier, 2755 SecondTypeName.StartLocation, 2756 S, &SS, true, ObjectTypePtrForLookup); 2757 if (!T && 2758 ((SS.isSet() && !computeDeclContext(SS, false)) || 2759 (!SS.isSet() && ObjectType->isDependentType()))) { 2760 // The name of the type being destroyed is a dependent name, and we 2761 // couldn't find anything useful in scope. Just store the identifier and 2762 // it's location, and we'll perform (qualified) name lookup again at 2763 // template instantiation time. 2764 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier, 2765 SecondTypeName.StartLocation); 2766 } else if (!T) { 2767 Diag(SecondTypeName.StartLocation, 2768 diag::err_pseudo_dtor_destructor_non_type) 2769 << SecondTypeName.Identifier << ObjectType; 2770 if (isSFINAEContext()) 2771 return ExprError(); 2772 2773 // Recover by assuming we had the right type all along. 2774 DestructedType = ObjectType; 2775 } else 2776 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo); 2777 } else { 2778 // Resolve the template-id to a type. 2779 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId; 2780 ASTTemplateArgsPtr TemplateArgsPtr(*this, 2781 TemplateId->getTemplateArgs(), 2782 TemplateId->NumArgs); 2783 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template), 2784 TemplateId->TemplateNameLoc, 2785 TemplateId->LAngleLoc, 2786 TemplateArgsPtr, 2787 TemplateId->RAngleLoc); 2788 if (T.isInvalid() || !T.get()) { 2789 // Recover by assuming we had the right type all along. 2790 DestructedType = ObjectType; 2791 } else 2792 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo); 2793 } 2794 2795 // If we've performed some kind of recovery, (re-)build the type source 2796 // information. 2797 if (!DestructedType.isNull()) { 2798 if (!DestructedTypeInfo) 2799 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType, 2800 SecondTypeName.StartLocation); 2801 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 2802 } 2803 2804 // Convert the name of the scope type (the type prior to '::') into a type. 2805 TypeSourceInfo *ScopeTypeInfo = 0; 2806 QualType ScopeType; 2807 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 2808 FirstTypeName.Identifier) { 2809 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) { 2810 TypeTy *T = getTypeName(*FirstTypeName.Identifier, 2811 FirstTypeName.StartLocation, 2812 S, &SS, false, ObjectTypePtrForLookup); 2813 if (!T) { 2814 Diag(FirstTypeName.StartLocation, 2815 diag::err_pseudo_dtor_destructor_non_type) 2816 << FirstTypeName.Identifier << ObjectType; 2817 2818 if (isSFINAEContext()) 2819 return ExprError(); 2820 2821 // Just drop this type. It's unnecessary anyway. 2822 ScopeType = QualType(); 2823 } else 2824 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo); 2825 } else { 2826 // Resolve the template-id to a type. 2827 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId; 2828 ASTTemplateArgsPtr TemplateArgsPtr(*this, 2829 TemplateId->getTemplateArgs(), 2830 TemplateId->NumArgs); 2831 TypeResult T = ActOnTemplateIdType(TemplateTy::make(TemplateId->Template), 2832 TemplateId->TemplateNameLoc, 2833 TemplateId->LAngleLoc, 2834 TemplateArgsPtr, 2835 TemplateId->RAngleLoc); 2836 if (T.isInvalid() || !T.get()) { 2837 // Recover by dropping this type. 2838 ScopeType = QualType(); 2839 } else 2840 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo); 2841 } 2842 } 2843 2844 if (!ScopeType.isNull() && !ScopeTypeInfo) 2845 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType, 2846 FirstTypeName.StartLocation); 2847 2848 2849 return BuildPseudoDestructorExpr(move(Base), OpLoc, OpKind, SS, 2850 ScopeTypeInfo, CCLoc, TildeLoc, 2851 Destructed, HasTrailingLParen); 2852} 2853 2854CXXMemberCallExpr *Sema::BuildCXXMemberCallExpr(Expr *Exp, 2855 NamedDecl *FoundDecl, 2856 CXXMethodDecl *Method) { 2857 if (PerformObjectArgumentInitialization(Exp, /*Qualifier=*/0, 2858 FoundDecl, Method)) 2859 assert(0 && "Calling BuildCXXMemberCallExpr with invalid call?"); 2860 2861 MemberExpr *ME = 2862 new (Context) MemberExpr(Exp, /*IsArrow=*/false, Method, 2863 SourceLocation(), Method->getType()); 2864 QualType ResultType = Method->getResultType().getNonReferenceType(); 2865 MarkDeclarationReferenced(Exp->getLocStart(), Method); 2866 CXXMemberCallExpr *CE = 2867 new (Context) CXXMemberCallExpr(Context, ME, 0, 0, ResultType, 2868 Exp->getLocEnd()); 2869 return CE; 2870} 2871 2872Sema::OwningExprResult Sema::BuildCXXCastArgument(SourceLocation CastLoc, 2873 QualType Ty, 2874 CastExpr::CastKind Kind, 2875 CXXMethodDecl *Method, 2876 ExprArg Arg) { 2877 Expr *From = Arg.takeAs<Expr>(); 2878 2879 switch (Kind) { 2880 default: assert(0 && "Unhandled cast kind!"); 2881 case CastExpr::CK_ConstructorConversion: { 2882 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this); 2883 2884 if (CompleteConstructorCall(cast<CXXConstructorDecl>(Method), 2885 MultiExprArg(*this, (void **)&From, 1), 2886 CastLoc, ConstructorArgs)) 2887 return ExprError(); 2888 2889 OwningExprResult Result = 2890 BuildCXXConstructExpr(CastLoc, Ty, cast<CXXConstructorDecl>(Method), 2891 move_arg(ConstructorArgs)); 2892 if (Result.isInvalid()) 2893 return ExprError(); 2894 2895 return MaybeBindToTemporary(Result.takeAs<Expr>()); 2896 } 2897 2898 case CastExpr::CK_UserDefinedConversion: { 2899 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!"); 2900 2901 // Create an implicit call expr that calls it. 2902 // FIXME: pass the FoundDecl for the user-defined conversion here 2903 CXXMemberCallExpr *CE = BuildCXXMemberCallExpr(From, Method, Method); 2904 return MaybeBindToTemporary(CE); 2905 } 2906 } 2907} 2908 2909Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) { 2910 Expr *FullExpr = Arg.takeAs<Expr>(); 2911 if (FullExpr) 2912 FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr); 2913 2914 return Owned(FullExpr); 2915} 2916