SemaExprCXX.cpp revision 219077
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 "clang/Sema/SemaInternal.h" 15#include "clang/Sema/DeclSpec.h" 16#include "clang/Sema/Initialization.h" 17#include "clang/Sema/Lookup.h" 18#include "clang/Sema/ParsedTemplate.h" 19#include "clang/Sema/ScopeInfo.h" 20#include "clang/Sema/TemplateDeduction.h" 21#include "clang/AST/ASTContext.h" 22#include "clang/AST/CXXInheritance.h" 23#include "clang/AST/DeclObjC.h" 24#include "clang/AST/ExprCXX.h" 25#include "clang/AST/ExprObjC.h" 26#include "clang/AST/TypeLoc.h" 27#include "clang/Basic/PartialDiagnostic.h" 28#include "clang/Basic/TargetInfo.h" 29#include "clang/Lex/Preprocessor.h" 30#include "llvm/ADT/STLExtras.h" 31using namespace clang; 32using namespace sema; 33 34ParsedType Sema::getDestructorName(SourceLocation TildeLoc, 35 IdentifierInfo &II, 36 SourceLocation NameLoc, 37 Scope *S, CXXScopeSpec &SS, 38 ParsedType ObjectTypePtr, 39 bool EnteringContext) { 40 // Determine where to perform name lookup. 41 42 // FIXME: This area of the standard is very messy, and the current 43 // wording is rather unclear about which scopes we search for the 44 // destructor name; see core issues 399 and 555. Issue 399 in 45 // particular shows where the current description of destructor name 46 // lookup is completely out of line with existing practice, e.g., 47 // this appears to be ill-formed: 48 // 49 // namespace N { 50 // template <typename T> struct S { 51 // ~S(); 52 // }; 53 // } 54 // 55 // void f(N::S<int>* s) { 56 // s->N::S<int>::~S(); 57 // } 58 // 59 // See also PR6358 and PR6359. 60 // For this reason, we're currently only doing the C++03 version of this 61 // code; the C++0x version has to wait until we get a proper spec. 62 QualType SearchType; 63 DeclContext *LookupCtx = 0; 64 bool isDependent = false; 65 bool LookInScope = false; 66 67 // If we have an object type, it's because we are in a 68 // pseudo-destructor-expression or a member access expression, and 69 // we know what type we're looking for. 70 if (ObjectTypePtr) 71 SearchType = GetTypeFromParser(ObjectTypePtr); 72 73 if (SS.isSet()) { 74 NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep(); 75 76 bool AlreadySearched = false; 77 bool LookAtPrefix = true; 78 // C++ [basic.lookup.qual]p6: 79 // If a pseudo-destructor-name (5.2.4) contains a nested-name-specifier, 80 // the type-names are looked up as types in the scope designated by the 81 // nested-name-specifier. In a qualified-id of the form: 82 // 83 // ::[opt] nested-name-specifier ~ class-name 84 // 85 // where the nested-name-specifier designates a namespace scope, and in 86 // a qualified-id of the form: 87 // 88 // ::opt nested-name-specifier class-name :: ~ class-name 89 // 90 // the class-names are looked up as types in the scope designated by 91 // the nested-name-specifier. 92 // 93 // Here, we check the first case (completely) and determine whether the 94 // code below is permitted to look at the prefix of the 95 // nested-name-specifier. 96 DeclContext *DC = computeDeclContext(SS, EnteringContext); 97 if (DC && DC->isFileContext()) { 98 AlreadySearched = true; 99 LookupCtx = DC; 100 isDependent = false; 101 } else if (DC && isa<CXXRecordDecl>(DC)) 102 LookAtPrefix = false; 103 104 // The second case from the C++03 rules quoted further above. 105 NestedNameSpecifier *Prefix = 0; 106 if (AlreadySearched) { 107 // Nothing left to do. 108 } else if (LookAtPrefix && (Prefix = NNS->getPrefix())) { 109 CXXScopeSpec PrefixSS; 110 PrefixSS.Adopt(NestedNameSpecifierLoc(Prefix, SS.location_data())); 111 LookupCtx = computeDeclContext(PrefixSS, EnteringContext); 112 isDependent = isDependentScopeSpecifier(PrefixSS); 113 } else if (ObjectTypePtr) { 114 LookupCtx = computeDeclContext(SearchType); 115 isDependent = SearchType->isDependentType(); 116 } else { 117 LookupCtx = computeDeclContext(SS, EnteringContext); 118 isDependent = LookupCtx && LookupCtx->isDependentContext(); 119 } 120 121 LookInScope = false; 122 } else if (ObjectTypePtr) { 123 // C++ [basic.lookup.classref]p3: 124 // If the unqualified-id is ~type-name, the type-name is looked up 125 // in the context of the entire postfix-expression. If the type T 126 // of the object expression is of a class type C, the type-name is 127 // also looked up in the scope of class C. At least one of the 128 // lookups shall find a name that refers to (possibly 129 // cv-qualified) T. 130 LookupCtx = computeDeclContext(SearchType); 131 isDependent = SearchType->isDependentType(); 132 assert((isDependent || !SearchType->isIncompleteType()) && 133 "Caller should have completed object type"); 134 135 LookInScope = true; 136 } else { 137 // Perform lookup into the current scope (only). 138 LookInScope = true; 139 } 140 141 LookupResult Found(*this, &II, NameLoc, LookupOrdinaryName); 142 for (unsigned Step = 0; Step != 2; ++Step) { 143 // Look for the name first in the computed lookup context (if we 144 // have one) and, if that fails to find a match, in the sope (if 145 // we're allowed to look there). 146 Found.clear(); 147 if (Step == 0 && LookupCtx) 148 LookupQualifiedName(Found, LookupCtx); 149 else if (Step == 1 && LookInScope && S) 150 LookupName(Found, S); 151 else 152 continue; 153 154 // FIXME: Should we be suppressing ambiguities here? 155 if (Found.isAmbiguous()) 156 return ParsedType(); 157 158 if (TypeDecl *Type = Found.getAsSingle<TypeDecl>()) { 159 QualType T = Context.getTypeDeclType(Type); 160 161 if (SearchType.isNull() || SearchType->isDependentType() || 162 Context.hasSameUnqualifiedType(T, SearchType)) { 163 // We found our type! 164 165 return ParsedType::make(T); 166 } 167 } 168 169 // If the name that we found is a class template name, and it is 170 // the same name as the template name in the last part of the 171 // nested-name-specifier (if present) or the object type, then 172 // this is the destructor for that class. 173 // FIXME: This is a workaround until we get real drafting for core 174 // issue 399, for which there isn't even an obvious direction. 175 if (ClassTemplateDecl *Template = Found.getAsSingle<ClassTemplateDecl>()) { 176 QualType MemberOfType; 177 if (SS.isSet()) { 178 if (DeclContext *Ctx = computeDeclContext(SS, EnteringContext)) { 179 // Figure out the type of the context, if it has one. 180 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx)) 181 MemberOfType = Context.getTypeDeclType(Record); 182 } 183 } 184 if (MemberOfType.isNull()) 185 MemberOfType = SearchType; 186 187 if (MemberOfType.isNull()) 188 continue; 189 190 // We're referring into a class template specialization. If the 191 // class template we found is the same as the template being 192 // specialized, we found what we are looking for. 193 if (const RecordType *Record = MemberOfType->getAs<RecordType>()) { 194 if (ClassTemplateSpecializationDecl *Spec 195 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) { 196 if (Spec->getSpecializedTemplate()->getCanonicalDecl() == 197 Template->getCanonicalDecl()) 198 return ParsedType::make(MemberOfType); 199 } 200 201 continue; 202 } 203 204 // We're referring to an unresolved class template 205 // specialization. Determine whether we class template we found 206 // is the same as the template being specialized or, if we don't 207 // know which template is being specialized, that it at least 208 // has the same name. 209 if (const TemplateSpecializationType *SpecType 210 = MemberOfType->getAs<TemplateSpecializationType>()) { 211 TemplateName SpecName = SpecType->getTemplateName(); 212 213 // The class template we found is the same template being 214 // specialized. 215 if (TemplateDecl *SpecTemplate = SpecName.getAsTemplateDecl()) { 216 if (SpecTemplate->getCanonicalDecl() == Template->getCanonicalDecl()) 217 return ParsedType::make(MemberOfType); 218 219 continue; 220 } 221 222 // The class template we found has the same name as the 223 // (dependent) template name being specialized. 224 if (DependentTemplateName *DepTemplate 225 = SpecName.getAsDependentTemplateName()) { 226 if (DepTemplate->isIdentifier() && 227 DepTemplate->getIdentifier() == Template->getIdentifier()) 228 return ParsedType::make(MemberOfType); 229 230 continue; 231 } 232 } 233 } 234 } 235 236 if (isDependent) { 237 // We didn't find our type, but that's okay: it's dependent 238 // anyway. 239 NestedNameSpecifier *NNS = 0; 240 SourceRange Range; 241 if (SS.isSet()) { 242 NNS = (NestedNameSpecifier *)SS.getScopeRep(); 243 Range = SourceRange(SS.getRange().getBegin(), NameLoc); 244 } else { 245 NNS = NestedNameSpecifier::Create(Context, &II); 246 Range = SourceRange(NameLoc); 247 } 248 249 QualType T = CheckTypenameType(ETK_None, NNS, II, 250 SourceLocation(), 251 Range, NameLoc); 252 return ParsedType::make(T); 253 } 254 255 if (ObjectTypePtr) 256 Diag(NameLoc, diag::err_ident_in_pseudo_dtor_not_a_type) 257 << &II; 258 else 259 Diag(NameLoc, diag::err_destructor_class_name); 260 261 return ParsedType(); 262} 263 264/// \brief Build a C++ typeid expression with a type operand. 265ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType, 266 SourceLocation TypeidLoc, 267 TypeSourceInfo *Operand, 268 SourceLocation RParenLoc) { 269 // C++ [expr.typeid]p4: 270 // The top-level cv-qualifiers of the lvalue expression or the type-id 271 // that is the operand of typeid are always ignored. 272 // If the type of the type-id is a class type or a reference to a class 273 // type, the class shall be completely-defined. 274 Qualifiers Quals; 275 QualType T 276 = Context.getUnqualifiedArrayType(Operand->getType().getNonReferenceType(), 277 Quals); 278 if (T->getAs<RecordType>() && 279 RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid)) 280 return ExprError(); 281 282 return Owned(new (Context) CXXTypeidExpr(TypeInfoType.withConst(), 283 Operand, 284 SourceRange(TypeidLoc, RParenLoc))); 285} 286 287/// \brief Build a C++ typeid expression with an expression operand. 288ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType, 289 SourceLocation TypeidLoc, 290 Expr *E, 291 SourceLocation RParenLoc) { 292 bool isUnevaluatedOperand = true; 293 if (E && !E->isTypeDependent()) { 294 QualType T = E->getType(); 295 if (const RecordType *RecordT = T->getAs<RecordType>()) { 296 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl()); 297 // C++ [expr.typeid]p3: 298 // [...] If the type of the expression is a class type, the class 299 // shall be completely-defined. 300 if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid)) 301 return ExprError(); 302 303 // C++ [expr.typeid]p3: 304 // When typeid is applied to an expression other than an glvalue of a 305 // polymorphic class type [...] [the] expression is an unevaluated 306 // operand. [...] 307 if (RecordD->isPolymorphic() && E->Classify(Context).isGLValue()) { 308 isUnevaluatedOperand = false; 309 310 // We require a vtable to query the type at run time. 311 MarkVTableUsed(TypeidLoc, RecordD); 312 } 313 } 314 315 // C++ [expr.typeid]p4: 316 // [...] If the type of the type-id is a reference to a possibly 317 // cv-qualified type, the result of the typeid expression refers to a 318 // std::type_info object representing the cv-unqualified referenced 319 // type. 320 Qualifiers Quals; 321 QualType UnqualT = Context.getUnqualifiedArrayType(T, Quals); 322 if (!Context.hasSameType(T, UnqualT)) { 323 T = UnqualT; 324 ImpCastExprToType(E, UnqualT, CK_NoOp, CastCategory(E)); 325 } 326 } 327 328 // If this is an unevaluated operand, clear out the set of 329 // declaration references we have been computing and eliminate any 330 // temporaries introduced in its computation. 331 if (isUnevaluatedOperand) 332 ExprEvalContexts.back().Context = Unevaluated; 333 334 return Owned(new (Context) CXXTypeidExpr(TypeInfoType.withConst(), 335 E, 336 SourceRange(TypeidLoc, RParenLoc))); 337} 338 339/// ActOnCXXTypeidOfType - Parse typeid( type-id ) or typeid (expression); 340ExprResult 341Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc, 342 bool isType, void *TyOrExpr, SourceLocation RParenLoc) { 343 // Find the std::type_info type. 344 if (!StdNamespace) 345 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid)); 346 347 if (!CXXTypeInfoDecl) { 348 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info"); 349 LookupResult R(*this, TypeInfoII, SourceLocation(), LookupTagName); 350 LookupQualifiedName(R, getStdNamespace()); 351 CXXTypeInfoDecl = R.getAsSingle<RecordDecl>(); 352 if (!CXXTypeInfoDecl) 353 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid)); 354 } 355 356 QualType TypeInfoType = Context.getTypeDeclType(CXXTypeInfoDecl); 357 358 if (isType) { 359 // The operand is a type; handle it as such. 360 TypeSourceInfo *TInfo = 0; 361 QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr), 362 &TInfo); 363 if (T.isNull()) 364 return ExprError(); 365 366 if (!TInfo) 367 TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc); 368 369 return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc); 370 } 371 372 // The operand is an expression. 373 return BuildCXXTypeId(TypeInfoType, OpLoc, (Expr*)TyOrExpr, RParenLoc); 374} 375 376/// Retrieve the UuidAttr associated with QT. 377static UuidAttr *GetUuidAttrOfType(QualType QT) { 378 // Optionally remove one level of pointer, reference or array indirection. 379 const Type *Ty = QT.getTypePtr();; 380 if (QT->isPointerType() || QT->isReferenceType()) 381 Ty = QT->getPointeeType().getTypePtr(); 382 else if (QT->isArrayType()) 383 Ty = cast<ArrayType>(QT)->getElementType().getTypePtr(); 384 385 // Loop all class definition and declaration looking for an uuid attribute. 386 CXXRecordDecl *RD = Ty->getAsCXXRecordDecl(); 387 while (RD) { 388 if (UuidAttr *Uuid = RD->getAttr<UuidAttr>()) 389 return Uuid; 390 RD = RD->getPreviousDeclaration(); 391 } 392 return 0; 393} 394 395/// \brief Build a Microsoft __uuidof expression with a type operand. 396ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType, 397 SourceLocation TypeidLoc, 398 TypeSourceInfo *Operand, 399 SourceLocation RParenLoc) { 400 if (!Operand->getType()->isDependentType()) { 401 if (!GetUuidAttrOfType(Operand->getType())) 402 return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid)); 403 } 404 405 // FIXME: add __uuidof semantic analysis for type operand. 406 return Owned(new (Context) CXXUuidofExpr(TypeInfoType.withConst(), 407 Operand, 408 SourceRange(TypeidLoc, RParenLoc))); 409} 410 411/// \brief Build a Microsoft __uuidof expression with an expression operand. 412ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType, 413 SourceLocation TypeidLoc, 414 Expr *E, 415 SourceLocation RParenLoc) { 416 if (!E->getType()->isDependentType()) { 417 if (!GetUuidAttrOfType(E->getType()) && 418 !E->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) 419 return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid)); 420 } 421 // FIXME: add __uuidof semantic analysis for type operand. 422 return Owned(new (Context) CXXUuidofExpr(TypeInfoType.withConst(), 423 E, 424 SourceRange(TypeidLoc, RParenLoc))); 425} 426 427/// ActOnCXXUuidof - Parse __uuidof( type-id ) or __uuidof (expression); 428ExprResult 429Sema::ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc, 430 bool isType, void *TyOrExpr, SourceLocation RParenLoc) { 431 // If MSVCGuidDecl has not been cached, do the lookup. 432 if (!MSVCGuidDecl) { 433 IdentifierInfo *GuidII = &PP.getIdentifierTable().get("_GUID"); 434 LookupResult R(*this, GuidII, SourceLocation(), LookupTagName); 435 LookupQualifiedName(R, Context.getTranslationUnitDecl()); 436 MSVCGuidDecl = R.getAsSingle<RecordDecl>(); 437 if (!MSVCGuidDecl) 438 return ExprError(Diag(OpLoc, diag::err_need_header_before_ms_uuidof)); 439 } 440 441 QualType GuidType = Context.getTypeDeclType(MSVCGuidDecl); 442 443 if (isType) { 444 // The operand is a type; handle it as such. 445 TypeSourceInfo *TInfo = 0; 446 QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr), 447 &TInfo); 448 if (T.isNull()) 449 return ExprError(); 450 451 if (!TInfo) 452 TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc); 453 454 return BuildCXXUuidof(GuidType, OpLoc, TInfo, RParenLoc); 455 } 456 457 // The operand is an expression. 458 return BuildCXXUuidof(GuidType, OpLoc, (Expr*)TyOrExpr, RParenLoc); 459} 460 461/// ActOnCXXBoolLiteral - Parse {true,false} literals. 462ExprResult 463Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) { 464 assert((Kind == tok::kw_true || Kind == tok::kw_false) && 465 "Unknown C++ Boolean value!"); 466 return Owned(new (Context) CXXBoolLiteralExpr(Kind == tok::kw_true, 467 Context.BoolTy, OpLoc)); 468} 469 470/// ActOnCXXNullPtrLiteral - Parse 'nullptr'. 471ExprResult 472Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc) { 473 return Owned(new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc)); 474} 475 476/// ActOnCXXThrow - Parse throw expressions. 477ExprResult 478Sema::ActOnCXXThrow(SourceLocation OpLoc, Expr *Ex) { 479 // Don't report an error if 'throw' is used in system headers. 480 if (!getLangOptions().Exceptions && 481 !getSourceManager().isInSystemHeader(OpLoc)) 482 Diag(OpLoc, diag::err_exceptions_disabled) << "throw"; 483 484 if (Ex && !Ex->isTypeDependent() && CheckCXXThrowOperand(OpLoc, Ex)) 485 return ExprError(); 486 return Owned(new (Context) CXXThrowExpr(Ex, Context.VoidTy, OpLoc)); 487} 488 489/// CheckCXXThrowOperand - Validate the operand of a throw. 490bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E) { 491 // C++ [except.throw]p3: 492 // A throw-expression initializes a temporary object, called the exception 493 // object, the type of which is determined by removing any top-level 494 // cv-qualifiers from the static type of the operand of throw and adjusting 495 // the type from "array of T" or "function returning T" to "pointer to T" 496 // or "pointer to function returning T", [...] 497 if (E->getType().hasQualifiers()) 498 ImpCastExprToType(E, E->getType().getUnqualifiedType(), CK_NoOp, 499 CastCategory(E)); 500 501 DefaultFunctionArrayConversion(E); 502 503 // If the type of the exception would be an incomplete type or a pointer 504 // to an incomplete type other than (cv) void the program is ill-formed. 505 QualType Ty = E->getType(); 506 bool isPointer = false; 507 if (const PointerType* Ptr = Ty->getAs<PointerType>()) { 508 Ty = Ptr->getPointeeType(); 509 isPointer = true; 510 } 511 if (!isPointer || !Ty->isVoidType()) { 512 if (RequireCompleteType(ThrowLoc, Ty, 513 PDiag(isPointer ? diag::err_throw_incomplete_ptr 514 : diag::err_throw_incomplete) 515 << E->getSourceRange())) 516 return true; 517 518 if (RequireNonAbstractType(ThrowLoc, E->getType(), 519 PDiag(diag::err_throw_abstract_type) 520 << E->getSourceRange())) 521 return true; 522 } 523 524 // Initialize the exception result. This implicitly weeds out 525 // abstract types or types with inaccessible copy constructors. 526 const VarDecl *NRVOVariable = getCopyElisionCandidate(QualType(), E, false); 527 528 // FIXME: Determine whether we can elide this copy per C++0x [class.copy]p32. 529 InitializedEntity Entity = 530 InitializedEntity::InitializeException(ThrowLoc, E->getType(), 531 /*NRVO=*/false); 532 ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOVariable, 533 QualType(), E); 534 if (Res.isInvalid()) 535 return true; 536 E = Res.takeAs<Expr>(); 537 538 // If the exception has class type, we need additional handling. 539 const RecordType *RecordTy = Ty->getAs<RecordType>(); 540 if (!RecordTy) 541 return false; 542 CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl()); 543 544 // If we are throwing a polymorphic class type or pointer thereof, 545 // exception handling will make use of the vtable. 546 MarkVTableUsed(ThrowLoc, RD); 547 548 // If a pointer is thrown, the referenced object will not be destroyed. 549 if (isPointer) 550 return false; 551 552 // If the class has a non-trivial destructor, we must be able to call it. 553 if (RD->hasTrivialDestructor()) 554 return false; 555 556 CXXDestructorDecl *Destructor 557 = const_cast<CXXDestructorDecl*>(LookupDestructor(RD)); 558 if (!Destructor) 559 return false; 560 561 MarkDeclarationReferenced(E->getExprLoc(), Destructor); 562 CheckDestructorAccess(E->getExprLoc(), Destructor, 563 PDiag(diag::err_access_dtor_exception) << Ty); 564 return false; 565} 566 567CXXMethodDecl *Sema::tryCaptureCXXThis() { 568 // Ignore block scopes: we can capture through them. 569 // Ignore nested enum scopes: we'll diagnose non-constant expressions 570 // where they're invalid, and other uses are legitimate. 571 // Don't ignore nested class scopes: you can't use 'this' in a local class. 572 DeclContext *DC = CurContext; 573 while (true) { 574 if (isa<BlockDecl>(DC)) DC = cast<BlockDecl>(DC)->getDeclContext(); 575 else if (isa<EnumDecl>(DC)) DC = cast<EnumDecl>(DC)->getDeclContext(); 576 else break; 577 } 578 579 // If we're not in an instance method, error out. 580 CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(DC); 581 if (!method || !method->isInstance()) 582 return 0; 583 584 // Mark that we're closing on 'this' in all the block scopes, if applicable. 585 for (unsigned idx = FunctionScopes.size() - 1; 586 isa<BlockScopeInfo>(FunctionScopes[idx]); 587 --idx) 588 cast<BlockScopeInfo>(FunctionScopes[idx])->CapturesCXXThis = true; 589 590 return method; 591} 592 593ExprResult Sema::ActOnCXXThis(SourceLocation loc) { 594 /// C++ 9.3.2: In the body of a non-static member function, the keyword this 595 /// is a non-lvalue expression whose value is the address of the object for 596 /// which the function is called. 597 598 CXXMethodDecl *method = tryCaptureCXXThis(); 599 if (!method) return Diag(loc, diag::err_invalid_this_use); 600 601 return Owned(new (Context) CXXThisExpr(loc, method->getThisType(Context), 602 /*isImplicit=*/false)); 603} 604 605ExprResult 606Sema::ActOnCXXTypeConstructExpr(ParsedType TypeRep, 607 SourceLocation LParenLoc, 608 MultiExprArg exprs, 609 SourceLocation RParenLoc) { 610 if (!TypeRep) 611 return ExprError(); 612 613 TypeSourceInfo *TInfo; 614 QualType Ty = GetTypeFromParser(TypeRep, &TInfo); 615 if (!TInfo) 616 TInfo = Context.getTrivialTypeSourceInfo(Ty, SourceLocation()); 617 618 return BuildCXXTypeConstructExpr(TInfo, LParenLoc, exprs, RParenLoc); 619} 620 621/// ActOnCXXTypeConstructExpr - Parse construction of a specified type. 622/// Can be interpreted either as function-style casting ("int(x)") 623/// or class type construction ("ClassType(x,y,z)") 624/// or creation of a value-initialized type ("int()"). 625ExprResult 626Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo, 627 SourceLocation LParenLoc, 628 MultiExprArg exprs, 629 SourceLocation RParenLoc) { 630 QualType Ty = TInfo->getType(); 631 unsigned NumExprs = exprs.size(); 632 Expr **Exprs = (Expr**)exprs.get(); 633 SourceLocation TyBeginLoc = TInfo->getTypeLoc().getBeginLoc(); 634 SourceRange FullRange = SourceRange(TyBeginLoc, RParenLoc); 635 636 if (Ty->isDependentType() || 637 CallExpr::hasAnyTypeDependentArguments(Exprs, NumExprs)) { 638 exprs.release(); 639 640 return Owned(CXXUnresolvedConstructExpr::Create(Context, TInfo, 641 LParenLoc, 642 Exprs, NumExprs, 643 RParenLoc)); 644 } 645 646 if (Ty->isArrayType()) 647 return ExprError(Diag(TyBeginLoc, 648 diag::err_value_init_for_array_type) << FullRange); 649 if (!Ty->isVoidType() && 650 RequireCompleteType(TyBeginLoc, Ty, 651 PDiag(diag::err_invalid_incomplete_type_use) 652 << FullRange)) 653 return ExprError(); 654 655 if (RequireNonAbstractType(TyBeginLoc, Ty, 656 diag::err_allocation_of_abstract_type)) 657 return ExprError(); 658 659 660 // C++ [expr.type.conv]p1: 661 // If the expression list is a single expression, the type conversion 662 // expression is equivalent (in definedness, and if defined in meaning) to the 663 // corresponding cast expression. 664 // 665 if (NumExprs == 1) { 666 CastKind Kind = CK_Invalid; 667 ExprValueKind VK = VK_RValue; 668 CXXCastPath BasePath; 669 if (CheckCastTypes(TInfo->getTypeLoc().getSourceRange(), Ty, Exprs[0], 670 Kind, VK, BasePath, 671 /*FunctionalStyle=*/true)) 672 return ExprError(); 673 674 exprs.release(); 675 676 return Owned(CXXFunctionalCastExpr::Create(Context, 677 Ty.getNonLValueExprType(Context), 678 VK, TInfo, TyBeginLoc, Kind, 679 Exprs[0], &BasePath, 680 RParenLoc)); 681 } 682 683 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TInfo); 684 InitializationKind Kind 685 = NumExprs ? InitializationKind::CreateDirect(TyBeginLoc, 686 LParenLoc, RParenLoc) 687 : InitializationKind::CreateValue(TyBeginLoc, 688 LParenLoc, RParenLoc); 689 InitializationSequence InitSeq(*this, Entity, Kind, Exprs, NumExprs); 690 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, move(exprs)); 691 692 // FIXME: Improve AST representation? 693 return move(Result); 694} 695 696/// doesUsualArrayDeleteWantSize - Answers whether the usual 697/// operator delete[] for the given type has a size_t parameter. 698static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc, 699 QualType allocType) { 700 const RecordType *record = 701 allocType->getBaseElementTypeUnsafe()->getAs<RecordType>(); 702 if (!record) return false; 703 704 // Try to find an operator delete[] in class scope. 705 706 DeclarationName deleteName = 707 S.Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete); 708 LookupResult ops(S, deleteName, loc, Sema::LookupOrdinaryName); 709 S.LookupQualifiedName(ops, record->getDecl()); 710 711 // We're just doing this for information. 712 ops.suppressDiagnostics(); 713 714 // Very likely: there's no operator delete[]. 715 if (ops.empty()) return false; 716 717 // If it's ambiguous, it should be illegal to call operator delete[] 718 // on this thing, so it doesn't matter if we allocate extra space or not. 719 if (ops.isAmbiguous()) return false; 720 721 LookupResult::Filter filter = ops.makeFilter(); 722 while (filter.hasNext()) { 723 NamedDecl *del = filter.next()->getUnderlyingDecl(); 724 725 // C++0x [basic.stc.dynamic.deallocation]p2: 726 // A template instance is never a usual deallocation function, 727 // regardless of its signature. 728 if (isa<FunctionTemplateDecl>(del)) { 729 filter.erase(); 730 continue; 731 } 732 733 // C++0x [basic.stc.dynamic.deallocation]p2: 734 // If class T does not declare [an operator delete[] with one 735 // parameter] but does declare a member deallocation function 736 // named operator delete[] with exactly two parameters, the 737 // second of which has type std::size_t, then this function 738 // is a usual deallocation function. 739 if (!cast<CXXMethodDecl>(del)->isUsualDeallocationFunction()) { 740 filter.erase(); 741 continue; 742 } 743 } 744 filter.done(); 745 746 if (!ops.isSingleResult()) return false; 747 748 const FunctionDecl *del = cast<FunctionDecl>(ops.getFoundDecl()); 749 return (del->getNumParams() == 2); 750} 751 752/// ActOnCXXNew - Parsed a C++ 'new' expression (C++ 5.3.4), as in e.g.: 753/// @code new (memory) int[size][4] @endcode 754/// or 755/// @code ::new Foo(23, "hello") @endcode 756/// For the interpretation of this heap of arguments, consult the base version. 757ExprResult 758Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, 759 SourceLocation PlacementLParen, MultiExprArg PlacementArgs, 760 SourceLocation PlacementRParen, SourceRange TypeIdParens, 761 Declarator &D, SourceLocation ConstructorLParen, 762 MultiExprArg ConstructorArgs, 763 SourceLocation ConstructorRParen) { 764 bool TypeContainsAuto = D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto; 765 766 Expr *ArraySize = 0; 767 // If the specified type is an array, unwrap it and save the expression. 768 if (D.getNumTypeObjects() > 0 && 769 D.getTypeObject(0).Kind == DeclaratorChunk::Array) { 770 DeclaratorChunk &Chunk = D.getTypeObject(0); 771 if (TypeContainsAuto) 772 return ExprError(Diag(Chunk.Loc, diag::err_new_array_of_auto) 773 << D.getSourceRange()); 774 if (Chunk.Arr.hasStatic) 775 return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new) 776 << D.getSourceRange()); 777 if (!Chunk.Arr.NumElts) 778 return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size) 779 << D.getSourceRange()); 780 781 ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts); 782 D.DropFirstTypeObject(); 783 } 784 785 // Every dimension shall be of constant size. 786 if (ArraySize) { 787 for (unsigned I = 0, N = D.getNumTypeObjects(); I < N; ++I) { 788 if (D.getTypeObject(I).Kind != DeclaratorChunk::Array) 789 break; 790 791 DeclaratorChunk::ArrayTypeInfo &Array = D.getTypeObject(I).Arr; 792 if (Expr *NumElts = (Expr *)Array.NumElts) { 793 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent() && 794 !NumElts->isIntegerConstantExpr(Context)) { 795 Diag(D.getTypeObject(I).Loc, diag::err_new_array_nonconst) 796 << NumElts->getSourceRange(); 797 return ExprError(); 798 } 799 } 800 } 801 } 802 803 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, /*Scope=*/0, /*OwnedDecl=*/0, 804 /*AllowAuto=*/true); 805 QualType AllocType = TInfo->getType(); 806 if (D.isInvalidType()) 807 return ExprError(); 808 809 return BuildCXXNew(StartLoc, UseGlobal, 810 PlacementLParen, 811 move(PlacementArgs), 812 PlacementRParen, 813 TypeIdParens, 814 AllocType, 815 TInfo, 816 ArraySize, 817 ConstructorLParen, 818 move(ConstructorArgs), 819 ConstructorRParen, 820 TypeContainsAuto); 821} 822 823ExprResult 824Sema::BuildCXXNew(SourceLocation StartLoc, bool UseGlobal, 825 SourceLocation PlacementLParen, 826 MultiExprArg PlacementArgs, 827 SourceLocation PlacementRParen, 828 SourceRange TypeIdParens, 829 QualType AllocType, 830 TypeSourceInfo *AllocTypeInfo, 831 Expr *ArraySize, 832 SourceLocation ConstructorLParen, 833 MultiExprArg ConstructorArgs, 834 SourceLocation ConstructorRParen, 835 bool TypeMayContainAuto) { 836 SourceRange TypeRange = AllocTypeInfo->getTypeLoc().getSourceRange(); 837 838 // C++0x [decl.spec.auto]p6. Deduce the type which 'auto' stands in for. 839 if (TypeMayContainAuto && AllocType->getContainedAutoType()) { 840 if (ConstructorArgs.size() == 0) 841 return ExprError(Diag(StartLoc, diag::err_auto_new_requires_ctor_arg) 842 << AllocType << TypeRange); 843 if (ConstructorArgs.size() != 1) { 844 Expr *FirstBad = ConstructorArgs.get()[1]; 845 return ExprError(Diag(FirstBad->getSourceRange().getBegin(), 846 diag::err_auto_new_ctor_multiple_expressions) 847 << AllocType << TypeRange); 848 } 849 QualType DeducedType; 850 if (!DeduceAutoType(AllocType, ConstructorArgs.get()[0], DeducedType)) 851 return ExprError(Diag(StartLoc, diag::err_auto_new_deduction_failure) 852 << AllocType 853 << ConstructorArgs.get()[0]->getType() 854 << TypeRange 855 << ConstructorArgs.get()[0]->getSourceRange()); 856 857 AllocType = DeducedType; 858 AllocTypeInfo = Context.getTrivialTypeSourceInfo(AllocType, StartLoc); 859 } 860 861 // Per C++0x [expr.new]p5, the type being constructed may be a 862 // typedef of an array type. 863 if (!ArraySize) { 864 if (const ConstantArrayType *Array 865 = Context.getAsConstantArrayType(AllocType)) { 866 ArraySize = IntegerLiteral::Create(Context, Array->getSize(), 867 Context.getSizeType(), 868 TypeRange.getEnd()); 869 AllocType = Array->getElementType(); 870 } 871 } 872 873 if (CheckAllocatedType(AllocType, TypeRange.getBegin(), TypeRange)) 874 return ExprError(); 875 876 QualType ResultType = Context.getPointerType(AllocType); 877 878 // C++ 5.3.4p6: "The expression in a direct-new-declarator shall have integral 879 // or enumeration type with a non-negative value." 880 if (ArraySize && !ArraySize->isTypeDependent()) { 881 882 QualType SizeType = ArraySize->getType(); 883 884 ExprResult ConvertedSize 885 = ConvertToIntegralOrEnumerationType(StartLoc, ArraySize, 886 PDiag(diag::err_array_size_not_integral), 887 PDiag(diag::err_array_size_incomplete_type) 888 << ArraySize->getSourceRange(), 889 PDiag(diag::err_array_size_explicit_conversion), 890 PDiag(diag::note_array_size_conversion), 891 PDiag(diag::err_array_size_ambiguous_conversion), 892 PDiag(diag::note_array_size_conversion), 893 PDiag(getLangOptions().CPlusPlus0x? 0 894 : diag::ext_array_size_conversion)); 895 if (ConvertedSize.isInvalid()) 896 return ExprError(); 897 898 ArraySize = ConvertedSize.take(); 899 SizeType = ArraySize->getType(); 900 if (!SizeType->isIntegralOrUnscopedEnumerationType()) 901 return ExprError(); 902 903 // Let's see if this is a constant < 0. If so, we reject it out of hand. 904 // We don't care about special rules, so we tell the machinery it's not 905 // evaluated - it gives us a result in more cases. 906 if (!ArraySize->isValueDependent()) { 907 llvm::APSInt Value; 908 if (ArraySize->isIntegerConstantExpr(Value, Context, 0, false)) { 909 if (Value < llvm::APSInt( 910 llvm::APInt::getNullValue(Value.getBitWidth()), 911 Value.isUnsigned())) 912 return ExprError(Diag(ArraySize->getSourceRange().getBegin(), 913 diag::err_typecheck_negative_array_size) 914 << ArraySize->getSourceRange()); 915 916 if (!AllocType->isDependentType()) { 917 unsigned ActiveSizeBits 918 = ConstantArrayType::getNumAddressingBits(Context, AllocType, Value); 919 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) { 920 Diag(ArraySize->getSourceRange().getBegin(), 921 diag::err_array_too_large) 922 << Value.toString(10) 923 << ArraySize->getSourceRange(); 924 return ExprError(); 925 } 926 } 927 } else if (TypeIdParens.isValid()) { 928 // Can't have dynamic array size when the type-id is in parentheses. 929 Diag(ArraySize->getLocStart(), diag::ext_new_paren_array_nonconst) 930 << ArraySize->getSourceRange() 931 << FixItHint::CreateRemoval(TypeIdParens.getBegin()) 932 << FixItHint::CreateRemoval(TypeIdParens.getEnd()); 933 934 TypeIdParens = SourceRange(); 935 } 936 } 937 938 ImpCastExprToType(ArraySize, Context.getSizeType(), 939 CK_IntegralCast); 940 } 941 942 FunctionDecl *OperatorNew = 0; 943 FunctionDecl *OperatorDelete = 0; 944 Expr **PlaceArgs = (Expr**)PlacementArgs.get(); 945 unsigned NumPlaceArgs = PlacementArgs.size(); 946 947 if (!AllocType->isDependentType() && 948 !Expr::hasAnyTypeDependentArguments(PlaceArgs, NumPlaceArgs) && 949 FindAllocationFunctions(StartLoc, 950 SourceRange(PlacementLParen, PlacementRParen), 951 UseGlobal, AllocType, ArraySize, PlaceArgs, 952 NumPlaceArgs, OperatorNew, OperatorDelete)) 953 return ExprError(); 954 955 // If this is an array allocation, compute whether the usual array 956 // deallocation function for the type has a size_t parameter. 957 bool UsualArrayDeleteWantsSize = false; 958 if (ArraySize && !AllocType->isDependentType()) 959 UsualArrayDeleteWantsSize 960 = doesUsualArrayDeleteWantSize(*this, StartLoc, AllocType); 961 962 llvm::SmallVector<Expr *, 8> AllPlaceArgs; 963 if (OperatorNew) { 964 // Add default arguments, if any. 965 const FunctionProtoType *Proto = 966 OperatorNew->getType()->getAs<FunctionProtoType>(); 967 VariadicCallType CallType = 968 Proto->isVariadic() ? VariadicFunction : VariadicDoesNotApply; 969 970 if (GatherArgumentsForCall(PlacementLParen, OperatorNew, 971 Proto, 1, PlaceArgs, NumPlaceArgs, 972 AllPlaceArgs, CallType)) 973 return ExprError(); 974 975 NumPlaceArgs = AllPlaceArgs.size(); 976 if (NumPlaceArgs > 0) 977 PlaceArgs = &AllPlaceArgs[0]; 978 } 979 980 bool Init = ConstructorLParen.isValid(); 981 // --- Choosing a constructor --- 982 CXXConstructorDecl *Constructor = 0; 983 Expr **ConsArgs = (Expr**)ConstructorArgs.get(); 984 unsigned NumConsArgs = ConstructorArgs.size(); 985 ASTOwningVector<Expr*> ConvertedConstructorArgs(*this); 986 987 // Array 'new' can't have any initializers. 988 if (NumConsArgs && (ResultType->isArrayType() || ArraySize)) { 989 SourceRange InitRange(ConsArgs[0]->getLocStart(), 990 ConsArgs[NumConsArgs - 1]->getLocEnd()); 991 992 Diag(StartLoc, diag::err_new_array_init_args) << InitRange; 993 return ExprError(); 994 } 995 996 if (!AllocType->isDependentType() && 997 !Expr::hasAnyTypeDependentArguments(ConsArgs, NumConsArgs)) { 998 // C++0x [expr.new]p15: 999 // A new-expression that creates an object of type T initializes that 1000 // object as follows: 1001 InitializationKind Kind 1002 // - If the new-initializer is omitted, the object is default- 1003 // initialized (8.5); if no initialization is performed, 1004 // the object has indeterminate value 1005 = !Init? InitializationKind::CreateDefault(TypeRange.getBegin()) 1006 // - Otherwise, the new-initializer is interpreted according to the 1007 // initialization rules of 8.5 for direct-initialization. 1008 : InitializationKind::CreateDirect(TypeRange.getBegin(), 1009 ConstructorLParen, 1010 ConstructorRParen); 1011 1012 InitializedEntity Entity 1013 = InitializedEntity::InitializeNew(StartLoc, AllocType); 1014 InitializationSequence InitSeq(*this, Entity, Kind, ConsArgs, NumConsArgs); 1015 ExprResult FullInit = InitSeq.Perform(*this, Entity, Kind, 1016 move(ConstructorArgs)); 1017 if (FullInit.isInvalid()) 1018 return ExprError(); 1019 1020 // FullInit is our initializer; walk through it to determine if it's a 1021 // constructor call, which CXXNewExpr handles directly. 1022 if (Expr *FullInitExpr = (Expr *)FullInit.get()) { 1023 if (CXXBindTemporaryExpr *Binder 1024 = dyn_cast<CXXBindTemporaryExpr>(FullInitExpr)) 1025 FullInitExpr = Binder->getSubExpr(); 1026 if (CXXConstructExpr *Construct 1027 = dyn_cast<CXXConstructExpr>(FullInitExpr)) { 1028 Constructor = Construct->getConstructor(); 1029 for (CXXConstructExpr::arg_iterator A = Construct->arg_begin(), 1030 AEnd = Construct->arg_end(); 1031 A != AEnd; ++A) 1032 ConvertedConstructorArgs.push_back(*A); 1033 } else { 1034 // Take the converted initializer. 1035 ConvertedConstructorArgs.push_back(FullInit.release()); 1036 } 1037 } else { 1038 // No initialization required. 1039 } 1040 1041 // Take the converted arguments and use them for the new expression. 1042 NumConsArgs = ConvertedConstructorArgs.size(); 1043 ConsArgs = (Expr **)ConvertedConstructorArgs.take(); 1044 } 1045 1046 // Mark the new and delete operators as referenced. 1047 if (OperatorNew) 1048 MarkDeclarationReferenced(StartLoc, OperatorNew); 1049 if (OperatorDelete) 1050 MarkDeclarationReferenced(StartLoc, OperatorDelete); 1051 1052 // FIXME: Also check that the destructor is accessible. (C++ 5.3.4p16) 1053 1054 PlacementArgs.release(); 1055 ConstructorArgs.release(); 1056 1057 return Owned(new (Context) CXXNewExpr(Context, UseGlobal, OperatorNew, 1058 PlaceArgs, NumPlaceArgs, TypeIdParens, 1059 ArraySize, Constructor, Init, 1060 ConsArgs, NumConsArgs, OperatorDelete, 1061 UsualArrayDeleteWantsSize, 1062 ResultType, AllocTypeInfo, 1063 StartLoc, 1064 Init ? ConstructorRParen : 1065 TypeRange.getEnd(), 1066 ConstructorLParen, ConstructorRParen)); 1067} 1068 1069/// CheckAllocatedType - Checks that a type is suitable as the allocated type 1070/// in a new-expression. 1071/// dimension off and stores the size expression in ArraySize. 1072bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc, 1073 SourceRange R) { 1074 // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an 1075 // abstract class type or array thereof. 1076 if (AllocType->isFunctionType()) 1077 return Diag(Loc, diag::err_bad_new_type) 1078 << AllocType << 0 << R; 1079 else if (AllocType->isReferenceType()) 1080 return Diag(Loc, diag::err_bad_new_type) 1081 << AllocType << 1 << R; 1082 else if (!AllocType->isDependentType() && 1083 RequireCompleteType(Loc, AllocType, 1084 PDiag(diag::err_new_incomplete_type) 1085 << R)) 1086 return true; 1087 else if (RequireNonAbstractType(Loc, AllocType, 1088 diag::err_allocation_of_abstract_type)) 1089 return true; 1090 else if (AllocType->isVariablyModifiedType()) 1091 return Diag(Loc, diag::err_variably_modified_new_type) 1092 << AllocType; 1093 1094 return false; 1095} 1096 1097/// \brief Determine whether the given function is a non-placement 1098/// deallocation function. 1099static bool isNonPlacementDeallocationFunction(FunctionDecl *FD) { 1100 if (FD->isInvalidDecl()) 1101 return false; 1102 1103 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD)) 1104 return Method->isUsualDeallocationFunction(); 1105 1106 return ((FD->getOverloadedOperator() == OO_Delete || 1107 FD->getOverloadedOperator() == OO_Array_Delete) && 1108 FD->getNumParams() == 1); 1109} 1110 1111/// FindAllocationFunctions - Finds the overloads of operator new and delete 1112/// that are appropriate for the allocation. 1113bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, 1114 bool UseGlobal, QualType AllocType, 1115 bool IsArray, Expr **PlaceArgs, 1116 unsigned NumPlaceArgs, 1117 FunctionDecl *&OperatorNew, 1118 FunctionDecl *&OperatorDelete) { 1119 // --- Choosing an allocation function --- 1120 // C++ 5.3.4p8 - 14 & 18 1121 // 1) If UseGlobal is true, only look in the global scope. Else, also look 1122 // in the scope of the allocated class. 1123 // 2) If an array size is given, look for operator new[], else look for 1124 // operator new. 1125 // 3) The first argument is always size_t. Append the arguments from the 1126 // placement form. 1127 1128 llvm::SmallVector<Expr*, 8> AllocArgs(1 + NumPlaceArgs); 1129 // We don't care about the actual value of this argument. 1130 // FIXME: Should the Sema create the expression and embed it in the syntax 1131 // tree? Or should the consumer just recalculate the value? 1132 IntegerLiteral Size(Context, llvm::APInt::getNullValue( 1133 Context.Target.getPointerWidth(0)), 1134 Context.getSizeType(), 1135 SourceLocation()); 1136 AllocArgs[0] = &Size; 1137 std::copy(PlaceArgs, PlaceArgs + NumPlaceArgs, AllocArgs.begin() + 1); 1138 1139 // C++ [expr.new]p8: 1140 // If the allocated type is a non-array type, the allocation 1141 // function's name is operator new and the deallocation function's 1142 // name is operator delete. If the allocated type is an array 1143 // type, the allocation function's name is operator new[] and the 1144 // deallocation function's name is operator delete[]. 1145 DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName( 1146 IsArray ? OO_Array_New : OO_New); 1147 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName( 1148 IsArray ? OO_Array_Delete : OO_Delete); 1149 1150 QualType AllocElemType = Context.getBaseElementType(AllocType); 1151 1152 if (AllocElemType->isRecordType() && !UseGlobal) { 1153 CXXRecordDecl *Record 1154 = cast<CXXRecordDecl>(AllocElemType->getAs<RecordType>()->getDecl()); 1155 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0], 1156 AllocArgs.size(), Record, /*AllowMissing=*/true, 1157 OperatorNew)) 1158 return true; 1159 } 1160 if (!OperatorNew) { 1161 // Didn't find a member overload. Look for a global one. 1162 DeclareGlobalNewDelete(); 1163 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 1164 if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0], 1165 AllocArgs.size(), TUDecl, /*AllowMissing=*/false, 1166 OperatorNew)) 1167 return true; 1168 } 1169 1170 // We don't need an operator delete if we're running under 1171 // -fno-exceptions. 1172 if (!getLangOptions().Exceptions) { 1173 OperatorDelete = 0; 1174 return false; 1175 } 1176 1177 // FindAllocationOverload can change the passed in arguments, so we need to 1178 // copy them back. 1179 if (NumPlaceArgs > 0) 1180 std::copy(&AllocArgs[1], AllocArgs.end(), PlaceArgs); 1181 1182 // C++ [expr.new]p19: 1183 // 1184 // If the new-expression begins with a unary :: operator, the 1185 // deallocation function's name is looked up in the global 1186 // scope. Otherwise, if the allocated type is a class type T or an 1187 // array thereof, the deallocation function's name is looked up in 1188 // the scope of T. If this lookup fails to find the name, or if 1189 // the allocated type is not a class type or array thereof, the 1190 // deallocation function's name is looked up in the global scope. 1191 LookupResult FoundDelete(*this, DeleteName, StartLoc, LookupOrdinaryName); 1192 if (AllocElemType->isRecordType() && !UseGlobal) { 1193 CXXRecordDecl *RD 1194 = cast<CXXRecordDecl>(AllocElemType->getAs<RecordType>()->getDecl()); 1195 LookupQualifiedName(FoundDelete, RD); 1196 } 1197 if (FoundDelete.isAmbiguous()) 1198 return true; // FIXME: clean up expressions? 1199 1200 if (FoundDelete.empty()) { 1201 DeclareGlobalNewDelete(); 1202 LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl()); 1203 } 1204 1205 FoundDelete.suppressDiagnostics(); 1206 1207 llvm::SmallVector<std::pair<DeclAccessPair,FunctionDecl*>, 2> Matches; 1208 1209 // Whether we're looking for a placement operator delete is dictated 1210 // by whether we selected a placement operator new, not by whether 1211 // we had explicit placement arguments. This matters for things like 1212 // struct A { void *operator new(size_t, int = 0); ... }; 1213 // A *a = new A() 1214 bool isPlacementNew = (NumPlaceArgs > 0 || OperatorNew->param_size() != 1); 1215 1216 if (isPlacementNew) { 1217 // C++ [expr.new]p20: 1218 // A declaration of a placement deallocation function matches the 1219 // declaration of a placement allocation function if it has the 1220 // same number of parameters and, after parameter transformations 1221 // (8.3.5), all parameter types except the first are 1222 // identical. [...] 1223 // 1224 // To perform this comparison, we compute the function type that 1225 // the deallocation function should have, and use that type both 1226 // for template argument deduction and for comparison purposes. 1227 // 1228 // FIXME: this comparison should ignore CC and the like. 1229 QualType ExpectedFunctionType; 1230 { 1231 const FunctionProtoType *Proto 1232 = OperatorNew->getType()->getAs<FunctionProtoType>(); 1233 1234 llvm::SmallVector<QualType, 4> ArgTypes; 1235 ArgTypes.push_back(Context.VoidPtrTy); 1236 for (unsigned I = 1, N = Proto->getNumArgs(); I < N; ++I) 1237 ArgTypes.push_back(Proto->getArgType(I)); 1238 1239 FunctionProtoType::ExtProtoInfo EPI; 1240 EPI.Variadic = Proto->isVariadic(); 1241 1242 ExpectedFunctionType 1243 = Context.getFunctionType(Context.VoidTy, ArgTypes.data(), 1244 ArgTypes.size(), EPI); 1245 } 1246 1247 for (LookupResult::iterator D = FoundDelete.begin(), 1248 DEnd = FoundDelete.end(); 1249 D != DEnd; ++D) { 1250 FunctionDecl *Fn = 0; 1251 if (FunctionTemplateDecl *FnTmpl 1252 = dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) { 1253 // Perform template argument deduction to try to match the 1254 // expected function type. 1255 TemplateDeductionInfo Info(Context, StartLoc); 1256 if (DeduceTemplateArguments(FnTmpl, 0, ExpectedFunctionType, Fn, Info)) 1257 continue; 1258 } else 1259 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl()); 1260 1261 if (Context.hasSameType(Fn->getType(), ExpectedFunctionType)) 1262 Matches.push_back(std::make_pair(D.getPair(), Fn)); 1263 } 1264 } else { 1265 // C++ [expr.new]p20: 1266 // [...] Any non-placement deallocation function matches a 1267 // non-placement allocation function. [...] 1268 for (LookupResult::iterator D = FoundDelete.begin(), 1269 DEnd = FoundDelete.end(); 1270 D != DEnd; ++D) { 1271 if (FunctionDecl *Fn = dyn_cast<FunctionDecl>((*D)->getUnderlyingDecl())) 1272 if (isNonPlacementDeallocationFunction(Fn)) 1273 Matches.push_back(std::make_pair(D.getPair(), Fn)); 1274 } 1275 } 1276 1277 // C++ [expr.new]p20: 1278 // [...] If the lookup finds a single matching deallocation 1279 // function, that function will be called; otherwise, no 1280 // deallocation function will be called. 1281 if (Matches.size() == 1) { 1282 OperatorDelete = Matches[0].second; 1283 1284 // C++0x [expr.new]p20: 1285 // If the lookup finds the two-parameter form of a usual 1286 // deallocation function (3.7.4.2) and that function, considered 1287 // as a placement deallocation function, would have been 1288 // selected as a match for the allocation function, the program 1289 // is ill-formed. 1290 if (NumPlaceArgs && getLangOptions().CPlusPlus0x && 1291 isNonPlacementDeallocationFunction(OperatorDelete)) { 1292 Diag(StartLoc, diag::err_placement_new_non_placement_delete) 1293 << SourceRange(PlaceArgs[0]->getLocStart(), 1294 PlaceArgs[NumPlaceArgs - 1]->getLocEnd()); 1295 Diag(OperatorDelete->getLocation(), diag::note_previous_decl) 1296 << DeleteName; 1297 } else { 1298 CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(), 1299 Matches[0].first); 1300 } 1301 } 1302 1303 return false; 1304} 1305 1306/// FindAllocationOverload - Find an fitting overload for the allocation 1307/// function in the specified scope. 1308bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range, 1309 DeclarationName Name, Expr** Args, 1310 unsigned NumArgs, DeclContext *Ctx, 1311 bool AllowMissing, FunctionDecl *&Operator) { 1312 LookupResult R(*this, Name, StartLoc, LookupOrdinaryName); 1313 LookupQualifiedName(R, Ctx); 1314 if (R.empty()) { 1315 if (AllowMissing) 1316 return false; 1317 return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call) 1318 << Name << Range; 1319 } 1320 1321 if (R.isAmbiguous()) 1322 return true; 1323 1324 R.suppressDiagnostics(); 1325 1326 OverloadCandidateSet Candidates(StartLoc); 1327 for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end(); 1328 Alloc != AllocEnd; ++Alloc) { 1329 // Even member operator new/delete are implicitly treated as 1330 // static, so don't use AddMemberCandidate. 1331 NamedDecl *D = (*Alloc)->getUnderlyingDecl(); 1332 1333 if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) { 1334 AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(), 1335 /*ExplicitTemplateArgs=*/0, Args, NumArgs, 1336 Candidates, 1337 /*SuppressUserConversions=*/false); 1338 continue; 1339 } 1340 1341 FunctionDecl *Fn = cast<FunctionDecl>(D); 1342 AddOverloadCandidate(Fn, Alloc.getPair(), Args, NumArgs, Candidates, 1343 /*SuppressUserConversions=*/false); 1344 } 1345 1346 // Do the resolution. 1347 OverloadCandidateSet::iterator Best; 1348 switch (Candidates.BestViableFunction(*this, StartLoc, Best)) { 1349 case OR_Success: { 1350 // Got one! 1351 FunctionDecl *FnDecl = Best->Function; 1352 MarkDeclarationReferenced(StartLoc, FnDecl); 1353 // The first argument is size_t, and the first parameter must be size_t, 1354 // too. This is checked on declaration and can be assumed. (It can't be 1355 // asserted on, though, since invalid decls are left in there.) 1356 // Watch out for variadic allocator function. 1357 unsigned NumArgsInFnDecl = FnDecl->getNumParams(); 1358 for (unsigned i = 0; (i < NumArgs && i < NumArgsInFnDecl); ++i) { 1359 ExprResult Result 1360 = PerformCopyInitialization(InitializedEntity::InitializeParameter( 1361 Context, 1362 FnDecl->getParamDecl(i)), 1363 SourceLocation(), 1364 Owned(Args[i])); 1365 if (Result.isInvalid()) 1366 return true; 1367 1368 Args[i] = Result.takeAs<Expr>(); 1369 } 1370 Operator = FnDecl; 1371 CheckAllocationAccess(StartLoc, Range, R.getNamingClass(), Best->FoundDecl); 1372 return false; 1373 } 1374 1375 case OR_No_Viable_Function: 1376 Diag(StartLoc, diag::err_ovl_no_viable_function_in_call) 1377 << Name << Range; 1378 Candidates.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs); 1379 return true; 1380 1381 case OR_Ambiguous: 1382 Diag(StartLoc, diag::err_ovl_ambiguous_call) 1383 << Name << Range; 1384 Candidates.NoteCandidates(*this, OCD_ViableCandidates, Args, NumArgs); 1385 return true; 1386 1387 case OR_Deleted: 1388 Diag(StartLoc, diag::err_ovl_deleted_call) 1389 << Best->Function->isDeleted() 1390 << Name 1391 << Best->Function->getMessageUnavailableAttr( 1392 !Best->Function->isDeleted()) 1393 << Range; 1394 Candidates.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs); 1395 return true; 1396 } 1397 assert(false && "Unreachable, bad result from BestViableFunction"); 1398 return true; 1399} 1400 1401 1402/// DeclareGlobalNewDelete - Declare the global forms of operator new and 1403/// delete. These are: 1404/// @code 1405/// void* operator new(std::size_t) throw(std::bad_alloc); 1406/// void* operator new[](std::size_t) throw(std::bad_alloc); 1407/// void operator delete(void *) throw(); 1408/// void operator delete[](void *) throw(); 1409/// @endcode 1410/// Note that the placement and nothrow forms of new are *not* implicitly 1411/// declared. Their use requires including \<new\>. 1412void Sema::DeclareGlobalNewDelete() { 1413 if (GlobalNewDeleteDeclared) 1414 return; 1415 1416 // C++ [basic.std.dynamic]p2: 1417 // [...] The following allocation and deallocation functions (18.4) are 1418 // implicitly declared in global scope in each translation unit of a 1419 // program 1420 // 1421 // void* operator new(std::size_t) throw(std::bad_alloc); 1422 // void* operator new[](std::size_t) throw(std::bad_alloc); 1423 // void operator delete(void*) throw(); 1424 // void operator delete[](void*) throw(); 1425 // 1426 // These implicit declarations introduce only the function names operator 1427 // new, operator new[], operator delete, operator delete[]. 1428 // 1429 // Here, we need to refer to std::bad_alloc, so we will implicitly declare 1430 // "std" or "bad_alloc" as necessary to form the exception specification. 1431 // However, we do not make these implicit declarations visible to name 1432 // lookup. 1433 if (!StdBadAlloc) { 1434 // The "std::bad_alloc" class has not yet been declared, so build it 1435 // implicitly. 1436 StdBadAlloc = CXXRecordDecl::Create(Context, TTK_Class, 1437 getOrCreateStdNamespace(), 1438 SourceLocation(), 1439 &PP.getIdentifierTable().get("bad_alloc"), 1440 SourceLocation(), 0); 1441 getStdBadAlloc()->setImplicit(true); 1442 } 1443 1444 GlobalNewDeleteDeclared = true; 1445 1446 QualType VoidPtr = Context.getPointerType(Context.VoidTy); 1447 QualType SizeT = Context.getSizeType(); 1448 bool AssumeSaneOperatorNew = getLangOptions().AssumeSaneOperatorNew; 1449 1450 DeclareGlobalAllocationFunction( 1451 Context.DeclarationNames.getCXXOperatorName(OO_New), 1452 VoidPtr, SizeT, AssumeSaneOperatorNew); 1453 DeclareGlobalAllocationFunction( 1454 Context.DeclarationNames.getCXXOperatorName(OO_Array_New), 1455 VoidPtr, SizeT, AssumeSaneOperatorNew); 1456 DeclareGlobalAllocationFunction( 1457 Context.DeclarationNames.getCXXOperatorName(OO_Delete), 1458 Context.VoidTy, VoidPtr); 1459 DeclareGlobalAllocationFunction( 1460 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete), 1461 Context.VoidTy, VoidPtr); 1462} 1463 1464/// DeclareGlobalAllocationFunction - Declares a single implicit global 1465/// allocation function if it doesn't already exist. 1466void Sema::DeclareGlobalAllocationFunction(DeclarationName Name, 1467 QualType Return, QualType Argument, 1468 bool AddMallocAttr) { 1469 DeclContext *GlobalCtx = Context.getTranslationUnitDecl(); 1470 1471 // Check if this function is already declared. 1472 { 1473 DeclContext::lookup_iterator Alloc, AllocEnd; 1474 for (llvm::tie(Alloc, AllocEnd) = GlobalCtx->lookup(Name); 1475 Alloc != AllocEnd; ++Alloc) { 1476 // Only look at non-template functions, as it is the predefined, 1477 // non-templated allocation function we are trying to declare here. 1478 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) { 1479 QualType InitialParamType = 1480 Context.getCanonicalType( 1481 Func->getParamDecl(0)->getType().getUnqualifiedType()); 1482 // FIXME: Do we need to check for default arguments here? 1483 if (Func->getNumParams() == 1 && InitialParamType == Argument) { 1484 if(AddMallocAttr && !Func->hasAttr<MallocAttr>()) 1485 Func->addAttr(::new (Context) MallocAttr(SourceLocation(), Context)); 1486 return; 1487 } 1488 } 1489 } 1490 } 1491 1492 QualType BadAllocType; 1493 bool HasBadAllocExceptionSpec 1494 = (Name.getCXXOverloadedOperator() == OO_New || 1495 Name.getCXXOverloadedOperator() == OO_Array_New); 1496 if (HasBadAllocExceptionSpec) { 1497 assert(StdBadAlloc && "Must have std::bad_alloc declared"); 1498 BadAllocType = Context.getTypeDeclType(getStdBadAlloc()); 1499 } 1500 1501 FunctionProtoType::ExtProtoInfo EPI; 1502 EPI.HasExceptionSpec = true; 1503 if (HasBadAllocExceptionSpec) { 1504 EPI.NumExceptions = 1; 1505 EPI.Exceptions = &BadAllocType; 1506 } 1507 1508 QualType FnType = Context.getFunctionType(Return, &Argument, 1, EPI); 1509 FunctionDecl *Alloc = 1510 FunctionDecl::Create(Context, GlobalCtx, SourceLocation(), Name, 1511 FnType, /*TInfo=*/0, SC_None, 1512 SC_None, false, true); 1513 Alloc->setImplicit(); 1514 1515 if (AddMallocAttr) 1516 Alloc->addAttr(::new (Context) MallocAttr(SourceLocation(), Context)); 1517 1518 ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(), 1519 0, Argument, /*TInfo=*/0, 1520 SC_None, 1521 SC_None, 0); 1522 Alloc->setParams(&Param, 1); 1523 1524 // FIXME: Also add this declaration to the IdentifierResolver, but 1525 // make sure it is at the end of the chain to coincide with the 1526 // global scope. 1527 Context.getTranslationUnitDecl()->addDecl(Alloc); 1528} 1529 1530bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, 1531 DeclarationName Name, 1532 FunctionDecl* &Operator) { 1533 LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName); 1534 // Try to find operator delete/operator delete[] in class scope. 1535 LookupQualifiedName(Found, RD); 1536 1537 if (Found.isAmbiguous()) 1538 return true; 1539 1540 Found.suppressDiagnostics(); 1541 1542 llvm::SmallVector<DeclAccessPair,4> Matches; 1543 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end(); 1544 F != FEnd; ++F) { 1545 NamedDecl *ND = (*F)->getUnderlyingDecl(); 1546 1547 // Ignore template operator delete members from the check for a usual 1548 // deallocation function. 1549 if (isa<FunctionTemplateDecl>(ND)) 1550 continue; 1551 1552 if (cast<CXXMethodDecl>(ND)->isUsualDeallocationFunction()) 1553 Matches.push_back(F.getPair()); 1554 } 1555 1556 // There's exactly one suitable operator; pick it. 1557 if (Matches.size() == 1) { 1558 Operator = cast<CXXMethodDecl>(Matches[0]->getUnderlyingDecl()); 1559 CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(), 1560 Matches[0]); 1561 return false; 1562 1563 // We found multiple suitable operators; complain about the ambiguity. 1564 } else if (!Matches.empty()) { 1565 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found) 1566 << Name << RD; 1567 1568 for (llvm::SmallVectorImpl<DeclAccessPair>::iterator 1569 F = Matches.begin(), FEnd = Matches.end(); F != FEnd; ++F) 1570 Diag((*F)->getUnderlyingDecl()->getLocation(), 1571 diag::note_member_declared_here) << Name; 1572 return true; 1573 } 1574 1575 // We did find operator delete/operator delete[] declarations, but 1576 // none of them were suitable. 1577 if (!Found.empty()) { 1578 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found) 1579 << Name << RD; 1580 1581 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end(); 1582 F != FEnd; ++F) 1583 Diag((*F)->getUnderlyingDecl()->getLocation(), 1584 diag::note_member_declared_here) << Name; 1585 1586 return true; 1587 } 1588 1589 // Look for a global declaration. 1590 DeclareGlobalNewDelete(); 1591 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 1592 1593 CXXNullPtrLiteralExpr Null(Context.VoidPtrTy, SourceLocation()); 1594 Expr* DeallocArgs[1]; 1595 DeallocArgs[0] = &Null; 1596 if (FindAllocationOverload(StartLoc, SourceRange(), Name, 1597 DeallocArgs, 1, TUDecl, /*AllowMissing=*/false, 1598 Operator)) 1599 return true; 1600 1601 assert(Operator && "Did not find a deallocation function!"); 1602 return false; 1603} 1604 1605/// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in: 1606/// @code ::delete ptr; @endcode 1607/// or 1608/// @code delete [] ptr; @endcode 1609ExprResult 1610Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, 1611 bool ArrayForm, Expr *Ex) { 1612 // C++ [expr.delete]p1: 1613 // The operand shall have a pointer type, or a class type having a single 1614 // conversion function to a pointer type. The result has type void. 1615 // 1616 // DR599 amends "pointer type" to "pointer to object type" in both cases. 1617 1618 FunctionDecl *OperatorDelete = 0; 1619 bool ArrayFormAsWritten = ArrayForm; 1620 bool UsualArrayDeleteWantsSize = false; 1621 1622 if (!Ex->isTypeDependent()) { 1623 QualType Type = Ex->getType(); 1624 1625 if (const RecordType *Record = Type->getAs<RecordType>()) { 1626 if (RequireCompleteType(StartLoc, Type, 1627 PDiag(diag::err_delete_incomplete_class_type))) 1628 return ExprError(); 1629 1630 llvm::SmallVector<CXXConversionDecl*, 4> ObjectPtrConversions; 1631 1632 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); 1633 const UnresolvedSetImpl *Conversions = RD->getVisibleConversionFunctions(); 1634 for (UnresolvedSetImpl::iterator I = Conversions->begin(), 1635 E = Conversions->end(); I != E; ++I) { 1636 NamedDecl *D = I.getDecl(); 1637 if (isa<UsingShadowDecl>(D)) 1638 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 1639 1640 // Skip over templated conversion functions; they aren't considered. 1641 if (isa<FunctionTemplateDecl>(D)) 1642 continue; 1643 1644 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D); 1645 1646 QualType ConvType = Conv->getConversionType().getNonReferenceType(); 1647 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>()) 1648 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType()) 1649 ObjectPtrConversions.push_back(Conv); 1650 } 1651 if (ObjectPtrConversions.size() == 1) { 1652 // We have a single conversion to a pointer-to-object type. Perform 1653 // that conversion. 1654 // TODO: don't redo the conversion calculation. 1655 if (!PerformImplicitConversion(Ex, 1656 ObjectPtrConversions.front()->getConversionType(), 1657 AA_Converting)) { 1658 Type = Ex->getType(); 1659 } 1660 } 1661 else if (ObjectPtrConversions.size() > 1) { 1662 Diag(StartLoc, diag::err_ambiguous_delete_operand) 1663 << Type << Ex->getSourceRange(); 1664 for (unsigned i= 0; i < ObjectPtrConversions.size(); i++) 1665 NoteOverloadCandidate(ObjectPtrConversions[i]); 1666 return ExprError(); 1667 } 1668 } 1669 1670 if (!Type->isPointerType()) 1671 return ExprError(Diag(StartLoc, diag::err_delete_operand) 1672 << Type << Ex->getSourceRange()); 1673 1674 QualType Pointee = Type->getAs<PointerType>()->getPointeeType(); 1675 if (Pointee->isVoidType() && !isSFINAEContext()) { 1676 // The C++ standard bans deleting a pointer to a non-object type, which 1677 // effectively bans deletion of "void*". However, most compilers support 1678 // this, so we treat it as a warning unless we're in a SFINAE context. 1679 Diag(StartLoc, diag::ext_delete_void_ptr_operand) 1680 << Type << Ex->getSourceRange(); 1681 } else if (Pointee->isFunctionType() || Pointee->isVoidType()) 1682 return ExprError(Diag(StartLoc, diag::err_delete_operand) 1683 << Type << Ex->getSourceRange()); 1684 else if (!Pointee->isDependentType() && 1685 RequireCompleteType(StartLoc, Pointee, 1686 PDiag(diag::warn_delete_incomplete) 1687 << Ex->getSourceRange())) 1688 return ExprError(); 1689 1690 // C++ [expr.delete]p2: 1691 // [Note: a pointer to a const type can be the operand of a 1692 // delete-expression; it is not necessary to cast away the constness 1693 // (5.2.11) of the pointer expression before it is used as the operand 1694 // of the delete-expression. ] 1695 ImpCastExprToType(Ex, Context.getPointerType(Context.VoidTy), 1696 CK_NoOp); 1697 1698 if (Pointee->isArrayType() && !ArrayForm) { 1699 Diag(StartLoc, diag::warn_delete_array_type) 1700 << Type << Ex->getSourceRange() 1701 << FixItHint::CreateInsertion(PP.getLocForEndOfToken(StartLoc), "[]"); 1702 ArrayForm = true; 1703 } 1704 1705 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName( 1706 ArrayForm ? OO_Array_Delete : OO_Delete); 1707 1708 QualType PointeeElem = Context.getBaseElementType(Pointee); 1709 if (const RecordType *RT = PointeeElem->getAs<RecordType>()) { 1710 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1711 1712 if (!UseGlobal && 1713 FindDeallocationFunction(StartLoc, RD, DeleteName, OperatorDelete)) 1714 return ExprError(); 1715 1716 // If we're allocating an array of records, check whether the 1717 // usual operator delete[] has a size_t parameter. 1718 if (ArrayForm) { 1719 // If the user specifically asked to use the global allocator, 1720 // we'll need to do the lookup into the class. 1721 if (UseGlobal) 1722 UsualArrayDeleteWantsSize = 1723 doesUsualArrayDeleteWantSize(*this, StartLoc, PointeeElem); 1724 1725 // Otherwise, the usual operator delete[] should be the 1726 // function we just found. 1727 else if (isa<CXXMethodDecl>(OperatorDelete)) 1728 UsualArrayDeleteWantsSize = (OperatorDelete->getNumParams() == 2); 1729 } 1730 1731 if (!RD->hasTrivialDestructor()) 1732 if (CXXDestructorDecl *Dtor = LookupDestructor(RD)) { 1733 MarkDeclarationReferenced(StartLoc, 1734 const_cast<CXXDestructorDecl*>(Dtor)); 1735 DiagnoseUseOfDecl(Dtor, StartLoc); 1736 } 1737 } 1738 1739 if (!OperatorDelete) { 1740 // Look for a global declaration. 1741 DeclareGlobalNewDelete(); 1742 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 1743 if (FindAllocationOverload(StartLoc, SourceRange(), DeleteName, 1744 &Ex, 1, TUDecl, /*AllowMissing=*/false, 1745 OperatorDelete)) 1746 return ExprError(); 1747 } 1748 1749 MarkDeclarationReferenced(StartLoc, OperatorDelete); 1750 1751 // Check access and ambiguity of operator delete and destructor. 1752 if (const RecordType *RT = PointeeElem->getAs<RecordType>()) { 1753 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1754 if (CXXDestructorDecl *Dtor = LookupDestructor(RD)) { 1755 CheckDestructorAccess(Ex->getExprLoc(), Dtor, 1756 PDiag(diag::err_access_dtor) << PointeeElem); 1757 } 1758 } 1759 1760 } 1761 1762 return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm, 1763 ArrayFormAsWritten, 1764 UsualArrayDeleteWantsSize, 1765 OperatorDelete, Ex, StartLoc)); 1766} 1767 1768/// \brief Check the use of the given variable as a C++ condition in an if, 1769/// while, do-while, or switch statement. 1770ExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar, 1771 SourceLocation StmtLoc, 1772 bool ConvertToBoolean) { 1773 QualType T = ConditionVar->getType(); 1774 1775 // C++ [stmt.select]p2: 1776 // The declarator shall not specify a function or an array. 1777 if (T->isFunctionType()) 1778 return ExprError(Diag(ConditionVar->getLocation(), 1779 diag::err_invalid_use_of_function_type) 1780 << ConditionVar->getSourceRange()); 1781 else if (T->isArrayType()) 1782 return ExprError(Diag(ConditionVar->getLocation(), 1783 diag::err_invalid_use_of_array_type) 1784 << ConditionVar->getSourceRange()); 1785 1786 Expr *Condition = DeclRefExpr::Create(Context, 0, SourceRange(), ConditionVar, 1787 ConditionVar->getLocation(), 1788 ConditionVar->getType().getNonReferenceType(), 1789 VK_LValue); 1790 if (ConvertToBoolean && CheckBooleanCondition(Condition, StmtLoc)) 1791 return ExprError(); 1792 1793 return Owned(Condition); 1794} 1795 1796/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid. 1797bool Sema::CheckCXXBooleanCondition(Expr *&CondExpr) { 1798 // C++ 6.4p4: 1799 // The value of a condition that is an initialized declaration in a statement 1800 // other than a switch statement is the value of the declared variable 1801 // implicitly converted to type bool. If that conversion is ill-formed, the 1802 // program is ill-formed. 1803 // The value of a condition that is an expression is the value of the 1804 // expression, implicitly converted to bool. 1805 // 1806 return PerformContextuallyConvertToBool(CondExpr); 1807} 1808 1809/// Helper function to determine whether this is the (deprecated) C++ 1810/// conversion from a string literal to a pointer to non-const char or 1811/// non-const wchar_t (for narrow and wide string literals, 1812/// respectively). 1813bool 1814Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) { 1815 // Look inside the implicit cast, if it exists. 1816 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From)) 1817 From = Cast->getSubExpr(); 1818 1819 // A string literal (2.13.4) that is not a wide string literal can 1820 // be converted to an rvalue of type "pointer to char"; a wide 1821 // string literal can be converted to an rvalue of type "pointer 1822 // to wchar_t" (C++ 4.2p2). 1823 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From->IgnoreParens())) 1824 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) 1825 if (const BuiltinType *ToPointeeType 1826 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) { 1827 // This conversion is considered only when there is an 1828 // explicit appropriate pointer target type (C++ 4.2p2). 1829 if (!ToPtrType->getPointeeType().hasQualifiers() && 1830 ((StrLit->isWide() && ToPointeeType->isWideCharType()) || 1831 (!StrLit->isWide() && 1832 (ToPointeeType->getKind() == BuiltinType::Char_U || 1833 ToPointeeType->getKind() == BuiltinType::Char_S)))) 1834 return true; 1835 } 1836 1837 return false; 1838} 1839 1840static ExprResult BuildCXXCastArgument(Sema &S, 1841 SourceLocation CastLoc, 1842 QualType Ty, 1843 CastKind Kind, 1844 CXXMethodDecl *Method, 1845 NamedDecl *FoundDecl, 1846 Expr *From) { 1847 switch (Kind) { 1848 default: assert(0 && "Unhandled cast kind!"); 1849 case CK_ConstructorConversion: { 1850 ASTOwningVector<Expr*> ConstructorArgs(S); 1851 1852 if (S.CompleteConstructorCall(cast<CXXConstructorDecl>(Method), 1853 MultiExprArg(&From, 1), 1854 CastLoc, ConstructorArgs)) 1855 return ExprError(); 1856 1857 ExprResult Result = 1858 S.BuildCXXConstructExpr(CastLoc, Ty, cast<CXXConstructorDecl>(Method), 1859 move_arg(ConstructorArgs), 1860 /*ZeroInit*/ false, CXXConstructExpr::CK_Complete, 1861 SourceRange()); 1862 if (Result.isInvalid()) 1863 return ExprError(); 1864 1865 return S.MaybeBindToTemporary(Result.takeAs<Expr>()); 1866 } 1867 1868 case CK_UserDefinedConversion: { 1869 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!"); 1870 1871 // Create an implicit call expr that calls it. 1872 ExprResult Result = S.BuildCXXMemberCallExpr(From, FoundDecl, Method); 1873 if (Result.isInvalid()) 1874 return ExprError(); 1875 1876 return S.MaybeBindToTemporary(Result.get()); 1877 } 1878 } 1879} 1880 1881/// PerformImplicitConversion - Perform an implicit conversion of the 1882/// expression From to the type ToType using the pre-computed implicit 1883/// conversion sequence ICS. Returns true if there was an error, false 1884/// otherwise. The expression From is replaced with the converted 1885/// expression. Action is the kind of conversion we're performing, 1886/// used in the error message. 1887bool 1888Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1889 const ImplicitConversionSequence &ICS, 1890 AssignmentAction Action, bool CStyle) { 1891 switch (ICS.getKind()) { 1892 case ImplicitConversionSequence::StandardConversion: 1893 if (PerformImplicitConversion(From, ToType, ICS.Standard, Action, 1894 CStyle)) 1895 return true; 1896 break; 1897 1898 case ImplicitConversionSequence::UserDefinedConversion: { 1899 1900 FunctionDecl *FD = ICS.UserDefined.ConversionFunction; 1901 CastKind CastKind; 1902 QualType BeforeToType; 1903 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) { 1904 CastKind = CK_UserDefinedConversion; 1905 1906 // If the user-defined conversion is specified by a conversion function, 1907 // the initial standard conversion sequence converts the source type to 1908 // the implicit object parameter of the conversion function. 1909 BeforeToType = Context.getTagDeclType(Conv->getParent()); 1910 } else { 1911 const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(FD); 1912 CastKind = CK_ConstructorConversion; 1913 // Do no conversion if dealing with ... for the first conversion. 1914 if (!ICS.UserDefined.EllipsisConversion) { 1915 // If the user-defined conversion is specified by a constructor, the 1916 // initial standard conversion sequence converts the source type to the 1917 // type required by the argument of the constructor 1918 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType(); 1919 } 1920 } 1921 // Watch out for elipsis conversion. 1922 if (!ICS.UserDefined.EllipsisConversion) { 1923 if (PerformImplicitConversion(From, BeforeToType, 1924 ICS.UserDefined.Before, AA_Converting, 1925 CStyle)) 1926 return true; 1927 } 1928 1929 ExprResult CastArg 1930 = BuildCXXCastArgument(*this, 1931 From->getLocStart(), 1932 ToType.getNonReferenceType(), 1933 CastKind, cast<CXXMethodDecl>(FD), 1934 ICS.UserDefined.FoundConversionFunction, 1935 From); 1936 1937 if (CastArg.isInvalid()) 1938 return true; 1939 1940 From = CastArg.takeAs<Expr>(); 1941 1942 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After, 1943 AA_Converting, CStyle); 1944 } 1945 1946 case ImplicitConversionSequence::AmbiguousConversion: 1947 ICS.DiagnoseAmbiguousConversion(*this, From->getExprLoc(), 1948 PDiag(diag::err_typecheck_ambiguous_condition) 1949 << From->getSourceRange()); 1950 return true; 1951 1952 case ImplicitConversionSequence::EllipsisConversion: 1953 assert(false && "Cannot perform an ellipsis conversion"); 1954 return false; 1955 1956 case ImplicitConversionSequence::BadConversion: 1957 return true; 1958 } 1959 1960 // Everything went well. 1961 return false; 1962} 1963 1964/// PerformImplicitConversion - Perform an implicit conversion of the 1965/// expression From to the type ToType by following the standard 1966/// conversion sequence SCS. Returns true if there was an error, false 1967/// otherwise. The expression From is replaced with the converted 1968/// expression. Flavor is the context in which we're performing this 1969/// conversion, for use in error messages. 1970bool 1971Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1972 const StandardConversionSequence& SCS, 1973 AssignmentAction Action, bool CStyle) { 1974 // Overall FIXME: we are recomputing too many types here and doing far too 1975 // much extra work. What this means is that we need to keep track of more 1976 // information that is computed when we try the implicit conversion initially, 1977 // so that we don't need to recompute anything here. 1978 QualType FromType = From->getType(); 1979 1980 if (SCS.CopyConstructor) { 1981 // FIXME: When can ToType be a reference type? 1982 assert(!ToType->isReferenceType()); 1983 if (SCS.Second == ICK_Derived_To_Base) { 1984 ASTOwningVector<Expr*> ConstructorArgs(*this); 1985 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor), 1986 MultiExprArg(*this, &From, 1), 1987 /*FIXME:ConstructLoc*/SourceLocation(), 1988 ConstructorArgs)) 1989 return true; 1990 ExprResult FromResult = 1991 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 1992 ToType, SCS.CopyConstructor, 1993 move_arg(ConstructorArgs), 1994 /*ZeroInit*/ false, 1995 CXXConstructExpr::CK_Complete, 1996 SourceRange()); 1997 if (FromResult.isInvalid()) 1998 return true; 1999 From = FromResult.takeAs<Expr>(); 2000 return false; 2001 } 2002 ExprResult FromResult = 2003 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 2004 ToType, SCS.CopyConstructor, 2005 MultiExprArg(*this, &From, 1), 2006 /*ZeroInit*/ false, 2007 CXXConstructExpr::CK_Complete, 2008 SourceRange()); 2009 2010 if (FromResult.isInvalid()) 2011 return true; 2012 2013 From = FromResult.takeAs<Expr>(); 2014 return false; 2015 } 2016 2017 // Resolve overloaded function references. 2018 if (Context.hasSameType(FromType, Context.OverloadTy)) { 2019 DeclAccessPair Found; 2020 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, 2021 true, Found); 2022 if (!Fn) 2023 return true; 2024 2025 if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin())) 2026 return true; 2027 2028 From = FixOverloadedFunctionReference(From, Found, Fn); 2029 FromType = From->getType(); 2030 } 2031 2032 // Perform the first implicit conversion. 2033 switch (SCS.First) { 2034 case ICK_Identity: 2035 // Nothing to do. 2036 break; 2037 2038 case ICK_Lvalue_To_Rvalue: 2039 // Should this get its own ICK? 2040 if (From->getObjectKind() == OK_ObjCProperty) { 2041 ConvertPropertyForRValue(From); 2042 if (!From->isGLValue()) break; 2043 } 2044 2045 // Check for trivial buffer overflows. 2046 if (const ArraySubscriptExpr *AE = dyn_cast<ArraySubscriptExpr>(From)) 2047 CheckArrayAccess(AE); 2048 2049 FromType = FromType.getUnqualifiedType(); 2050 From = ImplicitCastExpr::Create(Context, FromType, CK_LValueToRValue, 2051 From, 0, VK_RValue); 2052 break; 2053 2054 case ICK_Array_To_Pointer: 2055 FromType = Context.getArrayDecayedType(FromType); 2056 ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay); 2057 break; 2058 2059 case ICK_Function_To_Pointer: 2060 FromType = Context.getPointerType(FromType); 2061 ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay); 2062 break; 2063 2064 default: 2065 assert(false && "Improper first standard conversion"); 2066 break; 2067 } 2068 2069 // Perform the second implicit conversion 2070 switch (SCS.Second) { 2071 case ICK_Identity: 2072 // If both sides are functions (or pointers/references to them), there could 2073 // be incompatible exception declarations. 2074 if (CheckExceptionSpecCompatibility(From, ToType)) 2075 return true; 2076 // Nothing else to do. 2077 break; 2078 2079 case ICK_NoReturn_Adjustment: 2080 // If both sides are functions (or pointers/references to them), there could 2081 // be incompatible exception declarations. 2082 if (CheckExceptionSpecCompatibility(From, ToType)) 2083 return true; 2084 2085 ImpCastExprToType(From, ToType, CK_NoOp); 2086 break; 2087 2088 case ICK_Integral_Promotion: 2089 case ICK_Integral_Conversion: 2090 ImpCastExprToType(From, ToType, CK_IntegralCast); 2091 break; 2092 2093 case ICK_Floating_Promotion: 2094 case ICK_Floating_Conversion: 2095 ImpCastExprToType(From, ToType, CK_FloatingCast); 2096 break; 2097 2098 case ICK_Complex_Promotion: 2099 case ICK_Complex_Conversion: { 2100 QualType FromEl = From->getType()->getAs<ComplexType>()->getElementType(); 2101 QualType ToEl = ToType->getAs<ComplexType>()->getElementType(); 2102 CastKind CK; 2103 if (FromEl->isRealFloatingType()) { 2104 if (ToEl->isRealFloatingType()) 2105 CK = CK_FloatingComplexCast; 2106 else 2107 CK = CK_FloatingComplexToIntegralComplex; 2108 } else if (ToEl->isRealFloatingType()) { 2109 CK = CK_IntegralComplexToFloatingComplex; 2110 } else { 2111 CK = CK_IntegralComplexCast; 2112 } 2113 ImpCastExprToType(From, ToType, CK); 2114 break; 2115 } 2116 2117 case ICK_Floating_Integral: 2118 if (ToType->isRealFloatingType()) 2119 ImpCastExprToType(From, ToType, CK_IntegralToFloating); 2120 else 2121 ImpCastExprToType(From, ToType, CK_FloatingToIntegral); 2122 break; 2123 2124 case ICK_Compatible_Conversion: 2125 ImpCastExprToType(From, ToType, CK_NoOp); 2126 break; 2127 2128 case ICK_Pointer_Conversion: { 2129 if (SCS.IncompatibleObjC && Action != AA_Casting) { 2130 // Diagnose incompatible Objective-C conversions 2131 Diag(From->getSourceRange().getBegin(), 2132 diag::ext_typecheck_convert_incompatible_pointer) 2133 << From->getType() << ToType << Action 2134 << From->getSourceRange(); 2135 } 2136 2137 CastKind Kind = CK_Invalid; 2138 CXXCastPath BasePath; 2139 if (CheckPointerConversion(From, ToType, Kind, BasePath, CStyle)) 2140 return true; 2141 ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath); 2142 break; 2143 } 2144 2145 case ICK_Pointer_Member: { 2146 CastKind Kind = CK_Invalid; 2147 CXXCastPath BasePath; 2148 if (CheckMemberPointerConversion(From, ToType, Kind, BasePath, CStyle)) 2149 return true; 2150 if (CheckExceptionSpecCompatibility(From, ToType)) 2151 return true; 2152 ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath); 2153 break; 2154 } 2155 case ICK_Boolean_Conversion: { 2156 CastKind Kind = CK_Invalid; 2157 switch (FromType->getScalarTypeKind()) { 2158 case Type::STK_Pointer: Kind = CK_PointerToBoolean; break; 2159 case Type::STK_MemberPointer: Kind = CK_MemberPointerToBoolean; break; 2160 case Type::STK_Bool: llvm_unreachable("bool -> bool conversion?"); 2161 case Type::STK_Integral: Kind = CK_IntegralToBoolean; break; 2162 case Type::STK_Floating: Kind = CK_FloatingToBoolean; break; 2163 case Type::STK_IntegralComplex: Kind = CK_IntegralComplexToBoolean; break; 2164 case Type::STK_FloatingComplex: Kind = CK_FloatingComplexToBoolean; break; 2165 } 2166 2167 ImpCastExprToType(From, Context.BoolTy, Kind); 2168 break; 2169 } 2170 2171 case ICK_Derived_To_Base: { 2172 CXXCastPath BasePath; 2173 if (CheckDerivedToBaseConversion(From->getType(), 2174 ToType.getNonReferenceType(), 2175 From->getLocStart(), 2176 From->getSourceRange(), 2177 &BasePath, 2178 CStyle)) 2179 return true; 2180 2181 ImpCastExprToType(From, ToType.getNonReferenceType(), 2182 CK_DerivedToBase, CastCategory(From), 2183 &BasePath); 2184 break; 2185 } 2186 2187 case ICK_Vector_Conversion: 2188 ImpCastExprToType(From, ToType, CK_BitCast); 2189 break; 2190 2191 case ICK_Vector_Splat: 2192 ImpCastExprToType(From, ToType, CK_VectorSplat); 2193 break; 2194 2195 case ICK_Complex_Real: 2196 // Case 1. x -> _Complex y 2197 if (const ComplexType *ToComplex = ToType->getAs<ComplexType>()) { 2198 QualType ElType = ToComplex->getElementType(); 2199 bool isFloatingComplex = ElType->isRealFloatingType(); 2200 2201 // x -> y 2202 if (Context.hasSameUnqualifiedType(ElType, From->getType())) { 2203 // do nothing 2204 } else if (From->getType()->isRealFloatingType()) { 2205 ImpCastExprToType(From, ElType, 2206 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral); 2207 } else { 2208 assert(From->getType()->isIntegerType()); 2209 ImpCastExprToType(From, ElType, 2210 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast); 2211 } 2212 // y -> _Complex y 2213 ImpCastExprToType(From, ToType, 2214 isFloatingComplex ? CK_FloatingRealToComplex 2215 : CK_IntegralRealToComplex); 2216 2217 // Case 2. _Complex x -> y 2218 } else { 2219 const ComplexType *FromComplex = From->getType()->getAs<ComplexType>(); 2220 assert(FromComplex); 2221 2222 QualType ElType = FromComplex->getElementType(); 2223 bool isFloatingComplex = ElType->isRealFloatingType(); 2224 2225 // _Complex x -> x 2226 ImpCastExprToType(From, ElType, 2227 isFloatingComplex ? CK_FloatingComplexToReal 2228 : CK_IntegralComplexToReal); 2229 2230 // x -> y 2231 if (Context.hasSameUnqualifiedType(ElType, ToType)) { 2232 // do nothing 2233 } else if (ToType->isRealFloatingType()) { 2234 ImpCastExprToType(From, ToType, 2235 isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating); 2236 } else { 2237 assert(ToType->isIntegerType()); 2238 ImpCastExprToType(From, ToType, 2239 isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast); 2240 } 2241 } 2242 break; 2243 2244 case ICK_Block_Pointer_Conversion: { 2245 ImpCastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast, VK_RValue); 2246 break; 2247 } 2248 2249 case ICK_Lvalue_To_Rvalue: 2250 case ICK_Array_To_Pointer: 2251 case ICK_Function_To_Pointer: 2252 case ICK_Qualification: 2253 case ICK_Num_Conversion_Kinds: 2254 assert(false && "Improper second standard conversion"); 2255 break; 2256 } 2257 2258 switch (SCS.Third) { 2259 case ICK_Identity: 2260 // Nothing to do. 2261 break; 2262 2263 case ICK_Qualification: { 2264 // The qualification keeps the category of the inner expression, unless the 2265 // target type isn't a reference. 2266 ExprValueKind VK = ToType->isReferenceType() ? 2267 CastCategory(From) : VK_RValue; 2268 ImpCastExprToType(From, ToType.getNonLValueExprType(Context), 2269 CK_NoOp, VK); 2270 2271 if (SCS.DeprecatedStringLiteralToCharPtr) 2272 Diag(From->getLocStart(), diag::warn_deprecated_string_literal_conversion) 2273 << ToType.getNonReferenceType(); 2274 2275 break; 2276 } 2277 2278 default: 2279 assert(false && "Improper third standard conversion"); 2280 break; 2281 } 2282 2283 return false; 2284} 2285 2286ExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait UTT, 2287 SourceLocation KWLoc, 2288 ParsedType Ty, 2289 SourceLocation RParen) { 2290 TypeSourceInfo *TSInfo; 2291 QualType T = GetTypeFromParser(Ty, &TSInfo); 2292 2293 if (!TSInfo) 2294 TSInfo = Context.getTrivialTypeSourceInfo(T); 2295 return BuildUnaryTypeTrait(UTT, KWLoc, TSInfo, RParen); 2296} 2297 2298static bool EvaluateUnaryTypeTrait(Sema &Self, UnaryTypeTrait UTT, QualType T, 2299 SourceLocation KeyLoc) { 2300 // FIXME: For many of these traits, we need a complete type before we can 2301 // check these properties. 2302 assert(!T->isDependentType() && 2303 "Cannot evaluate traits for dependent types."); 2304 ASTContext &C = Self.Context; 2305 switch(UTT) { 2306 default: assert(false && "Unknown type trait or not implemented"); 2307 case UTT_IsPOD: return T->isPODType(); 2308 case UTT_IsLiteral: return T->isLiteralType(); 2309 case UTT_IsClass: // Fallthrough 2310 case UTT_IsUnion: 2311 if (const RecordType *Record = T->getAs<RecordType>()) { 2312 bool Union = Record->getDecl()->isUnion(); 2313 return UTT == UTT_IsUnion ? Union : !Union; 2314 } 2315 return false; 2316 case UTT_IsEnum: return T->isEnumeralType(); 2317 case UTT_IsPolymorphic: 2318 if (const RecordType *Record = T->getAs<RecordType>()) { 2319 // Type traits are only parsed in C++, so we've got CXXRecords. 2320 return cast<CXXRecordDecl>(Record->getDecl())->isPolymorphic(); 2321 } 2322 return false; 2323 case UTT_IsAbstract: 2324 if (const RecordType *RT = T->getAs<RecordType>()) 2325 return cast<CXXRecordDecl>(RT->getDecl())->isAbstract(); 2326 return false; 2327 case UTT_IsEmpty: 2328 if (const RecordType *Record = T->getAs<RecordType>()) { 2329 return !Record->getDecl()->isUnion() 2330 && cast<CXXRecordDecl>(Record->getDecl())->isEmpty(); 2331 } 2332 return false; 2333 case UTT_HasTrivialConstructor: 2334 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2335 // If __is_pod (type) is true then the trait is true, else if type is 2336 // a cv class or union type (or array thereof) with a trivial default 2337 // constructor ([class.ctor]) then the trait is true, else it is false. 2338 if (T->isPODType()) 2339 return true; 2340 if (const RecordType *RT = 2341 C.getBaseElementType(T)->getAs<RecordType>()) 2342 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialConstructor(); 2343 return false; 2344 case UTT_HasTrivialCopy: 2345 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2346 // If __is_pod (type) is true or type is a reference type then 2347 // the trait is true, else if type is a cv class or union type 2348 // with a trivial copy constructor ([class.copy]) then the trait 2349 // is true, else it is false. 2350 if (T->isPODType() || T->isReferenceType()) 2351 return true; 2352 if (const RecordType *RT = T->getAs<RecordType>()) 2353 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialCopyConstructor(); 2354 return false; 2355 case UTT_HasTrivialAssign: 2356 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2357 // If type is const qualified or is a reference type then the 2358 // trait is false. Otherwise if __is_pod (type) is true then the 2359 // trait is true, else if type is a cv class or union type with 2360 // a trivial copy assignment ([class.copy]) then the trait is 2361 // true, else it is false. 2362 // Note: the const and reference restrictions are interesting, 2363 // given that const and reference members don't prevent a class 2364 // from having a trivial copy assignment operator (but do cause 2365 // errors if the copy assignment operator is actually used, q.v. 2366 // [class.copy]p12). 2367 2368 if (C.getBaseElementType(T).isConstQualified()) 2369 return false; 2370 if (T->isPODType()) 2371 return true; 2372 if (const RecordType *RT = T->getAs<RecordType>()) 2373 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialCopyAssignment(); 2374 return false; 2375 case UTT_HasTrivialDestructor: 2376 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2377 // If __is_pod (type) is true or type is a reference type 2378 // then the trait is true, else if type is a cv class or union 2379 // type (or array thereof) with a trivial destructor 2380 // ([class.dtor]) then the trait is true, else it is 2381 // false. 2382 if (T->isPODType() || T->isReferenceType()) 2383 return true; 2384 if (const RecordType *RT = 2385 C.getBaseElementType(T)->getAs<RecordType>()) 2386 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialDestructor(); 2387 return false; 2388 // TODO: Propagate nothrowness for implicitly declared special members. 2389 case UTT_HasNothrowAssign: 2390 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2391 // If type is const qualified or is a reference type then the 2392 // trait is false. Otherwise if __has_trivial_assign (type) 2393 // is true then the trait is true, else if type is a cv class 2394 // or union type with copy assignment operators that are known 2395 // not to throw an exception then the trait is true, else it is 2396 // false. 2397 if (C.getBaseElementType(T).isConstQualified()) 2398 return false; 2399 if (T->isReferenceType()) 2400 return false; 2401 if (T->isPODType()) 2402 return true; 2403 if (const RecordType *RT = T->getAs<RecordType>()) { 2404 CXXRecordDecl* RD = cast<CXXRecordDecl>(RT->getDecl()); 2405 if (RD->hasTrivialCopyAssignment()) 2406 return true; 2407 2408 bool FoundAssign = false; 2409 bool AllNoThrow = true; 2410 DeclarationName Name = C.DeclarationNames.getCXXOperatorName(OO_Equal); 2411 LookupResult Res(Self, DeclarationNameInfo(Name, KeyLoc), 2412 Sema::LookupOrdinaryName); 2413 if (Self.LookupQualifiedName(Res, RD)) { 2414 for (LookupResult::iterator Op = Res.begin(), OpEnd = Res.end(); 2415 Op != OpEnd; ++Op) { 2416 CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op); 2417 if (Operator->isCopyAssignmentOperator()) { 2418 FoundAssign = true; 2419 const FunctionProtoType *CPT 2420 = Operator->getType()->getAs<FunctionProtoType>(); 2421 if (!CPT->hasEmptyExceptionSpec()) { 2422 AllNoThrow = false; 2423 break; 2424 } 2425 } 2426 } 2427 } 2428 2429 return FoundAssign && AllNoThrow; 2430 } 2431 return false; 2432 case UTT_HasNothrowCopy: 2433 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2434 // If __has_trivial_copy (type) is true then the trait is true, else 2435 // if type is a cv class or union type with copy constructors that are 2436 // known not to throw an exception then the trait is true, else it is 2437 // false. 2438 if (T->isPODType() || T->isReferenceType()) 2439 return true; 2440 if (const RecordType *RT = T->getAs<RecordType>()) { 2441 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 2442 if (RD->hasTrivialCopyConstructor()) 2443 return true; 2444 2445 bool FoundConstructor = false; 2446 bool AllNoThrow = true; 2447 unsigned FoundTQs; 2448 DeclContext::lookup_const_iterator Con, ConEnd; 2449 for (llvm::tie(Con, ConEnd) = Self.LookupConstructors(RD); 2450 Con != ConEnd; ++Con) { 2451 // A template constructor is never a copy constructor. 2452 // FIXME: However, it may actually be selected at the actual overload 2453 // resolution point. 2454 if (isa<FunctionTemplateDecl>(*Con)) 2455 continue; 2456 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con); 2457 if (Constructor->isCopyConstructor(FoundTQs)) { 2458 FoundConstructor = true; 2459 const FunctionProtoType *CPT 2460 = Constructor->getType()->getAs<FunctionProtoType>(); 2461 // TODO: check whether evaluating default arguments can throw. 2462 // For now, we'll be conservative and assume that they can throw. 2463 if (!CPT->hasEmptyExceptionSpec() || CPT->getNumArgs() > 1) { 2464 AllNoThrow = false; 2465 break; 2466 } 2467 } 2468 } 2469 2470 return FoundConstructor && AllNoThrow; 2471 } 2472 return false; 2473 case UTT_HasNothrowConstructor: 2474 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2475 // If __has_trivial_constructor (type) is true then the trait is 2476 // true, else if type is a cv class or union type (or array 2477 // thereof) with a default constructor that is known not to 2478 // throw an exception then the trait is true, else it is false. 2479 if (T->isPODType()) 2480 return true; 2481 if (const RecordType *RT = C.getBaseElementType(T)->getAs<RecordType>()) { 2482 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 2483 if (RD->hasTrivialConstructor()) 2484 return true; 2485 2486 DeclContext::lookup_const_iterator Con, ConEnd; 2487 for (llvm::tie(Con, ConEnd) = Self.LookupConstructors(RD); 2488 Con != ConEnd; ++Con) { 2489 // FIXME: In C++0x, a constructor template can be a default constructor. 2490 if (isa<FunctionTemplateDecl>(*Con)) 2491 continue; 2492 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con); 2493 if (Constructor->isDefaultConstructor()) { 2494 const FunctionProtoType *CPT 2495 = Constructor->getType()->getAs<FunctionProtoType>(); 2496 // TODO: check whether evaluating default arguments can throw. 2497 // For now, we'll be conservative and assume that they can throw. 2498 return CPT->hasEmptyExceptionSpec() && CPT->getNumArgs() == 0; 2499 } 2500 } 2501 } 2502 return false; 2503 case UTT_HasVirtualDestructor: 2504 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2505 // If type is a class type with a virtual destructor ([class.dtor]) 2506 // then the trait is true, else it is false. 2507 if (const RecordType *Record = T->getAs<RecordType>()) { 2508 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); 2509 if (CXXDestructorDecl *Destructor = Self.LookupDestructor(RD)) 2510 return Destructor->isVirtual(); 2511 } 2512 return false; 2513 } 2514} 2515 2516ExprResult Sema::BuildUnaryTypeTrait(UnaryTypeTrait UTT, 2517 SourceLocation KWLoc, 2518 TypeSourceInfo *TSInfo, 2519 SourceLocation RParen) { 2520 QualType T = TSInfo->getType(); 2521 2522 // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html 2523 // all traits except __is_class, __is_enum and __is_union require a the type 2524 // to be complete, an array of unknown bound, or void. 2525 if (UTT != UTT_IsClass && UTT != UTT_IsEnum && UTT != UTT_IsUnion) { 2526 QualType E = T; 2527 if (T->isIncompleteArrayType()) 2528 E = Context.getAsArrayType(T)->getElementType(); 2529 if (!T->isVoidType() && 2530 RequireCompleteType(KWLoc, E, 2531 diag::err_incomplete_type_used_in_type_trait_expr)) 2532 return ExprError(); 2533 } 2534 2535 bool Value = false; 2536 if (!T->isDependentType()) 2537 Value = EvaluateUnaryTypeTrait(*this, UTT, T, KWLoc); 2538 2539 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, UTT, TSInfo, Value, 2540 RParen, Context.BoolTy)); 2541} 2542 2543ExprResult Sema::ActOnBinaryTypeTrait(BinaryTypeTrait BTT, 2544 SourceLocation KWLoc, 2545 ParsedType LhsTy, 2546 ParsedType RhsTy, 2547 SourceLocation RParen) { 2548 TypeSourceInfo *LhsTSInfo; 2549 QualType LhsT = GetTypeFromParser(LhsTy, &LhsTSInfo); 2550 if (!LhsTSInfo) 2551 LhsTSInfo = Context.getTrivialTypeSourceInfo(LhsT); 2552 2553 TypeSourceInfo *RhsTSInfo; 2554 QualType RhsT = GetTypeFromParser(RhsTy, &RhsTSInfo); 2555 if (!RhsTSInfo) 2556 RhsTSInfo = Context.getTrivialTypeSourceInfo(RhsT); 2557 2558 return BuildBinaryTypeTrait(BTT, KWLoc, LhsTSInfo, RhsTSInfo, RParen); 2559} 2560 2561static bool EvaluateBinaryTypeTrait(Sema &Self, BinaryTypeTrait BTT, 2562 QualType LhsT, QualType RhsT, 2563 SourceLocation KeyLoc) { 2564 assert((!LhsT->isDependentType() || RhsT->isDependentType()) && 2565 "Cannot evaluate traits for dependent types."); 2566 2567 switch(BTT) { 2568 case BTT_IsBaseOf: { 2569 // C++0x [meta.rel]p2 2570 // Base is a base class of Derived without regard to cv-qualifiers or 2571 // Base and Derived are not unions and name the same class type without 2572 // regard to cv-qualifiers. 2573 2574 const RecordType *lhsRecord = LhsT->getAs<RecordType>(); 2575 if (!lhsRecord) return false; 2576 2577 const RecordType *rhsRecord = RhsT->getAs<RecordType>(); 2578 if (!rhsRecord) return false; 2579 2580 assert(Self.Context.hasSameUnqualifiedType(LhsT, RhsT) 2581 == (lhsRecord == rhsRecord)); 2582 2583 if (lhsRecord == rhsRecord) 2584 return !lhsRecord->getDecl()->isUnion(); 2585 2586 // C++0x [meta.rel]p2: 2587 // If Base and Derived are class types and are different types 2588 // (ignoring possible cv-qualifiers) then Derived shall be a 2589 // complete type. 2590 if (Self.RequireCompleteType(KeyLoc, RhsT, 2591 diag::err_incomplete_type_used_in_type_trait_expr)) 2592 return false; 2593 2594 return cast<CXXRecordDecl>(rhsRecord->getDecl()) 2595 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->getDecl())); 2596 } 2597 2598 case BTT_TypeCompatible: 2599 return Self.Context.typesAreCompatible(LhsT.getUnqualifiedType(), 2600 RhsT.getUnqualifiedType()); 2601 2602 case BTT_IsConvertibleTo: { 2603 // C++0x [meta.rel]p4: 2604 // Given the following function prototype: 2605 // 2606 // template <class T> 2607 // typename add_rvalue_reference<T>::type create(); 2608 // 2609 // the predicate condition for a template specialization 2610 // is_convertible<From, To> shall be satisfied if and only if 2611 // the return expression in the following code would be 2612 // well-formed, including any implicit conversions to the return 2613 // type of the function: 2614 // 2615 // To test() { 2616 // return create<From>(); 2617 // } 2618 // 2619 // Access checking is performed as if in a context unrelated to To and 2620 // From. Only the validity of the immediate context of the expression 2621 // of the return-statement (including conversions to the return type) 2622 // is considered. 2623 // 2624 // We model the initialization as a copy-initialization of a temporary 2625 // of the appropriate type, which for this expression is identical to the 2626 // return statement (since NRVO doesn't apply). 2627 if (LhsT->isObjectType() || LhsT->isFunctionType()) 2628 LhsT = Self.Context.getRValueReferenceType(LhsT); 2629 2630 InitializedEntity To(InitializedEntity::InitializeTemporary(RhsT)); 2631 OpaqueValueExpr From(KeyLoc, LhsT.getNonLValueExprType(Self.Context), 2632 Expr::getValueKindForType(LhsT)); 2633 Expr *FromPtr = &From; 2634 InitializationKind Kind(InitializationKind::CreateCopy(KeyLoc, 2635 SourceLocation())); 2636 2637 // Perform the initialization within a SFINAE trap at translation unit 2638 // scope. 2639 Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true); 2640 Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl()); 2641 InitializationSequence Init(Self, To, Kind, &FromPtr, 1); 2642 if (Init.getKind() == InitializationSequence::FailedSequence) 2643 return false; 2644 2645 ExprResult Result = Init.Perform(Self, To, Kind, MultiExprArg(&FromPtr, 1)); 2646 return !Result.isInvalid() && !SFINAE.hasErrorOccurred(); 2647 } 2648 } 2649 llvm_unreachable("Unknown type trait or not implemented"); 2650} 2651 2652ExprResult Sema::BuildBinaryTypeTrait(BinaryTypeTrait BTT, 2653 SourceLocation KWLoc, 2654 TypeSourceInfo *LhsTSInfo, 2655 TypeSourceInfo *RhsTSInfo, 2656 SourceLocation RParen) { 2657 QualType LhsT = LhsTSInfo->getType(); 2658 QualType RhsT = RhsTSInfo->getType(); 2659 2660 if (BTT == BTT_TypeCompatible) { 2661 if (getLangOptions().CPlusPlus) { 2662 Diag(KWLoc, diag::err_types_compatible_p_in_cplusplus) 2663 << SourceRange(KWLoc, RParen); 2664 return ExprError(); 2665 } 2666 } 2667 2668 bool Value = false; 2669 if (!LhsT->isDependentType() && !RhsT->isDependentType()) 2670 Value = EvaluateBinaryTypeTrait(*this, BTT, LhsT, RhsT, KWLoc); 2671 2672 // Select trait result type. 2673 QualType ResultType; 2674 switch (BTT) { 2675 case BTT_IsBaseOf: ResultType = Context.BoolTy; break; 2676 case BTT_TypeCompatible: ResultType = Context.IntTy; break; 2677 case BTT_IsConvertibleTo: ResultType = Context.BoolTy; break; 2678 } 2679 2680 return Owned(new (Context) BinaryTypeTraitExpr(KWLoc, BTT, LhsTSInfo, 2681 RhsTSInfo, Value, RParen, 2682 ResultType)); 2683} 2684 2685QualType Sema::CheckPointerToMemberOperands(Expr *&lex, Expr *&rex, 2686 ExprValueKind &VK, 2687 SourceLocation Loc, 2688 bool isIndirect) { 2689 const char *OpSpelling = isIndirect ? "->*" : ".*"; 2690 // C++ 5.5p2 2691 // The binary operator .* [p3: ->*] binds its second operand, which shall 2692 // be of type "pointer to member of T" (where T is a completely-defined 2693 // class type) [...] 2694 QualType RType = rex->getType(); 2695 const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>(); 2696 if (!MemPtr) { 2697 Diag(Loc, diag::err_bad_memptr_rhs) 2698 << OpSpelling << RType << rex->getSourceRange(); 2699 return QualType(); 2700 } 2701 2702 QualType Class(MemPtr->getClass(), 0); 2703 2704 // Note: C++ [expr.mptr.oper]p2-3 says that the class type into which the 2705 // member pointer points must be completely-defined. However, there is no 2706 // reason for this semantic distinction, and the rule is not enforced by 2707 // other compilers. Therefore, we do not check this property, as it is 2708 // likely to be considered a defect. 2709 2710 // C++ 5.5p2 2711 // [...] to its first operand, which shall be of class T or of a class of 2712 // which T is an unambiguous and accessible base class. [p3: a pointer to 2713 // such a class] 2714 QualType LType = lex->getType(); 2715 if (isIndirect) { 2716 if (const PointerType *Ptr = LType->getAs<PointerType>()) 2717 LType = Ptr->getPointeeType(); 2718 else { 2719 Diag(Loc, diag::err_bad_memptr_lhs) 2720 << OpSpelling << 1 << LType 2721 << FixItHint::CreateReplacement(SourceRange(Loc), ".*"); 2722 return QualType(); 2723 } 2724 } 2725 2726 if (!Context.hasSameUnqualifiedType(Class, LType)) { 2727 // If we want to check the hierarchy, we need a complete type. 2728 if (RequireCompleteType(Loc, LType, PDiag(diag::err_bad_memptr_lhs) 2729 << OpSpelling << (int)isIndirect)) { 2730 return QualType(); 2731 } 2732 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 2733 /*DetectVirtual=*/false); 2734 // FIXME: Would it be useful to print full ambiguity paths, or is that 2735 // overkill? 2736 if (!IsDerivedFrom(LType, Class, Paths) || 2737 Paths.isAmbiguous(Context.getCanonicalType(Class))) { 2738 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling 2739 << (int)isIndirect << lex->getType(); 2740 return QualType(); 2741 } 2742 // Cast LHS to type of use. 2743 QualType UseType = isIndirect ? Context.getPointerType(Class) : Class; 2744 ExprValueKind VK = 2745 isIndirect ? VK_RValue : CastCategory(lex); 2746 2747 CXXCastPath BasePath; 2748 BuildBasePathArray(Paths, BasePath); 2749 ImpCastExprToType(lex, UseType, CK_DerivedToBase, VK, &BasePath); 2750 } 2751 2752 if (isa<CXXScalarValueInitExpr>(rex->IgnoreParens())) { 2753 // Diagnose use of pointer-to-member type which when used as 2754 // the functional cast in a pointer-to-member expression. 2755 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect; 2756 return QualType(); 2757 } 2758 2759 // C++ 5.5p2 2760 // The result is an object or a function of the type specified by the 2761 // second operand. 2762 // The cv qualifiers are the union of those in the pointer and the left side, 2763 // in accordance with 5.5p5 and 5.2.5. 2764 // FIXME: This returns a dereferenced member function pointer as a normal 2765 // function type. However, the only operation valid on such functions is 2766 // calling them. There's also a GCC extension to get a function pointer to the 2767 // thing, which is another complication, because this type - unlike the type 2768 // that is the result of this expression - takes the class as the first 2769 // argument. 2770 // We probably need a "MemberFunctionClosureType" or something like that. 2771 QualType Result = MemPtr->getPointeeType(); 2772 Result = Context.getCVRQualifiedType(Result, LType.getCVRQualifiers()); 2773 2774 // C++0x [expr.mptr.oper]p6: 2775 // In a .* expression whose object expression is an rvalue, the program is 2776 // ill-formed if the second operand is a pointer to member function with 2777 // ref-qualifier &. In a ->* expression or in a .* expression whose object 2778 // expression is an lvalue, the program is ill-formed if the second operand 2779 // is a pointer to member function with ref-qualifier &&. 2780 if (const FunctionProtoType *Proto = Result->getAs<FunctionProtoType>()) { 2781 switch (Proto->getRefQualifier()) { 2782 case RQ_None: 2783 // Do nothing 2784 break; 2785 2786 case RQ_LValue: 2787 if (!isIndirect && !lex->Classify(Context).isLValue()) 2788 Diag(Loc, diag::err_pointer_to_member_oper_value_classify) 2789 << RType << 1 << lex->getSourceRange(); 2790 break; 2791 2792 case RQ_RValue: 2793 if (isIndirect || !lex->Classify(Context).isRValue()) 2794 Diag(Loc, diag::err_pointer_to_member_oper_value_classify) 2795 << RType << 0 << lex->getSourceRange(); 2796 break; 2797 } 2798 } 2799 2800 // C++ [expr.mptr.oper]p6: 2801 // The result of a .* expression whose second operand is a pointer 2802 // to a data member is of the same value category as its 2803 // first operand. The result of a .* expression whose second 2804 // operand is a pointer to a member function is a prvalue. The 2805 // result of an ->* expression is an lvalue if its second operand 2806 // is a pointer to data member and a prvalue otherwise. 2807 if (Result->isFunctionType()) 2808 VK = VK_RValue; 2809 else if (isIndirect) 2810 VK = VK_LValue; 2811 else 2812 VK = lex->getValueKind(); 2813 2814 return Result; 2815} 2816 2817/// \brief Try to convert a type to another according to C++0x 5.16p3. 2818/// 2819/// This is part of the parameter validation for the ? operator. If either 2820/// value operand is a class type, the two operands are attempted to be 2821/// converted to each other. This function does the conversion in one direction. 2822/// It returns true if the program is ill-formed and has already been diagnosed 2823/// as such. 2824static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, 2825 SourceLocation QuestionLoc, 2826 bool &HaveConversion, 2827 QualType &ToType) { 2828 HaveConversion = false; 2829 ToType = To->getType(); 2830 2831 InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(), 2832 SourceLocation()); 2833 // C++0x 5.16p3 2834 // The process for determining whether an operand expression E1 of type T1 2835 // can be converted to match an operand expression E2 of type T2 is defined 2836 // as follows: 2837 // -- If E2 is an lvalue: 2838 bool ToIsLvalue = To->isLValue(); 2839 if (ToIsLvalue) { 2840 // E1 can be converted to match E2 if E1 can be implicitly converted to 2841 // type "lvalue reference to T2", subject to the constraint that in the 2842 // conversion the reference must bind directly to E1. 2843 QualType T = Self.Context.getLValueReferenceType(ToType); 2844 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 2845 2846 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 2847 if (InitSeq.isDirectReferenceBinding()) { 2848 ToType = T; 2849 HaveConversion = true; 2850 return false; 2851 } 2852 2853 if (InitSeq.isAmbiguous()) 2854 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 2855 } 2856 2857 // -- If E2 is an rvalue, or if the conversion above cannot be done: 2858 // -- if E1 and E2 have class type, and the underlying class types are 2859 // the same or one is a base class of the other: 2860 QualType FTy = From->getType(); 2861 QualType TTy = To->getType(); 2862 const RecordType *FRec = FTy->getAs<RecordType>(); 2863 const RecordType *TRec = TTy->getAs<RecordType>(); 2864 bool FDerivedFromT = FRec && TRec && FRec != TRec && 2865 Self.IsDerivedFrom(FTy, TTy); 2866 if (FRec && TRec && 2867 (FRec == TRec || FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) { 2868 // E1 can be converted to match E2 if the class of T2 is the 2869 // same type as, or a base class of, the class of T1, and 2870 // [cv2 > cv1]. 2871 if (FRec == TRec || FDerivedFromT) { 2872 if (TTy.isAtLeastAsQualifiedAs(FTy)) { 2873 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 2874 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 2875 if (InitSeq.getKind() != InitializationSequence::FailedSequence) { 2876 HaveConversion = true; 2877 return false; 2878 } 2879 2880 if (InitSeq.isAmbiguous()) 2881 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 2882 } 2883 } 2884 2885 return false; 2886 } 2887 2888 // -- Otherwise: E1 can be converted to match E2 if E1 can be 2889 // implicitly converted to the type that expression E2 would have 2890 // if E2 were converted to an rvalue (or the type it has, if E2 is 2891 // an rvalue). 2892 // 2893 // This actually refers very narrowly to the lvalue-to-rvalue conversion, not 2894 // to the array-to-pointer or function-to-pointer conversions. 2895 if (!TTy->getAs<TagType>()) 2896 TTy = TTy.getUnqualifiedType(); 2897 2898 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 2899 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 2900 HaveConversion = InitSeq.getKind() != InitializationSequence::FailedSequence; 2901 ToType = TTy; 2902 if (InitSeq.isAmbiguous()) 2903 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 2904 2905 return false; 2906} 2907 2908/// \brief Try to find a common type for two according to C++0x 5.16p5. 2909/// 2910/// This is part of the parameter validation for the ? operator. If either 2911/// value operand is a class type, overload resolution is used to find a 2912/// conversion to a common type. 2913static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS, 2914 SourceLocation QuestionLoc) { 2915 Expr *Args[2] = { LHS, RHS }; 2916 OverloadCandidateSet CandidateSet(QuestionLoc); 2917 Self.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args, 2, 2918 CandidateSet); 2919 2920 OverloadCandidateSet::iterator Best; 2921 switch (CandidateSet.BestViableFunction(Self, QuestionLoc, Best)) { 2922 case OR_Success: 2923 // We found a match. Perform the conversions on the arguments and move on. 2924 if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0], 2925 Best->Conversions[0], Sema::AA_Converting) || 2926 Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1], 2927 Best->Conversions[1], Sema::AA_Converting)) 2928 break; 2929 if (Best->Function) 2930 Self.MarkDeclarationReferenced(QuestionLoc, Best->Function); 2931 return false; 2932 2933 case OR_No_Viable_Function: 2934 2935 // Emit a better diagnostic if one of the expressions is a null pointer 2936 // constant and the other is a pointer type. In this case, the user most 2937 // likely forgot to take the address of the other expression. 2938 if (Self.DiagnoseConditionalForNull(LHS, RHS, QuestionLoc)) 2939 return true; 2940 2941 Self.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 2942 << LHS->getType() << RHS->getType() 2943 << LHS->getSourceRange() << RHS->getSourceRange(); 2944 return true; 2945 2946 case OR_Ambiguous: 2947 Self.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl) 2948 << LHS->getType() << RHS->getType() 2949 << LHS->getSourceRange() << RHS->getSourceRange(); 2950 // FIXME: Print the possible common types by printing the return types of 2951 // the viable candidates. 2952 break; 2953 2954 case OR_Deleted: 2955 assert(false && "Conditional operator has only built-in overloads"); 2956 break; 2957 } 2958 return true; 2959} 2960 2961/// \brief Perform an "extended" implicit conversion as returned by 2962/// TryClassUnification. 2963static bool ConvertForConditional(Sema &Self, Expr *&E, QualType T) { 2964 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 2965 InitializationKind Kind = InitializationKind::CreateCopy(E->getLocStart(), 2966 SourceLocation()); 2967 InitializationSequence InitSeq(Self, Entity, Kind, &E, 1); 2968 ExprResult Result = InitSeq.Perform(Self, Entity, Kind, MultiExprArg(&E, 1)); 2969 if (Result.isInvalid()) 2970 return true; 2971 2972 E = Result.takeAs<Expr>(); 2973 return false; 2974} 2975 2976/// \brief Check the operands of ?: under C++ semantics. 2977/// 2978/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y 2979/// extension. In this case, LHS == Cond. (But they're not aliases.) 2980QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, 2981 ExprValueKind &VK, ExprObjectKind &OK, 2982 SourceLocation QuestionLoc) { 2983 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++ 2984 // interface pointers. 2985 2986 // C++0x 5.16p1 2987 // The first expression is contextually converted to bool. 2988 if (!Cond->isTypeDependent()) { 2989 if (CheckCXXBooleanCondition(Cond)) 2990 return QualType(); 2991 } 2992 2993 // Assume r-value. 2994 VK = VK_RValue; 2995 OK = OK_Ordinary; 2996 2997 // Either of the arguments dependent? 2998 if (LHS->isTypeDependent() || RHS->isTypeDependent()) 2999 return Context.DependentTy; 3000 3001 // C++0x 5.16p2 3002 // If either the second or the third operand has type (cv) void, ... 3003 QualType LTy = LHS->getType(); 3004 QualType RTy = RHS->getType(); 3005 bool LVoid = LTy->isVoidType(); 3006 bool RVoid = RTy->isVoidType(); 3007 if (LVoid || RVoid) { 3008 // ... then the [l2r] conversions are performed on the second and third 3009 // operands ... 3010 DefaultFunctionArrayLvalueConversion(LHS); 3011 DefaultFunctionArrayLvalueConversion(RHS); 3012 LTy = LHS->getType(); 3013 RTy = RHS->getType(); 3014 3015 // ... and one of the following shall hold: 3016 // -- The second or the third operand (but not both) is a throw- 3017 // expression; the result is of the type of the other and is an rvalue. 3018 bool LThrow = isa<CXXThrowExpr>(LHS); 3019 bool RThrow = isa<CXXThrowExpr>(RHS); 3020 if (LThrow && !RThrow) 3021 return RTy; 3022 if (RThrow && !LThrow) 3023 return LTy; 3024 3025 // -- Both the second and third operands have type void; the result is of 3026 // type void and is an rvalue. 3027 if (LVoid && RVoid) 3028 return Context.VoidTy; 3029 3030 // Neither holds, error. 3031 Diag(QuestionLoc, diag::err_conditional_void_nonvoid) 3032 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1) 3033 << LHS->getSourceRange() << RHS->getSourceRange(); 3034 return QualType(); 3035 } 3036 3037 // Neither is void. 3038 3039 // C++0x 5.16p3 3040 // Otherwise, if the second and third operand have different types, and 3041 // either has (cv) class type, and attempt is made to convert each of those 3042 // operands to the other. 3043 if (!Context.hasSameType(LTy, RTy) && 3044 (LTy->isRecordType() || RTy->isRecordType())) { 3045 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft; 3046 // These return true if a single direction is already ambiguous. 3047 QualType L2RType, R2LType; 3048 bool HaveL2R, HaveR2L; 3049 if (TryClassUnification(*this, LHS, RHS, QuestionLoc, HaveL2R, L2RType)) 3050 return QualType(); 3051 if (TryClassUnification(*this, RHS, LHS, QuestionLoc, HaveR2L, R2LType)) 3052 return QualType(); 3053 3054 // If both can be converted, [...] the program is ill-formed. 3055 if (HaveL2R && HaveR2L) { 3056 Diag(QuestionLoc, diag::err_conditional_ambiguous) 3057 << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange(); 3058 return QualType(); 3059 } 3060 3061 // If exactly one conversion is possible, that conversion is applied to 3062 // the chosen operand and the converted operands are used in place of the 3063 // original operands for the remainder of this section. 3064 if (HaveL2R) { 3065 if (ConvertForConditional(*this, LHS, L2RType)) 3066 return QualType(); 3067 LTy = LHS->getType(); 3068 } else if (HaveR2L) { 3069 if (ConvertForConditional(*this, RHS, R2LType)) 3070 return QualType(); 3071 RTy = RHS->getType(); 3072 } 3073 } 3074 3075 // C++0x 5.16p4 3076 // If the second and third operands are glvalues of the same value 3077 // category and have the same type, the result is of that type and 3078 // value category and it is a bit-field if the second or the third 3079 // operand is a bit-field, or if both are bit-fields. 3080 // We only extend this to bitfields, not to the crazy other kinds of 3081 // l-values. 3082 bool Same = Context.hasSameType(LTy, RTy); 3083 if (Same && 3084 LHS->isGLValue() && 3085 LHS->getValueKind() == RHS->getValueKind() && 3086 LHS->isOrdinaryOrBitFieldObject() && 3087 RHS->isOrdinaryOrBitFieldObject()) { 3088 VK = LHS->getValueKind(); 3089 if (LHS->getObjectKind() == OK_BitField || 3090 RHS->getObjectKind() == OK_BitField) 3091 OK = OK_BitField; 3092 return LTy; 3093 } 3094 3095 // C++0x 5.16p5 3096 // Otherwise, the result is an rvalue. If the second and third operands 3097 // do not have the same type, and either has (cv) class type, ... 3098 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) { 3099 // ... overload resolution is used to determine the conversions (if any) 3100 // to be applied to the operands. If the overload resolution fails, the 3101 // program is ill-formed. 3102 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc)) 3103 return QualType(); 3104 } 3105 3106 // C++0x 5.16p6 3107 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard 3108 // conversions are performed on the second and third operands. 3109 DefaultFunctionArrayLvalueConversion(LHS); 3110 DefaultFunctionArrayLvalueConversion(RHS); 3111 LTy = LHS->getType(); 3112 RTy = RHS->getType(); 3113 3114 // After those conversions, one of the following shall hold: 3115 // -- The second and third operands have the same type; the result 3116 // is of that type. If the operands have class type, the result 3117 // is a prvalue temporary of the result type, which is 3118 // copy-initialized from either the second operand or the third 3119 // operand depending on the value of the first operand. 3120 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) { 3121 if (LTy->isRecordType()) { 3122 // The operands have class type. Make a temporary copy. 3123 InitializedEntity Entity = InitializedEntity::InitializeTemporary(LTy); 3124 ExprResult LHSCopy = PerformCopyInitialization(Entity, 3125 SourceLocation(), 3126 Owned(LHS)); 3127 if (LHSCopy.isInvalid()) 3128 return QualType(); 3129 3130 ExprResult RHSCopy = PerformCopyInitialization(Entity, 3131 SourceLocation(), 3132 Owned(RHS)); 3133 if (RHSCopy.isInvalid()) 3134 return QualType(); 3135 3136 LHS = LHSCopy.takeAs<Expr>(); 3137 RHS = RHSCopy.takeAs<Expr>(); 3138 } 3139 3140 return LTy; 3141 } 3142 3143 // Extension: conditional operator involving vector types. 3144 if (LTy->isVectorType() || RTy->isVectorType()) 3145 return CheckVectorOperands(QuestionLoc, LHS, RHS); 3146 3147 // -- The second and third operands have arithmetic or enumeration type; 3148 // the usual arithmetic conversions are performed to bring them to a 3149 // common type, and the result is of that type. 3150 if (LTy->isArithmeticType() && RTy->isArithmeticType()) { 3151 UsualArithmeticConversions(LHS, RHS); 3152 return LHS->getType(); 3153 } 3154 3155 // -- The second and third operands have pointer type, or one has pointer 3156 // type and the other is a null pointer constant; pointer conversions 3157 // and qualification conversions are performed to bring them to their 3158 // composite pointer type. The result is of the composite pointer type. 3159 // -- The second and third operands have pointer to member type, or one has 3160 // pointer to member type and the other is a null pointer constant; 3161 // pointer to member conversions and qualification conversions are 3162 // performed to bring them to a common type, whose cv-qualification 3163 // shall match the cv-qualification of either the second or the third 3164 // operand. The result is of the common type. 3165 bool NonStandardCompositeType = false; 3166 QualType Composite = FindCompositePointerType(QuestionLoc, LHS, RHS, 3167 isSFINAEContext()? 0 : &NonStandardCompositeType); 3168 if (!Composite.isNull()) { 3169 if (NonStandardCompositeType) 3170 Diag(QuestionLoc, 3171 diag::ext_typecheck_cond_incompatible_operands_nonstandard) 3172 << LTy << RTy << Composite 3173 << LHS->getSourceRange() << RHS->getSourceRange(); 3174 3175 return Composite; 3176 } 3177 3178 // Similarly, attempt to find composite type of two objective-c pointers. 3179 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc); 3180 if (!Composite.isNull()) 3181 return Composite; 3182 3183 // Check if we are using a null with a non-pointer type. 3184 if (DiagnoseConditionalForNull(LHS, RHS, QuestionLoc)) 3185 return QualType(); 3186 3187 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 3188 << LHS->getType() << RHS->getType() 3189 << LHS->getSourceRange() << RHS->getSourceRange(); 3190 return QualType(); 3191} 3192 3193/// \brief Find a merged pointer type and convert the two expressions to it. 3194/// 3195/// This finds the composite pointer type (or member pointer type) for @p E1 3196/// and @p E2 according to C++0x 5.9p2. It converts both expressions to this 3197/// type and returns it. 3198/// It does not emit diagnostics. 3199/// 3200/// \param Loc The location of the operator requiring these two expressions to 3201/// be converted to the composite pointer type. 3202/// 3203/// If \p NonStandardCompositeType is non-NULL, then we are permitted to find 3204/// a non-standard (but still sane) composite type to which both expressions 3205/// can be converted. When such a type is chosen, \c *NonStandardCompositeType 3206/// will be set true. 3207QualType Sema::FindCompositePointerType(SourceLocation Loc, 3208 Expr *&E1, Expr *&E2, 3209 bool *NonStandardCompositeType) { 3210 if (NonStandardCompositeType) 3211 *NonStandardCompositeType = false; 3212 3213 assert(getLangOptions().CPlusPlus && "This function assumes C++"); 3214 QualType T1 = E1->getType(), T2 = E2->getType(); 3215 3216 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() && 3217 !T2->isAnyPointerType() && !T2->isMemberPointerType()) 3218 return QualType(); 3219 3220 // C++0x 5.9p2 3221 // Pointer conversions and qualification conversions are performed on 3222 // pointer operands to bring them to their composite pointer type. If 3223 // one operand is a null pointer constant, the composite pointer type is 3224 // the type of the other operand. 3225 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 3226 if (T2->isMemberPointerType()) 3227 ImpCastExprToType(E1, T2, CK_NullToMemberPointer); 3228 else 3229 ImpCastExprToType(E1, T2, CK_NullToPointer); 3230 return T2; 3231 } 3232 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 3233 if (T1->isMemberPointerType()) 3234 ImpCastExprToType(E2, T1, CK_NullToMemberPointer); 3235 else 3236 ImpCastExprToType(E2, T1, CK_NullToPointer); 3237 return T1; 3238 } 3239 3240 // Now both have to be pointers or member pointers. 3241 if ((!T1->isPointerType() && !T1->isMemberPointerType()) || 3242 (!T2->isPointerType() && !T2->isMemberPointerType())) 3243 return QualType(); 3244 3245 // Otherwise, of one of the operands has type "pointer to cv1 void," then 3246 // the other has type "pointer to cv2 T" and the composite pointer type is 3247 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2. 3248 // Otherwise, the composite pointer type is a pointer type similar to the 3249 // type of one of the operands, with a cv-qualification signature that is 3250 // the union of the cv-qualification signatures of the operand types. 3251 // In practice, the first part here is redundant; it's subsumed by the second. 3252 // What we do here is, we build the two possible composite types, and try the 3253 // conversions in both directions. If only one works, or if the two composite 3254 // types are the same, we have succeeded. 3255 // FIXME: extended qualifiers? 3256 typedef llvm::SmallVector<unsigned, 4> QualifierVector; 3257 QualifierVector QualifierUnion; 3258 typedef llvm::SmallVector<std::pair<const Type *, const Type *>, 4> 3259 ContainingClassVector; 3260 ContainingClassVector MemberOfClass; 3261 QualType Composite1 = Context.getCanonicalType(T1), 3262 Composite2 = Context.getCanonicalType(T2); 3263 unsigned NeedConstBefore = 0; 3264 do { 3265 const PointerType *Ptr1, *Ptr2; 3266 if ((Ptr1 = Composite1->getAs<PointerType>()) && 3267 (Ptr2 = Composite2->getAs<PointerType>())) { 3268 Composite1 = Ptr1->getPointeeType(); 3269 Composite2 = Ptr2->getPointeeType(); 3270 3271 // If we're allowed to create a non-standard composite type, keep track 3272 // of where we need to fill in additional 'const' qualifiers. 3273 if (NonStandardCompositeType && 3274 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 3275 NeedConstBefore = QualifierUnion.size(); 3276 3277 QualifierUnion.push_back( 3278 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 3279 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0)); 3280 continue; 3281 } 3282 3283 const MemberPointerType *MemPtr1, *MemPtr2; 3284 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) && 3285 (MemPtr2 = Composite2->getAs<MemberPointerType>())) { 3286 Composite1 = MemPtr1->getPointeeType(); 3287 Composite2 = MemPtr2->getPointeeType(); 3288 3289 // If we're allowed to create a non-standard composite type, keep track 3290 // of where we need to fill in additional 'const' qualifiers. 3291 if (NonStandardCompositeType && 3292 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 3293 NeedConstBefore = QualifierUnion.size(); 3294 3295 QualifierUnion.push_back( 3296 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 3297 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(), 3298 MemPtr2->getClass())); 3299 continue; 3300 } 3301 3302 // FIXME: block pointer types? 3303 3304 // Cannot unwrap any more types. 3305 break; 3306 } while (true); 3307 3308 if (NeedConstBefore && NonStandardCompositeType) { 3309 // Extension: Add 'const' to qualifiers that come before the first qualifier 3310 // mismatch, so that our (non-standard!) composite type meets the 3311 // requirements of C++ [conv.qual]p4 bullet 3. 3312 for (unsigned I = 0; I != NeedConstBefore; ++I) { 3313 if ((QualifierUnion[I] & Qualifiers::Const) == 0) { 3314 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const; 3315 *NonStandardCompositeType = true; 3316 } 3317 } 3318 } 3319 3320 // Rewrap the composites as pointers or member pointers with the union CVRs. 3321 ContainingClassVector::reverse_iterator MOC 3322 = MemberOfClass.rbegin(); 3323 for (QualifierVector::reverse_iterator 3324 I = QualifierUnion.rbegin(), 3325 E = QualifierUnion.rend(); 3326 I != E; (void)++I, ++MOC) { 3327 Qualifiers Quals = Qualifiers::fromCVRMask(*I); 3328 if (MOC->first && MOC->second) { 3329 // Rebuild member pointer type 3330 Composite1 = Context.getMemberPointerType( 3331 Context.getQualifiedType(Composite1, Quals), 3332 MOC->first); 3333 Composite2 = Context.getMemberPointerType( 3334 Context.getQualifiedType(Composite2, Quals), 3335 MOC->second); 3336 } else { 3337 // Rebuild pointer type 3338 Composite1 3339 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals)); 3340 Composite2 3341 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals)); 3342 } 3343 } 3344 3345 // Try to convert to the first composite pointer type. 3346 InitializedEntity Entity1 3347 = InitializedEntity::InitializeTemporary(Composite1); 3348 InitializationKind Kind 3349 = InitializationKind::CreateCopy(Loc, SourceLocation()); 3350 InitializationSequence E1ToC1(*this, Entity1, Kind, &E1, 1); 3351 InitializationSequence E2ToC1(*this, Entity1, Kind, &E2, 1); 3352 3353 if (E1ToC1 && E2ToC1) { 3354 // Conversion to Composite1 is viable. 3355 if (!Context.hasSameType(Composite1, Composite2)) { 3356 // Composite2 is a different type from Composite1. Check whether 3357 // Composite2 is also viable. 3358 InitializedEntity Entity2 3359 = InitializedEntity::InitializeTemporary(Composite2); 3360 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1); 3361 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1); 3362 if (E1ToC2 && E2ToC2) { 3363 // Both Composite1 and Composite2 are viable and are different; 3364 // this is an ambiguity. 3365 return QualType(); 3366 } 3367 } 3368 3369 // Convert E1 to Composite1 3370 ExprResult E1Result 3371 = E1ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,&E1,1)); 3372 if (E1Result.isInvalid()) 3373 return QualType(); 3374 E1 = E1Result.takeAs<Expr>(); 3375 3376 // Convert E2 to Composite1 3377 ExprResult E2Result 3378 = E2ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,&E2,1)); 3379 if (E2Result.isInvalid()) 3380 return QualType(); 3381 E2 = E2Result.takeAs<Expr>(); 3382 3383 return Composite1; 3384 } 3385 3386 // Check whether Composite2 is viable. 3387 InitializedEntity Entity2 3388 = InitializedEntity::InitializeTemporary(Composite2); 3389 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1); 3390 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1); 3391 if (!E1ToC2 || !E2ToC2) 3392 return QualType(); 3393 3394 // Convert E1 to Composite2 3395 ExprResult E1Result 3396 = E1ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, &E1, 1)); 3397 if (E1Result.isInvalid()) 3398 return QualType(); 3399 E1 = E1Result.takeAs<Expr>(); 3400 3401 // Convert E2 to Composite2 3402 ExprResult E2Result 3403 = E2ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, &E2, 1)); 3404 if (E2Result.isInvalid()) 3405 return QualType(); 3406 E2 = E2Result.takeAs<Expr>(); 3407 3408 return Composite2; 3409} 3410 3411ExprResult Sema::MaybeBindToTemporary(Expr *E) { 3412 if (!E) 3413 return ExprError(); 3414 3415 if (!Context.getLangOptions().CPlusPlus) 3416 return Owned(E); 3417 3418 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?"); 3419 3420 const RecordType *RT = E->getType()->getAs<RecordType>(); 3421 if (!RT) 3422 return Owned(E); 3423 3424 // If the result is a glvalue, we shouldn't bind it. 3425 if (E->Classify(Context).isGLValue()) 3426 return Owned(E); 3427 3428 // That should be enough to guarantee that this type is complete. 3429 // If it has a trivial destructor, we can avoid the extra copy. 3430 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 3431 if (RD->isInvalidDecl() || RD->hasTrivialDestructor()) 3432 return Owned(E); 3433 3434 CXXTemporary *Temp = CXXTemporary::Create(Context, LookupDestructor(RD)); 3435 ExprTemporaries.push_back(Temp); 3436 if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) { 3437 MarkDeclarationReferenced(E->getExprLoc(), Destructor); 3438 CheckDestructorAccess(E->getExprLoc(), Destructor, 3439 PDiag(diag::err_access_dtor_temp) 3440 << E->getType()); 3441 } 3442 // FIXME: Add the temporary to the temporaries vector. 3443 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E)); 3444} 3445 3446Expr *Sema::MaybeCreateExprWithCleanups(Expr *SubExpr) { 3447 assert(SubExpr && "sub expression can't be null!"); 3448 3449 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 3450 assert(ExprTemporaries.size() >= FirstTemporary); 3451 if (ExprTemporaries.size() == FirstTemporary) 3452 return SubExpr; 3453 3454 Expr *E = ExprWithCleanups::Create(Context, SubExpr, 3455 &ExprTemporaries[FirstTemporary], 3456 ExprTemporaries.size() - FirstTemporary); 3457 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 3458 ExprTemporaries.end()); 3459 3460 return E; 3461} 3462 3463ExprResult 3464Sema::MaybeCreateExprWithCleanups(ExprResult SubExpr) { 3465 if (SubExpr.isInvalid()) 3466 return ExprError(); 3467 3468 return Owned(MaybeCreateExprWithCleanups(SubExpr.take())); 3469} 3470 3471Stmt *Sema::MaybeCreateStmtWithCleanups(Stmt *SubStmt) { 3472 assert(SubStmt && "sub statement can't be null!"); 3473 3474 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 3475 assert(ExprTemporaries.size() >= FirstTemporary); 3476 if (ExprTemporaries.size() == FirstTemporary) 3477 return SubStmt; 3478 3479 // FIXME: In order to attach the temporaries, wrap the statement into 3480 // a StmtExpr; currently this is only used for asm statements. 3481 // This is hacky, either create a new CXXStmtWithTemporaries statement or 3482 // a new AsmStmtWithTemporaries. 3483 CompoundStmt *CompStmt = new (Context) CompoundStmt(Context, &SubStmt, 1, 3484 SourceLocation(), 3485 SourceLocation()); 3486 Expr *E = new (Context) StmtExpr(CompStmt, Context.VoidTy, SourceLocation(), 3487 SourceLocation()); 3488 return MaybeCreateExprWithCleanups(E); 3489} 3490 3491ExprResult 3492Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, 3493 tok::TokenKind OpKind, ParsedType &ObjectType, 3494 bool &MayBePseudoDestructor) { 3495 // Since this might be a postfix expression, get rid of ParenListExprs. 3496 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base); 3497 if (Result.isInvalid()) return ExprError(); 3498 Base = Result.get(); 3499 3500 QualType BaseType = Base->getType(); 3501 MayBePseudoDestructor = false; 3502 if (BaseType->isDependentType()) { 3503 // If we have a pointer to a dependent type and are using the -> operator, 3504 // the object type is the type that the pointer points to. We might still 3505 // have enough information about that type to do something useful. 3506 if (OpKind == tok::arrow) 3507 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 3508 BaseType = Ptr->getPointeeType(); 3509 3510 ObjectType = ParsedType::make(BaseType); 3511 MayBePseudoDestructor = true; 3512 return Owned(Base); 3513 } 3514 3515 // C++ [over.match.oper]p8: 3516 // [...] When operator->returns, the operator-> is applied to the value 3517 // returned, with the original second operand. 3518 if (OpKind == tok::arrow) { 3519 // The set of types we've considered so far. 3520 llvm::SmallPtrSet<CanQualType,8> CTypes; 3521 llvm::SmallVector<SourceLocation, 8> Locations; 3522 CTypes.insert(Context.getCanonicalType(BaseType)); 3523 3524 while (BaseType->isRecordType()) { 3525 Result = BuildOverloadedArrowExpr(S, Base, OpLoc); 3526 if (Result.isInvalid()) 3527 return ExprError(); 3528 Base = Result.get(); 3529 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(Base)) 3530 Locations.push_back(OpCall->getDirectCallee()->getLocation()); 3531 BaseType = Base->getType(); 3532 CanQualType CBaseType = Context.getCanonicalType(BaseType); 3533 if (!CTypes.insert(CBaseType)) { 3534 Diag(OpLoc, diag::err_operator_arrow_circular); 3535 for (unsigned i = 0; i < Locations.size(); i++) 3536 Diag(Locations[i], diag::note_declared_at); 3537 return ExprError(); 3538 } 3539 } 3540 3541 if (BaseType->isPointerType()) 3542 BaseType = BaseType->getPointeeType(); 3543 } 3544 3545 // We could end up with various non-record types here, such as extended 3546 // vector types or Objective-C interfaces. Just return early and let 3547 // ActOnMemberReferenceExpr do the work. 3548 if (!BaseType->isRecordType()) { 3549 // C++ [basic.lookup.classref]p2: 3550 // [...] If the type of the object expression is of pointer to scalar 3551 // type, the unqualified-id is looked up in the context of the complete 3552 // postfix-expression. 3553 // 3554 // This also indicates that we should be parsing a 3555 // pseudo-destructor-name. 3556 ObjectType = ParsedType(); 3557 MayBePseudoDestructor = true; 3558 return Owned(Base); 3559 } 3560 3561 // The object type must be complete (or dependent). 3562 if (!BaseType->isDependentType() && 3563 RequireCompleteType(OpLoc, BaseType, 3564 PDiag(diag::err_incomplete_member_access))) 3565 return ExprError(); 3566 3567 // C++ [basic.lookup.classref]p2: 3568 // If the id-expression in a class member access (5.2.5) is an 3569 // unqualified-id, and the type of the object expression is of a class 3570 // type C (or of pointer to a class type C), the unqualified-id is looked 3571 // up in the scope of class C. [...] 3572 ObjectType = ParsedType::make(BaseType); 3573 return move(Base); 3574} 3575 3576ExprResult Sema::DiagnoseDtorReference(SourceLocation NameLoc, 3577 Expr *MemExpr) { 3578 SourceLocation ExpectedLParenLoc = PP.getLocForEndOfToken(NameLoc); 3579 Diag(MemExpr->getLocStart(), diag::err_dtor_expr_without_call) 3580 << isa<CXXPseudoDestructorExpr>(MemExpr) 3581 << FixItHint::CreateInsertion(ExpectedLParenLoc, "()"); 3582 3583 return ActOnCallExpr(/*Scope*/ 0, 3584 MemExpr, 3585 /*LPLoc*/ ExpectedLParenLoc, 3586 MultiExprArg(), 3587 /*RPLoc*/ ExpectedLParenLoc); 3588} 3589 3590ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base, 3591 SourceLocation OpLoc, 3592 tok::TokenKind OpKind, 3593 const CXXScopeSpec &SS, 3594 TypeSourceInfo *ScopeTypeInfo, 3595 SourceLocation CCLoc, 3596 SourceLocation TildeLoc, 3597 PseudoDestructorTypeStorage Destructed, 3598 bool HasTrailingLParen) { 3599 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo(); 3600 3601 // C++ [expr.pseudo]p2: 3602 // The left-hand side of the dot operator shall be of scalar type. The 3603 // left-hand side of the arrow operator shall be of pointer to scalar type. 3604 // This scalar type is the object type. 3605 QualType ObjectType = Base->getType(); 3606 if (OpKind == tok::arrow) { 3607 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 3608 ObjectType = Ptr->getPointeeType(); 3609 } else if (!Base->isTypeDependent()) { 3610 // The user wrote "p->" when she probably meant "p."; fix it. 3611 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 3612 << ObjectType << true 3613 << FixItHint::CreateReplacement(OpLoc, "."); 3614 if (isSFINAEContext()) 3615 return ExprError(); 3616 3617 OpKind = tok::period; 3618 } 3619 } 3620 3621 if (!ObjectType->isDependentType() && !ObjectType->isScalarType()) { 3622 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar) 3623 << ObjectType << Base->getSourceRange(); 3624 return ExprError(); 3625 } 3626 3627 // C++ [expr.pseudo]p2: 3628 // [...] The cv-unqualified versions of the object type and of the type 3629 // designated by the pseudo-destructor-name shall be the same type. 3630 if (DestructedTypeInfo) { 3631 QualType DestructedType = DestructedTypeInfo->getType(); 3632 SourceLocation DestructedTypeStart 3633 = DestructedTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(); 3634 if (!DestructedType->isDependentType() && !ObjectType->isDependentType() && 3635 !Context.hasSameUnqualifiedType(DestructedType, ObjectType)) { 3636 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch) 3637 << ObjectType << DestructedType << Base->getSourceRange() 3638 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange(); 3639 3640 // Recover by setting the destructed type to the object type. 3641 DestructedType = ObjectType; 3642 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType, 3643 DestructedTypeStart); 3644 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 3645 } 3646 } 3647 3648 // C++ [expr.pseudo]p2: 3649 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the 3650 // form 3651 // 3652 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name 3653 // 3654 // shall designate the same scalar type. 3655 if (ScopeTypeInfo) { 3656 QualType ScopeType = ScopeTypeInfo->getType(); 3657 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() && 3658 !Context.hasSameUnqualifiedType(ScopeType, ObjectType)) { 3659 3660 Diag(ScopeTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(), 3661 diag::err_pseudo_dtor_type_mismatch) 3662 << ObjectType << ScopeType << Base->getSourceRange() 3663 << ScopeTypeInfo->getTypeLoc().getLocalSourceRange(); 3664 3665 ScopeType = QualType(); 3666 ScopeTypeInfo = 0; 3667 } 3668 } 3669 3670 Expr *Result 3671 = new (Context) CXXPseudoDestructorExpr(Context, Base, 3672 OpKind == tok::arrow, OpLoc, 3673 SS.getWithLocInContext(Context), 3674 ScopeTypeInfo, 3675 CCLoc, 3676 TildeLoc, 3677 Destructed); 3678 3679 if (HasTrailingLParen) 3680 return Owned(Result); 3681 3682 return DiagnoseDtorReference(Destructed.getLocation(), Result); 3683} 3684 3685ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base, 3686 SourceLocation OpLoc, 3687 tok::TokenKind OpKind, 3688 CXXScopeSpec &SS, 3689 UnqualifiedId &FirstTypeName, 3690 SourceLocation CCLoc, 3691 SourceLocation TildeLoc, 3692 UnqualifiedId &SecondTypeName, 3693 bool HasTrailingLParen) { 3694 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 3695 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) && 3696 "Invalid first type name in pseudo-destructor"); 3697 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId || 3698 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) && 3699 "Invalid second type name in pseudo-destructor"); 3700 3701 // C++ [expr.pseudo]p2: 3702 // The left-hand side of the dot operator shall be of scalar type. The 3703 // left-hand side of the arrow operator shall be of pointer to scalar type. 3704 // This scalar type is the object type. 3705 QualType ObjectType = Base->getType(); 3706 if (OpKind == tok::arrow) { 3707 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 3708 ObjectType = Ptr->getPointeeType(); 3709 } else if (!ObjectType->isDependentType()) { 3710 // The user wrote "p->" when she probably meant "p."; fix it. 3711 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 3712 << ObjectType << true 3713 << FixItHint::CreateReplacement(OpLoc, "."); 3714 if (isSFINAEContext()) 3715 return ExprError(); 3716 3717 OpKind = tok::period; 3718 } 3719 } 3720 3721 // Compute the object type that we should use for name lookup purposes. Only 3722 // record types and dependent types matter. 3723 ParsedType ObjectTypePtrForLookup; 3724 if (!SS.isSet()) { 3725 if (ObjectType->isRecordType()) 3726 ObjectTypePtrForLookup = ParsedType::make(ObjectType); 3727 else if (ObjectType->isDependentType()) 3728 ObjectTypePtrForLookup = ParsedType::make(Context.DependentTy); 3729 } 3730 3731 // Convert the name of the type being destructed (following the ~) into a 3732 // type (with source-location information). 3733 QualType DestructedType; 3734 TypeSourceInfo *DestructedTypeInfo = 0; 3735 PseudoDestructorTypeStorage Destructed; 3736 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) { 3737 ParsedType T = getTypeName(*SecondTypeName.Identifier, 3738 SecondTypeName.StartLocation, 3739 S, &SS, true, false, ObjectTypePtrForLookup); 3740 if (!T && 3741 ((SS.isSet() && !computeDeclContext(SS, false)) || 3742 (!SS.isSet() && ObjectType->isDependentType()))) { 3743 // The name of the type being destroyed is a dependent name, and we 3744 // couldn't find anything useful in scope. Just store the identifier and 3745 // it's location, and we'll perform (qualified) name lookup again at 3746 // template instantiation time. 3747 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier, 3748 SecondTypeName.StartLocation); 3749 } else if (!T) { 3750 Diag(SecondTypeName.StartLocation, 3751 diag::err_pseudo_dtor_destructor_non_type) 3752 << SecondTypeName.Identifier << ObjectType; 3753 if (isSFINAEContext()) 3754 return ExprError(); 3755 3756 // Recover by assuming we had the right type all along. 3757 DestructedType = ObjectType; 3758 } else 3759 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo); 3760 } else { 3761 // Resolve the template-id to a type. 3762 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId; 3763 ASTTemplateArgsPtr TemplateArgsPtr(*this, 3764 TemplateId->getTemplateArgs(), 3765 TemplateId->NumArgs); 3766 TypeResult T = ActOnTemplateIdType(TemplateId->Template, 3767 TemplateId->TemplateNameLoc, 3768 TemplateId->LAngleLoc, 3769 TemplateArgsPtr, 3770 TemplateId->RAngleLoc); 3771 if (T.isInvalid() || !T.get()) { 3772 // Recover by assuming we had the right type all along. 3773 DestructedType = ObjectType; 3774 } else 3775 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo); 3776 } 3777 3778 // If we've performed some kind of recovery, (re-)build the type source 3779 // information. 3780 if (!DestructedType.isNull()) { 3781 if (!DestructedTypeInfo) 3782 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType, 3783 SecondTypeName.StartLocation); 3784 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 3785 } 3786 3787 // Convert the name of the scope type (the type prior to '::') into a type. 3788 TypeSourceInfo *ScopeTypeInfo = 0; 3789 QualType ScopeType; 3790 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 3791 FirstTypeName.Identifier) { 3792 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) { 3793 ParsedType T = getTypeName(*FirstTypeName.Identifier, 3794 FirstTypeName.StartLocation, 3795 S, &SS, true, false, ObjectTypePtrForLookup); 3796 if (!T) { 3797 Diag(FirstTypeName.StartLocation, 3798 diag::err_pseudo_dtor_destructor_non_type) 3799 << FirstTypeName.Identifier << ObjectType; 3800 3801 if (isSFINAEContext()) 3802 return ExprError(); 3803 3804 // Just drop this type. It's unnecessary anyway. 3805 ScopeType = QualType(); 3806 } else 3807 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo); 3808 } else { 3809 // Resolve the template-id to a type. 3810 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId; 3811 ASTTemplateArgsPtr TemplateArgsPtr(*this, 3812 TemplateId->getTemplateArgs(), 3813 TemplateId->NumArgs); 3814 TypeResult T = ActOnTemplateIdType(TemplateId->Template, 3815 TemplateId->TemplateNameLoc, 3816 TemplateId->LAngleLoc, 3817 TemplateArgsPtr, 3818 TemplateId->RAngleLoc); 3819 if (T.isInvalid() || !T.get()) { 3820 // Recover by dropping this type. 3821 ScopeType = QualType(); 3822 } else 3823 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo); 3824 } 3825 } 3826 3827 if (!ScopeType.isNull() && !ScopeTypeInfo) 3828 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType, 3829 FirstTypeName.StartLocation); 3830 3831 3832 return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, SS, 3833 ScopeTypeInfo, CCLoc, TildeLoc, 3834 Destructed, HasTrailingLParen); 3835} 3836 3837ExprResult Sema::BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, 3838 CXXMethodDecl *Method) { 3839 if (PerformObjectArgumentInitialization(Exp, /*Qualifier=*/0, 3840 FoundDecl, Method)) 3841 return true; 3842 3843 MemberExpr *ME = 3844 new (Context) MemberExpr(Exp, /*IsArrow=*/false, Method, 3845 SourceLocation(), Method->getType(), 3846 VK_RValue, OK_Ordinary); 3847 QualType ResultType = Method->getResultType(); 3848 ExprValueKind VK = Expr::getValueKindForType(ResultType); 3849 ResultType = ResultType.getNonLValueExprType(Context); 3850 3851 MarkDeclarationReferenced(Exp->getLocStart(), Method); 3852 CXXMemberCallExpr *CE = 3853 new (Context) CXXMemberCallExpr(Context, ME, 0, 0, ResultType, VK, 3854 Exp->getLocEnd()); 3855 return CE; 3856} 3857 3858ExprResult Sema::BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand, 3859 SourceLocation RParen) { 3860 return Owned(new (Context) CXXNoexceptExpr(Context.BoolTy, Operand, 3861 Operand->CanThrow(Context), 3862 KeyLoc, RParen)); 3863} 3864 3865ExprResult Sema::ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation, 3866 Expr *Operand, SourceLocation RParen) { 3867 return BuildCXXNoexceptExpr(KeyLoc, Operand, RParen); 3868} 3869 3870/// Perform the conversions required for an expression used in a 3871/// context that ignores the result. 3872void Sema::IgnoredValueConversions(Expr *&E) { 3873 // C99 6.3.2.1: 3874 // [Except in specific positions,] an lvalue that does not have 3875 // array type is converted to the value stored in the 3876 // designated object (and is no longer an lvalue). 3877 if (E->isRValue()) return; 3878 3879 // We always want to do this on ObjC property references. 3880 if (E->getObjectKind() == OK_ObjCProperty) { 3881 ConvertPropertyForRValue(E); 3882 if (E->isRValue()) return; 3883 } 3884 3885 // Otherwise, this rule does not apply in C++, at least not for the moment. 3886 if (getLangOptions().CPlusPlus) return; 3887 3888 // GCC seems to also exclude expressions of incomplete enum type. 3889 if (const EnumType *T = E->getType()->getAs<EnumType>()) { 3890 if (!T->getDecl()->isComplete()) { 3891 // FIXME: stupid workaround for a codegen bug! 3892 ImpCastExprToType(E, Context.VoidTy, CK_ToVoid); 3893 return; 3894 } 3895 } 3896 3897 DefaultFunctionArrayLvalueConversion(E); 3898 if (!E->getType()->isVoidType()) 3899 RequireCompleteType(E->getExprLoc(), E->getType(), 3900 diag::err_incomplete_type); 3901} 3902 3903ExprResult Sema::ActOnFinishFullExpr(Expr *FullExpr) { 3904 if (!FullExpr) 3905 return ExprError(); 3906 3907 if (DiagnoseUnexpandedParameterPack(FullExpr)) 3908 return ExprError(); 3909 3910 IgnoredValueConversions(FullExpr); 3911 CheckImplicitConversions(FullExpr); 3912 return MaybeCreateExprWithCleanups(FullExpr); 3913} 3914 3915StmtResult Sema::ActOnFinishFullStmt(Stmt *FullStmt) { 3916 if (!FullStmt) return StmtError(); 3917 3918 return MaybeCreateStmtWithCleanups(FullStmt); 3919} 3920