SemaExprCXX.cpp revision 7e384943ac136f6c2ea55c309108b83939cd4c21
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 // The first argument is size_t, and the first parameter must be size_t, 1353 // too. This is checked on declaration and can be assumed. (It can't be 1354 // asserted on, though, since invalid decls are left in there.) 1355 // Watch out for variadic allocator function. 1356 unsigned NumArgsInFnDecl = FnDecl->getNumParams(); 1357 for (unsigned i = 0; (i < NumArgs && i < NumArgsInFnDecl); ++i) { 1358 ExprResult Result 1359 = PerformCopyInitialization(InitializedEntity::InitializeParameter( 1360 Context, 1361 FnDecl->getParamDecl(i)), 1362 SourceLocation(), 1363 Owned(Args[i])); 1364 if (Result.isInvalid()) 1365 return true; 1366 1367 Args[i] = Result.takeAs<Expr>(); 1368 } 1369 Operator = FnDecl; 1370 CheckAllocationAccess(StartLoc, Range, R.getNamingClass(), Best->FoundDecl); 1371 return false; 1372 } 1373 1374 case OR_No_Viable_Function: 1375 Diag(StartLoc, diag::err_ovl_no_viable_function_in_call) 1376 << Name << Range; 1377 Candidates.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs); 1378 return true; 1379 1380 case OR_Ambiguous: 1381 Diag(StartLoc, diag::err_ovl_ambiguous_call) 1382 << Name << Range; 1383 Candidates.NoteCandidates(*this, OCD_ViableCandidates, Args, NumArgs); 1384 return true; 1385 1386 case OR_Deleted: 1387 Diag(StartLoc, diag::err_ovl_deleted_call) 1388 << Best->Function->isDeleted() 1389 << Name << Range; 1390 Candidates.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs); 1391 return true; 1392 } 1393 assert(false && "Unreachable, bad result from BestViableFunction"); 1394 return true; 1395} 1396 1397 1398/// DeclareGlobalNewDelete - Declare the global forms of operator new and 1399/// delete. These are: 1400/// @code 1401/// void* operator new(std::size_t) throw(std::bad_alloc); 1402/// void* operator new[](std::size_t) throw(std::bad_alloc); 1403/// void operator delete(void *) throw(); 1404/// void operator delete[](void *) throw(); 1405/// @endcode 1406/// Note that the placement and nothrow forms of new are *not* implicitly 1407/// declared. Their use requires including \<new\>. 1408void Sema::DeclareGlobalNewDelete() { 1409 if (GlobalNewDeleteDeclared) 1410 return; 1411 1412 // C++ [basic.std.dynamic]p2: 1413 // [...] The following allocation and deallocation functions (18.4) are 1414 // implicitly declared in global scope in each translation unit of a 1415 // program 1416 // 1417 // void* operator new(std::size_t) throw(std::bad_alloc); 1418 // void* operator new[](std::size_t) throw(std::bad_alloc); 1419 // void operator delete(void*) throw(); 1420 // void operator delete[](void*) throw(); 1421 // 1422 // These implicit declarations introduce only the function names operator 1423 // new, operator new[], operator delete, operator delete[]. 1424 // 1425 // Here, we need to refer to std::bad_alloc, so we will implicitly declare 1426 // "std" or "bad_alloc" as necessary to form the exception specification. 1427 // However, we do not make these implicit declarations visible to name 1428 // lookup. 1429 if (!StdBadAlloc) { 1430 // The "std::bad_alloc" class has not yet been declared, so build it 1431 // implicitly. 1432 StdBadAlloc = CXXRecordDecl::Create(Context, TTK_Class, 1433 getOrCreateStdNamespace(), 1434 SourceLocation(), 1435 &PP.getIdentifierTable().get("bad_alloc"), 1436 SourceLocation(), 0); 1437 getStdBadAlloc()->setImplicit(true); 1438 } 1439 1440 GlobalNewDeleteDeclared = true; 1441 1442 QualType VoidPtr = Context.getPointerType(Context.VoidTy); 1443 QualType SizeT = Context.getSizeType(); 1444 bool AssumeSaneOperatorNew = getLangOptions().AssumeSaneOperatorNew; 1445 1446 DeclareGlobalAllocationFunction( 1447 Context.DeclarationNames.getCXXOperatorName(OO_New), 1448 VoidPtr, SizeT, AssumeSaneOperatorNew); 1449 DeclareGlobalAllocationFunction( 1450 Context.DeclarationNames.getCXXOperatorName(OO_Array_New), 1451 VoidPtr, SizeT, AssumeSaneOperatorNew); 1452 DeclareGlobalAllocationFunction( 1453 Context.DeclarationNames.getCXXOperatorName(OO_Delete), 1454 Context.VoidTy, VoidPtr); 1455 DeclareGlobalAllocationFunction( 1456 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete), 1457 Context.VoidTy, VoidPtr); 1458} 1459 1460/// DeclareGlobalAllocationFunction - Declares a single implicit global 1461/// allocation function if it doesn't already exist. 1462void Sema::DeclareGlobalAllocationFunction(DeclarationName Name, 1463 QualType Return, QualType Argument, 1464 bool AddMallocAttr) { 1465 DeclContext *GlobalCtx = Context.getTranslationUnitDecl(); 1466 1467 // Check if this function is already declared. 1468 { 1469 DeclContext::lookup_iterator Alloc, AllocEnd; 1470 for (llvm::tie(Alloc, AllocEnd) = GlobalCtx->lookup(Name); 1471 Alloc != AllocEnd; ++Alloc) { 1472 // Only look at non-template functions, as it is the predefined, 1473 // non-templated allocation function we are trying to declare here. 1474 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) { 1475 QualType InitialParamType = 1476 Context.getCanonicalType( 1477 Func->getParamDecl(0)->getType().getUnqualifiedType()); 1478 // FIXME: Do we need to check for default arguments here? 1479 if (Func->getNumParams() == 1 && InitialParamType == Argument) { 1480 if(AddMallocAttr && !Func->hasAttr<MallocAttr>()) 1481 Func->addAttr(::new (Context) MallocAttr(SourceLocation(), Context)); 1482 return; 1483 } 1484 } 1485 } 1486 } 1487 1488 QualType BadAllocType; 1489 bool HasBadAllocExceptionSpec 1490 = (Name.getCXXOverloadedOperator() == OO_New || 1491 Name.getCXXOverloadedOperator() == OO_Array_New); 1492 if (HasBadAllocExceptionSpec) { 1493 assert(StdBadAlloc && "Must have std::bad_alloc declared"); 1494 BadAllocType = Context.getTypeDeclType(getStdBadAlloc()); 1495 } 1496 1497 FunctionProtoType::ExtProtoInfo EPI; 1498 EPI.HasExceptionSpec = true; 1499 if (HasBadAllocExceptionSpec) { 1500 EPI.NumExceptions = 1; 1501 EPI.Exceptions = &BadAllocType; 1502 } 1503 1504 QualType FnType = Context.getFunctionType(Return, &Argument, 1, EPI); 1505 FunctionDecl *Alloc = 1506 FunctionDecl::Create(Context, GlobalCtx, SourceLocation(), Name, 1507 FnType, /*TInfo=*/0, SC_None, 1508 SC_None, false, true); 1509 Alloc->setImplicit(); 1510 1511 if (AddMallocAttr) 1512 Alloc->addAttr(::new (Context) MallocAttr(SourceLocation(), Context)); 1513 1514 ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(), 1515 0, Argument, /*TInfo=*/0, 1516 SC_None, 1517 SC_None, 0); 1518 Alloc->setParams(&Param, 1); 1519 1520 // FIXME: Also add this declaration to the IdentifierResolver, but 1521 // make sure it is at the end of the chain to coincide with the 1522 // global scope. 1523 Context.getTranslationUnitDecl()->addDecl(Alloc); 1524} 1525 1526bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, 1527 DeclarationName Name, 1528 FunctionDecl* &Operator) { 1529 LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName); 1530 // Try to find operator delete/operator delete[] in class scope. 1531 LookupQualifiedName(Found, RD); 1532 1533 if (Found.isAmbiguous()) 1534 return true; 1535 1536 Found.suppressDiagnostics(); 1537 1538 llvm::SmallVector<DeclAccessPair,4> Matches; 1539 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end(); 1540 F != FEnd; ++F) { 1541 NamedDecl *ND = (*F)->getUnderlyingDecl(); 1542 1543 // Ignore template operator delete members from the check for a usual 1544 // deallocation function. 1545 if (isa<FunctionTemplateDecl>(ND)) 1546 continue; 1547 1548 if (cast<CXXMethodDecl>(ND)->isUsualDeallocationFunction()) 1549 Matches.push_back(F.getPair()); 1550 } 1551 1552 // There's exactly one suitable operator; pick it. 1553 if (Matches.size() == 1) { 1554 Operator = cast<CXXMethodDecl>(Matches[0]->getUnderlyingDecl()); 1555 CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(), 1556 Matches[0]); 1557 return false; 1558 1559 // We found multiple suitable operators; complain about the ambiguity. 1560 } else if (!Matches.empty()) { 1561 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found) 1562 << Name << RD; 1563 1564 for (llvm::SmallVectorImpl<DeclAccessPair>::iterator 1565 F = Matches.begin(), FEnd = Matches.end(); F != FEnd; ++F) 1566 Diag((*F)->getUnderlyingDecl()->getLocation(), 1567 diag::note_member_declared_here) << Name; 1568 return true; 1569 } 1570 1571 // We did find operator delete/operator delete[] declarations, but 1572 // none of them were suitable. 1573 if (!Found.empty()) { 1574 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found) 1575 << Name << RD; 1576 1577 for (LookupResult::iterator F = Found.begin(), FEnd = Found.end(); 1578 F != FEnd; ++F) 1579 Diag((*F)->getUnderlyingDecl()->getLocation(), 1580 diag::note_member_declared_here) << Name; 1581 1582 return true; 1583 } 1584 1585 // Look for a global declaration. 1586 DeclareGlobalNewDelete(); 1587 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 1588 1589 CXXNullPtrLiteralExpr Null(Context.VoidPtrTy, SourceLocation()); 1590 Expr* DeallocArgs[1]; 1591 DeallocArgs[0] = &Null; 1592 if (FindAllocationOverload(StartLoc, SourceRange(), Name, 1593 DeallocArgs, 1, TUDecl, /*AllowMissing=*/false, 1594 Operator)) 1595 return true; 1596 1597 assert(Operator && "Did not find a deallocation function!"); 1598 return false; 1599} 1600 1601/// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in: 1602/// @code ::delete ptr; @endcode 1603/// or 1604/// @code delete [] ptr; @endcode 1605ExprResult 1606Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, 1607 bool ArrayForm, Expr *Ex) { 1608 // C++ [expr.delete]p1: 1609 // The operand shall have a pointer type, or a class type having a single 1610 // conversion function to a pointer type. The result has type void. 1611 // 1612 // DR599 amends "pointer type" to "pointer to object type" in both cases. 1613 1614 FunctionDecl *OperatorDelete = 0; 1615 bool ArrayFormAsWritten = ArrayForm; 1616 bool UsualArrayDeleteWantsSize = false; 1617 1618 if (!Ex->isTypeDependent()) { 1619 QualType Type = Ex->getType(); 1620 1621 if (const RecordType *Record = Type->getAs<RecordType>()) { 1622 if (RequireCompleteType(StartLoc, Type, 1623 PDiag(diag::err_delete_incomplete_class_type))) 1624 return ExprError(); 1625 1626 llvm::SmallVector<CXXConversionDecl*, 4> ObjectPtrConversions; 1627 1628 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); 1629 const UnresolvedSetImpl *Conversions = RD->getVisibleConversionFunctions(); 1630 for (UnresolvedSetImpl::iterator I = Conversions->begin(), 1631 E = Conversions->end(); I != E; ++I) { 1632 NamedDecl *D = I.getDecl(); 1633 if (isa<UsingShadowDecl>(D)) 1634 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 1635 1636 // Skip over templated conversion functions; they aren't considered. 1637 if (isa<FunctionTemplateDecl>(D)) 1638 continue; 1639 1640 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D); 1641 1642 QualType ConvType = Conv->getConversionType().getNonReferenceType(); 1643 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>()) 1644 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType()) 1645 ObjectPtrConversions.push_back(Conv); 1646 } 1647 if (ObjectPtrConversions.size() == 1) { 1648 // We have a single conversion to a pointer-to-object type. Perform 1649 // that conversion. 1650 // TODO: don't redo the conversion calculation. 1651 if (!PerformImplicitConversion(Ex, 1652 ObjectPtrConversions.front()->getConversionType(), 1653 AA_Converting)) { 1654 Type = Ex->getType(); 1655 } 1656 } 1657 else if (ObjectPtrConversions.size() > 1) { 1658 Diag(StartLoc, diag::err_ambiguous_delete_operand) 1659 << Type << Ex->getSourceRange(); 1660 for (unsigned i= 0; i < ObjectPtrConversions.size(); i++) 1661 NoteOverloadCandidate(ObjectPtrConversions[i]); 1662 return ExprError(); 1663 } 1664 } 1665 1666 if (!Type->isPointerType()) 1667 return ExprError(Diag(StartLoc, diag::err_delete_operand) 1668 << Type << Ex->getSourceRange()); 1669 1670 QualType Pointee = Type->getAs<PointerType>()->getPointeeType(); 1671 if (Pointee->isVoidType() && !isSFINAEContext()) { 1672 // The C++ standard bans deleting a pointer to a non-object type, which 1673 // effectively bans deletion of "void*". However, most compilers support 1674 // this, so we treat it as a warning unless we're in a SFINAE context. 1675 Diag(StartLoc, diag::ext_delete_void_ptr_operand) 1676 << Type << Ex->getSourceRange(); 1677 } else if (Pointee->isFunctionType() || Pointee->isVoidType()) 1678 return ExprError(Diag(StartLoc, diag::err_delete_operand) 1679 << Type << Ex->getSourceRange()); 1680 else if (!Pointee->isDependentType() && 1681 RequireCompleteType(StartLoc, Pointee, 1682 PDiag(diag::warn_delete_incomplete) 1683 << Ex->getSourceRange())) 1684 return ExprError(); 1685 1686 // C++ [expr.delete]p2: 1687 // [Note: a pointer to a const type can be the operand of a 1688 // delete-expression; it is not necessary to cast away the constness 1689 // (5.2.11) of the pointer expression before it is used as the operand 1690 // of the delete-expression. ] 1691 ImpCastExprToType(Ex, Context.getPointerType(Context.VoidTy), 1692 CK_NoOp); 1693 1694 if (Pointee->isArrayType() && !ArrayForm) { 1695 Diag(StartLoc, diag::warn_delete_array_type) 1696 << Type << Ex->getSourceRange() 1697 << FixItHint::CreateInsertion(PP.getLocForEndOfToken(StartLoc), "[]"); 1698 ArrayForm = true; 1699 } 1700 1701 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName( 1702 ArrayForm ? OO_Array_Delete : OO_Delete); 1703 1704 QualType PointeeElem = Context.getBaseElementType(Pointee); 1705 if (const RecordType *RT = PointeeElem->getAs<RecordType>()) { 1706 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1707 1708 if (!UseGlobal && 1709 FindDeallocationFunction(StartLoc, RD, DeleteName, OperatorDelete)) 1710 return ExprError(); 1711 1712 // If we're allocating an array of records, check whether the 1713 // usual operator delete[] has a size_t parameter. 1714 if (ArrayForm) { 1715 // If the user specifically asked to use the global allocator, 1716 // we'll need to do the lookup into the class. 1717 if (UseGlobal) 1718 UsualArrayDeleteWantsSize = 1719 doesUsualArrayDeleteWantSize(*this, StartLoc, PointeeElem); 1720 1721 // Otherwise, the usual operator delete[] should be the 1722 // function we just found. 1723 else if (isa<CXXMethodDecl>(OperatorDelete)) 1724 UsualArrayDeleteWantsSize = (OperatorDelete->getNumParams() == 2); 1725 } 1726 1727 if (!RD->hasTrivialDestructor()) 1728 if (CXXDestructorDecl *Dtor = LookupDestructor(RD)) { 1729 MarkDeclarationReferenced(StartLoc, 1730 const_cast<CXXDestructorDecl*>(Dtor)); 1731 DiagnoseUseOfDecl(Dtor, StartLoc); 1732 } 1733 } 1734 1735 if (!OperatorDelete) { 1736 // Look for a global declaration. 1737 DeclareGlobalNewDelete(); 1738 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 1739 if (FindAllocationOverload(StartLoc, SourceRange(), DeleteName, 1740 &Ex, 1, TUDecl, /*AllowMissing=*/false, 1741 OperatorDelete)) 1742 return ExprError(); 1743 } 1744 1745 MarkDeclarationReferenced(StartLoc, OperatorDelete); 1746 1747 // Check access and ambiguity of operator delete and destructor. 1748 if (const RecordType *RT = PointeeElem->getAs<RecordType>()) { 1749 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1750 if (CXXDestructorDecl *Dtor = LookupDestructor(RD)) { 1751 CheckDestructorAccess(Ex->getExprLoc(), Dtor, 1752 PDiag(diag::err_access_dtor) << PointeeElem); 1753 } 1754 } 1755 1756 } 1757 1758 return Owned(new (Context) CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm, 1759 ArrayFormAsWritten, 1760 UsualArrayDeleteWantsSize, 1761 OperatorDelete, Ex, StartLoc)); 1762} 1763 1764/// \brief Check the use of the given variable as a C++ condition in an if, 1765/// while, do-while, or switch statement. 1766ExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar, 1767 SourceLocation StmtLoc, 1768 bool ConvertToBoolean) { 1769 QualType T = ConditionVar->getType(); 1770 1771 // C++ [stmt.select]p2: 1772 // The declarator shall not specify a function or an array. 1773 if (T->isFunctionType()) 1774 return ExprError(Diag(ConditionVar->getLocation(), 1775 diag::err_invalid_use_of_function_type) 1776 << ConditionVar->getSourceRange()); 1777 else if (T->isArrayType()) 1778 return ExprError(Diag(ConditionVar->getLocation(), 1779 diag::err_invalid_use_of_array_type) 1780 << ConditionVar->getSourceRange()); 1781 1782 Expr *Condition = DeclRefExpr::Create(Context, 0, SourceRange(), ConditionVar, 1783 ConditionVar->getLocation(), 1784 ConditionVar->getType().getNonReferenceType(), 1785 VK_LValue); 1786 if (ConvertToBoolean && CheckBooleanCondition(Condition, StmtLoc)) 1787 return ExprError(); 1788 1789 return Owned(Condition); 1790} 1791 1792/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid. 1793bool Sema::CheckCXXBooleanCondition(Expr *&CondExpr) { 1794 // C++ 6.4p4: 1795 // The value of a condition that is an initialized declaration in a statement 1796 // other than a switch statement is the value of the declared variable 1797 // implicitly converted to type bool. If that conversion is ill-formed, the 1798 // program is ill-formed. 1799 // The value of a condition that is an expression is the value of the 1800 // expression, implicitly converted to bool. 1801 // 1802 return PerformContextuallyConvertToBool(CondExpr); 1803} 1804 1805/// Helper function to determine whether this is the (deprecated) C++ 1806/// conversion from a string literal to a pointer to non-const char or 1807/// non-const wchar_t (for narrow and wide string literals, 1808/// respectively). 1809bool 1810Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) { 1811 // Look inside the implicit cast, if it exists. 1812 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From)) 1813 From = Cast->getSubExpr(); 1814 1815 // A string literal (2.13.4) that is not a wide string literal can 1816 // be converted to an rvalue of type "pointer to char"; a wide 1817 // string literal can be converted to an rvalue of type "pointer 1818 // to wchar_t" (C++ 4.2p2). 1819 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From->IgnoreParens())) 1820 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) 1821 if (const BuiltinType *ToPointeeType 1822 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) { 1823 // This conversion is considered only when there is an 1824 // explicit appropriate pointer target type (C++ 4.2p2). 1825 if (!ToPtrType->getPointeeType().hasQualifiers() && 1826 ((StrLit->isWide() && ToPointeeType->isWideCharType()) || 1827 (!StrLit->isWide() && 1828 (ToPointeeType->getKind() == BuiltinType::Char_U || 1829 ToPointeeType->getKind() == BuiltinType::Char_S)))) 1830 return true; 1831 } 1832 1833 return false; 1834} 1835 1836static ExprResult BuildCXXCastArgument(Sema &S, 1837 SourceLocation CastLoc, 1838 QualType Ty, 1839 CastKind Kind, 1840 CXXMethodDecl *Method, 1841 NamedDecl *FoundDecl, 1842 Expr *From) { 1843 switch (Kind) { 1844 default: assert(0 && "Unhandled cast kind!"); 1845 case CK_ConstructorConversion: { 1846 ASTOwningVector<Expr*> ConstructorArgs(S); 1847 1848 if (S.CompleteConstructorCall(cast<CXXConstructorDecl>(Method), 1849 MultiExprArg(&From, 1), 1850 CastLoc, ConstructorArgs)) 1851 return ExprError(); 1852 1853 ExprResult Result = 1854 S.BuildCXXConstructExpr(CastLoc, Ty, cast<CXXConstructorDecl>(Method), 1855 move_arg(ConstructorArgs), 1856 /*ZeroInit*/ false, CXXConstructExpr::CK_Complete, 1857 SourceRange()); 1858 if (Result.isInvalid()) 1859 return ExprError(); 1860 1861 return S.MaybeBindToTemporary(Result.takeAs<Expr>()); 1862 } 1863 1864 case CK_UserDefinedConversion: { 1865 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!"); 1866 1867 // Create an implicit call expr that calls it. 1868 ExprResult Result = S.BuildCXXMemberCallExpr(From, FoundDecl, Method); 1869 if (Result.isInvalid()) 1870 return ExprError(); 1871 1872 return S.MaybeBindToTemporary(Result.get()); 1873 } 1874 } 1875} 1876 1877/// PerformImplicitConversion - Perform an implicit conversion of the 1878/// expression From to the type ToType using the pre-computed implicit 1879/// conversion sequence ICS. Returns true if there was an error, false 1880/// otherwise. The expression From is replaced with the converted 1881/// expression. Action is the kind of conversion we're performing, 1882/// used in the error message. 1883bool 1884Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1885 const ImplicitConversionSequence &ICS, 1886 AssignmentAction Action, bool CStyle) { 1887 switch (ICS.getKind()) { 1888 case ImplicitConversionSequence::StandardConversion: 1889 if (PerformImplicitConversion(From, ToType, ICS.Standard, Action, 1890 CStyle)) 1891 return true; 1892 break; 1893 1894 case ImplicitConversionSequence::UserDefinedConversion: { 1895 1896 FunctionDecl *FD = ICS.UserDefined.ConversionFunction; 1897 CastKind CastKind; 1898 QualType BeforeToType; 1899 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) { 1900 CastKind = CK_UserDefinedConversion; 1901 1902 // If the user-defined conversion is specified by a conversion function, 1903 // the initial standard conversion sequence converts the source type to 1904 // the implicit object parameter of the conversion function. 1905 BeforeToType = Context.getTagDeclType(Conv->getParent()); 1906 } else { 1907 const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(FD); 1908 CastKind = CK_ConstructorConversion; 1909 // Do no conversion if dealing with ... for the first conversion. 1910 if (!ICS.UserDefined.EllipsisConversion) { 1911 // If the user-defined conversion is specified by a constructor, the 1912 // initial standard conversion sequence converts the source type to the 1913 // type required by the argument of the constructor 1914 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType(); 1915 } 1916 } 1917 // Watch out for elipsis conversion. 1918 if (!ICS.UserDefined.EllipsisConversion) { 1919 if (PerformImplicitConversion(From, BeforeToType, 1920 ICS.UserDefined.Before, AA_Converting, 1921 CStyle)) 1922 return true; 1923 } 1924 1925 ExprResult CastArg 1926 = BuildCXXCastArgument(*this, 1927 From->getLocStart(), 1928 ToType.getNonReferenceType(), 1929 CastKind, cast<CXXMethodDecl>(FD), 1930 ICS.UserDefined.FoundConversionFunction, 1931 From); 1932 1933 if (CastArg.isInvalid()) 1934 return true; 1935 1936 From = CastArg.takeAs<Expr>(); 1937 1938 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After, 1939 AA_Converting, CStyle); 1940 } 1941 1942 case ImplicitConversionSequence::AmbiguousConversion: 1943 ICS.DiagnoseAmbiguousConversion(*this, From->getExprLoc(), 1944 PDiag(diag::err_typecheck_ambiguous_condition) 1945 << From->getSourceRange()); 1946 return true; 1947 1948 case ImplicitConversionSequence::EllipsisConversion: 1949 assert(false && "Cannot perform an ellipsis conversion"); 1950 return false; 1951 1952 case ImplicitConversionSequence::BadConversion: 1953 return true; 1954 } 1955 1956 // Everything went well. 1957 return false; 1958} 1959 1960/// PerformImplicitConversion - Perform an implicit conversion of the 1961/// expression From to the type ToType by following the standard 1962/// conversion sequence SCS. Returns true if there was an error, false 1963/// otherwise. The expression From is replaced with the converted 1964/// expression. Flavor is the context in which we're performing this 1965/// conversion, for use in error messages. 1966bool 1967Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 1968 const StandardConversionSequence& SCS, 1969 AssignmentAction Action, bool CStyle) { 1970 // Overall FIXME: we are recomputing too many types here and doing far too 1971 // much extra work. What this means is that we need to keep track of more 1972 // information that is computed when we try the implicit conversion initially, 1973 // so that we don't need to recompute anything here. 1974 QualType FromType = From->getType(); 1975 1976 if (SCS.CopyConstructor) { 1977 // FIXME: When can ToType be a reference type? 1978 assert(!ToType->isReferenceType()); 1979 if (SCS.Second == ICK_Derived_To_Base) { 1980 ASTOwningVector<Expr*> ConstructorArgs(*this); 1981 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor), 1982 MultiExprArg(*this, &From, 1), 1983 /*FIXME:ConstructLoc*/SourceLocation(), 1984 ConstructorArgs)) 1985 return true; 1986 ExprResult FromResult = 1987 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 1988 ToType, SCS.CopyConstructor, 1989 move_arg(ConstructorArgs), 1990 /*ZeroInit*/ false, 1991 CXXConstructExpr::CK_Complete, 1992 SourceRange()); 1993 if (FromResult.isInvalid()) 1994 return true; 1995 From = FromResult.takeAs<Expr>(); 1996 return false; 1997 } 1998 ExprResult FromResult = 1999 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 2000 ToType, SCS.CopyConstructor, 2001 MultiExprArg(*this, &From, 1), 2002 /*ZeroInit*/ false, 2003 CXXConstructExpr::CK_Complete, 2004 SourceRange()); 2005 2006 if (FromResult.isInvalid()) 2007 return true; 2008 2009 From = FromResult.takeAs<Expr>(); 2010 return false; 2011 } 2012 2013 // Resolve overloaded function references. 2014 if (Context.hasSameType(FromType, Context.OverloadTy)) { 2015 DeclAccessPair Found; 2016 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, 2017 true, Found); 2018 if (!Fn) 2019 return true; 2020 2021 if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin())) 2022 return true; 2023 2024 From = FixOverloadedFunctionReference(From, Found, Fn); 2025 FromType = From->getType(); 2026 } 2027 2028 // Perform the first implicit conversion. 2029 switch (SCS.First) { 2030 case ICK_Identity: 2031 // Nothing to do. 2032 break; 2033 2034 case ICK_Lvalue_To_Rvalue: 2035 // Should this get its own ICK? 2036 if (From->getObjectKind() == OK_ObjCProperty) { 2037 ConvertPropertyForRValue(From); 2038 if (!From->isGLValue()) break; 2039 } 2040 2041 // Check for trivial buffer overflows. 2042 if (const ArraySubscriptExpr *AE = dyn_cast<ArraySubscriptExpr>(From)) 2043 CheckArrayAccess(AE); 2044 2045 FromType = FromType.getUnqualifiedType(); 2046 From = ImplicitCastExpr::Create(Context, FromType, CK_LValueToRValue, 2047 From, 0, VK_RValue); 2048 break; 2049 2050 case ICK_Array_To_Pointer: 2051 FromType = Context.getArrayDecayedType(FromType); 2052 ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay); 2053 break; 2054 2055 case ICK_Function_To_Pointer: 2056 FromType = Context.getPointerType(FromType); 2057 ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay); 2058 break; 2059 2060 default: 2061 assert(false && "Improper first standard conversion"); 2062 break; 2063 } 2064 2065 // Perform the second implicit conversion 2066 switch (SCS.Second) { 2067 case ICK_Identity: 2068 // If both sides are functions (or pointers/references to them), there could 2069 // be incompatible exception declarations. 2070 if (CheckExceptionSpecCompatibility(From, ToType)) 2071 return true; 2072 // Nothing else to do. 2073 break; 2074 2075 case ICK_NoReturn_Adjustment: 2076 // If both sides are functions (or pointers/references to them), there could 2077 // be incompatible exception declarations. 2078 if (CheckExceptionSpecCompatibility(From, ToType)) 2079 return true; 2080 2081 ImpCastExprToType(From, ToType, CK_NoOp); 2082 break; 2083 2084 case ICK_Integral_Promotion: 2085 case ICK_Integral_Conversion: 2086 ImpCastExprToType(From, ToType, CK_IntegralCast); 2087 break; 2088 2089 case ICK_Floating_Promotion: 2090 case ICK_Floating_Conversion: 2091 ImpCastExprToType(From, ToType, CK_FloatingCast); 2092 break; 2093 2094 case ICK_Complex_Promotion: 2095 case ICK_Complex_Conversion: { 2096 QualType FromEl = From->getType()->getAs<ComplexType>()->getElementType(); 2097 QualType ToEl = ToType->getAs<ComplexType>()->getElementType(); 2098 CastKind CK; 2099 if (FromEl->isRealFloatingType()) { 2100 if (ToEl->isRealFloatingType()) 2101 CK = CK_FloatingComplexCast; 2102 else 2103 CK = CK_FloatingComplexToIntegralComplex; 2104 } else if (ToEl->isRealFloatingType()) { 2105 CK = CK_IntegralComplexToFloatingComplex; 2106 } else { 2107 CK = CK_IntegralComplexCast; 2108 } 2109 ImpCastExprToType(From, ToType, CK); 2110 break; 2111 } 2112 2113 case ICK_Floating_Integral: 2114 if (ToType->isRealFloatingType()) 2115 ImpCastExprToType(From, ToType, CK_IntegralToFloating); 2116 else 2117 ImpCastExprToType(From, ToType, CK_FloatingToIntegral); 2118 break; 2119 2120 case ICK_Compatible_Conversion: 2121 ImpCastExprToType(From, ToType, CK_NoOp); 2122 break; 2123 2124 case ICK_Pointer_Conversion: { 2125 if (SCS.IncompatibleObjC && Action != AA_Casting) { 2126 // Diagnose incompatible Objective-C conversions 2127 Diag(From->getSourceRange().getBegin(), 2128 diag::ext_typecheck_convert_incompatible_pointer) 2129 << From->getType() << ToType << Action 2130 << From->getSourceRange(); 2131 } 2132 2133 CastKind Kind = CK_Invalid; 2134 CXXCastPath BasePath; 2135 if (CheckPointerConversion(From, ToType, Kind, BasePath, CStyle)) 2136 return true; 2137 ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath); 2138 break; 2139 } 2140 2141 case ICK_Pointer_Member: { 2142 CastKind Kind = CK_Invalid; 2143 CXXCastPath BasePath; 2144 if (CheckMemberPointerConversion(From, ToType, Kind, BasePath, CStyle)) 2145 return true; 2146 if (CheckExceptionSpecCompatibility(From, ToType)) 2147 return true; 2148 ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath); 2149 break; 2150 } 2151 case ICK_Boolean_Conversion: { 2152 CastKind Kind = CK_Invalid; 2153 switch (FromType->getScalarTypeKind()) { 2154 case Type::STK_Pointer: Kind = CK_PointerToBoolean; break; 2155 case Type::STK_MemberPointer: Kind = CK_MemberPointerToBoolean; break; 2156 case Type::STK_Bool: llvm_unreachable("bool -> bool conversion?"); 2157 case Type::STK_Integral: Kind = CK_IntegralToBoolean; break; 2158 case Type::STK_Floating: Kind = CK_FloatingToBoolean; break; 2159 case Type::STK_IntegralComplex: Kind = CK_IntegralComplexToBoolean; break; 2160 case Type::STK_FloatingComplex: Kind = CK_FloatingComplexToBoolean; break; 2161 } 2162 2163 ImpCastExprToType(From, Context.BoolTy, Kind); 2164 break; 2165 } 2166 2167 case ICK_Derived_To_Base: { 2168 CXXCastPath BasePath; 2169 if (CheckDerivedToBaseConversion(From->getType(), 2170 ToType.getNonReferenceType(), 2171 From->getLocStart(), 2172 From->getSourceRange(), 2173 &BasePath, 2174 CStyle)) 2175 return true; 2176 2177 ImpCastExprToType(From, ToType.getNonReferenceType(), 2178 CK_DerivedToBase, CastCategory(From), 2179 &BasePath); 2180 break; 2181 } 2182 2183 case ICK_Vector_Conversion: 2184 ImpCastExprToType(From, ToType, CK_BitCast); 2185 break; 2186 2187 case ICK_Vector_Splat: 2188 ImpCastExprToType(From, ToType, CK_VectorSplat); 2189 break; 2190 2191 case ICK_Complex_Real: 2192 // Case 1. x -> _Complex y 2193 if (const ComplexType *ToComplex = ToType->getAs<ComplexType>()) { 2194 QualType ElType = ToComplex->getElementType(); 2195 bool isFloatingComplex = ElType->isRealFloatingType(); 2196 2197 // x -> y 2198 if (Context.hasSameUnqualifiedType(ElType, From->getType())) { 2199 // do nothing 2200 } else if (From->getType()->isRealFloatingType()) { 2201 ImpCastExprToType(From, ElType, 2202 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral); 2203 } else { 2204 assert(From->getType()->isIntegerType()); 2205 ImpCastExprToType(From, ElType, 2206 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast); 2207 } 2208 // y -> _Complex y 2209 ImpCastExprToType(From, ToType, 2210 isFloatingComplex ? CK_FloatingRealToComplex 2211 : CK_IntegralRealToComplex); 2212 2213 // Case 2. _Complex x -> y 2214 } else { 2215 const ComplexType *FromComplex = From->getType()->getAs<ComplexType>(); 2216 assert(FromComplex); 2217 2218 QualType ElType = FromComplex->getElementType(); 2219 bool isFloatingComplex = ElType->isRealFloatingType(); 2220 2221 // _Complex x -> x 2222 ImpCastExprToType(From, ElType, 2223 isFloatingComplex ? CK_FloatingComplexToReal 2224 : CK_IntegralComplexToReal); 2225 2226 // x -> y 2227 if (Context.hasSameUnqualifiedType(ElType, ToType)) { 2228 // do nothing 2229 } else if (ToType->isRealFloatingType()) { 2230 ImpCastExprToType(From, ToType, 2231 isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating); 2232 } else { 2233 assert(ToType->isIntegerType()); 2234 ImpCastExprToType(From, ToType, 2235 isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast); 2236 } 2237 } 2238 break; 2239 2240 case ICK_Block_Pointer_Conversion: { 2241 ImpCastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast, VK_RValue); 2242 break; 2243 } 2244 2245 case ICK_Lvalue_To_Rvalue: 2246 case ICK_Array_To_Pointer: 2247 case ICK_Function_To_Pointer: 2248 case ICK_Qualification: 2249 case ICK_Num_Conversion_Kinds: 2250 assert(false && "Improper second standard conversion"); 2251 break; 2252 } 2253 2254 switch (SCS.Third) { 2255 case ICK_Identity: 2256 // Nothing to do. 2257 break; 2258 2259 case ICK_Qualification: { 2260 // The qualification keeps the category of the inner expression, unless the 2261 // target type isn't a reference. 2262 ExprValueKind VK = ToType->isReferenceType() ? 2263 CastCategory(From) : VK_RValue; 2264 ImpCastExprToType(From, ToType.getNonLValueExprType(Context), 2265 CK_NoOp, VK); 2266 2267 if (SCS.DeprecatedStringLiteralToCharPtr) 2268 Diag(From->getLocStart(), diag::warn_deprecated_string_literal_conversion) 2269 << ToType.getNonReferenceType(); 2270 2271 break; 2272 } 2273 2274 default: 2275 assert(false && "Improper third standard conversion"); 2276 break; 2277 } 2278 2279 return false; 2280} 2281 2282ExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait UTT, 2283 SourceLocation KWLoc, 2284 ParsedType Ty, 2285 SourceLocation RParen) { 2286 TypeSourceInfo *TSInfo; 2287 QualType T = GetTypeFromParser(Ty, &TSInfo); 2288 2289 if (!TSInfo) 2290 TSInfo = Context.getTrivialTypeSourceInfo(T); 2291 return BuildUnaryTypeTrait(UTT, KWLoc, TSInfo, RParen); 2292} 2293 2294static bool EvaluateUnaryTypeTrait(Sema &Self, UnaryTypeTrait UTT, QualType T, 2295 SourceLocation KeyLoc) { 2296 // FIXME: For many of these traits, we need a complete type before we can 2297 // check these properties. 2298 assert(!T->isDependentType() && 2299 "Cannot evaluate traits for dependent types."); 2300 ASTContext &C = Self.Context; 2301 switch(UTT) { 2302 default: assert(false && "Unknown type trait or not implemented"); 2303 case UTT_IsPOD: return T->isPODType(); 2304 case UTT_IsLiteral: return T->isLiteralType(); 2305 case UTT_IsClass: // Fallthrough 2306 case UTT_IsUnion: 2307 if (const RecordType *Record = T->getAs<RecordType>()) { 2308 bool Union = Record->getDecl()->isUnion(); 2309 return UTT == UTT_IsUnion ? Union : !Union; 2310 } 2311 return false; 2312 case UTT_IsEnum: return T->isEnumeralType(); 2313 case UTT_IsPolymorphic: 2314 if (const RecordType *Record = T->getAs<RecordType>()) { 2315 // Type traits are only parsed in C++, so we've got CXXRecords. 2316 return cast<CXXRecordDecl>(Record->getDecl())->isPolymorphic(); 2317 } 2318 return false; 2319 case UTT_IsAbstract: 2320 if (const RecordType *RT = T->getAs<RecordType>()) 2321 return cast<CXXRecordDecl>(RT->getDecl())->isAbstract(); 2322 return false; 2323 case UTT_IsEmpty: 2324 if (const RecordType *Record = T->getAs<RecordType>()) { 2325 return !Record->getDecl()->isUnion() 2326 && cast<CXXRecordDecl>(Record->getDecl())->isEmpty(); 2327 } 2328 return false; 2329 case UTT_HasTrivialConstructor: 2330 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2331 // If __is_pod (type) is true then the trait is true, else if type is 2332 // a cv class or union type (or array thereof) with a trivial default 2333 // constructor ([class.ctor]) then the trait is true, else it is false. 2334 if (T->isPODType()) 2335 return true; 2336 if (const RecordType *RT = 2337 C.getBaseElementType(T)->getAs<RecordType>()) 2338 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialConstructor(); 2339 return false; 2340 case UTT_HasTrivialCopy: 2341 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2342 // If __is_pod (type) is true or type is a reference type then 2343 // the trait is true, else if type is a cv class or union type 2344 // with a trivial copy constructor ([class.copy]) then the trait 2345 // is true, else it is false. 2346 if (T->isPODType() || T->isReferenceType()) 2347 return true; 2348 if (const RecordType *RT = T->getAs<RecordType>()) 2349 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialCopyConstructor(); 2350 return false; 2351 case UTT_HasTrivialAssign: 2352 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2353 // If type is const qualified or is a reference type then the 2354 // trait is false. Otherwise if __is_pod (type) is true then the 2355 // trait is true, else if type is a cv class or union type with 2356 // a trivial copy assignment ([class.copy]) then the trait is 2357 // true, else it is false. 2358 // Note: the const and reference restrictions are interesting, 2359 // given that const and reference members don't prevent a class 2360 // from having a trivial copy assignment operator (but do cause 2361 // errors if the copy assignment operator is actually used, q.v. 2362 // [class.copy]p12). 2363 2364 if (C.getBaseElementType(T).isConstQualified()) 2365 return false; 2366 if (T->isPODType()) 2367 return true; 2368 if (const RecordType *RT = T->getAs<RecordType>()) 2369 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialCopyAssignment(); 2370 return false; 2371 case UTT_HasTrivialDestructor: 2372 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2373 // If __is_pod (type) is true or type is a reference type 2374 // then the trait is true, else if type is a cv class or union 2375 // type (or array thereof) with a trivial destructor 2376 // ([class.dtor]) then the trait is true, else it is 2377 // false. 2378 if (T->isPODType() || T->isReferenceType()) 2379 return true; 2380 if (const RecordType *RT = 2381 C.getBaseElementType(T)->getAs<RecordType>()) 2382 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialDestructor(); 2383 return false; 2384 // TODO: Propagate nothrowness for implicitly declared special members. 2385 case UTT_HasNothrowAssign: 2386 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2387 // If type is const qualified or is a reference type then the 2388 // trait is false. Otherwise if __has_trivial_assign (type) 2389 // is true then the trait is true, else if type is a cv class 2390 // or union type with copy assignment operators that are known 2391 // not to throw an exception then the trait is true, else it is 2392 // false. 2393 if (C.getBaseElementType(T).isConstQualified()) 2394 return false; 2395 if (T->isReferenceType()) 2396 return false; 2397 if (T->isPODType()) 2398 return true; 2399 if (const RecordType *RT = T->getAs<RecordType>()) { 2400 CXXRecordDecl* RD = cast<CXXRecordDecl>(RT->getDecl()); 2401 if (RD->hasTrivialCopyAssignment()) 2402 return true; 2403 2404 bool FoundAssign = false; 2405 bool AllNoThrow = true; 2406 DeclarationName Name = C.DeclarationNames.getCXXOperatorName(OO_Equal); 2407 LookupResult Res(Self, DeclarationNameInfo(Name, KeyLoc), 2408 Sema::LookupOrdinaryName); 2409 if (Self.LookupQualifiedName(Res, RD)) { 2410 for (LookupResult::iterator Op = Res.begin(), OpEnd = Res.end(); 2411 Op != OpEnd; ++Op) { 2412 CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op); 2413 if (Operator->isCopyAssignmentOperator()) { 2414 FoundAssign = true; 2415 const FunctionProtoType *CPT 2416 = Operator->getType()->getAs<FunctionProtoType>(); 2417 if (!CPT->hasEmptyExceptionSpec()) { 2418 AllNoThrow = false; 2419 break; 2420 } 2421 } 2422 } 2423 } 2424 2425 return FoundAssign && AllNoThrow; 2426 } 2427 return false; 2428 case UTT_HasNothrowCopy: 2429 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2430 // If __has_trivial_copy (type) is true then the trait is true, else 2431 // if type is a cv class or union type with copy constructors that are 2432 // known not to throw an exception then the trait is true, else it is 2433 // false. 2434 if (T->isPODType() || T->isReferenceType()) 2435 return true; 2436 if (const RecordType *RT = T->getAs<RecordType>()) { 2437 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 2438 if (RD->hasTrivialCopyConstructor()) 2439 return true; 2440 2441 bool FoundConstructor = false; 2442 bool AllNoThrow = true; 2443 unsigned FoundTQs; 2444 DeclContext::lookup_const_iterator Con, ConEnd; 2445 for (llvm::tie(Con, ConEnd) = Self.LookupConstructors(RD); 2446 Con != ConEnd; ++Con) { 2447 // A template constructor is never a copy constructor. 2448 // FIXME: However, it may actually be selected at the actual overload 2449 // resolution point. 2450 if (isa<FunctionTemplateDecl>(*Con)) 2451 continue; 2452 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con); 2453 if (Constructor->isCopyConstructor(FoundTQs)) { 2454 FoundConstructor = true; 2455 const FunctionProtoType *CPT 2456 = Constructor->getType()->getAs<FunctionProtoType>(); 2457 // TODO: check whether evaluating default arguments can throw. 2458 // For now, we'll be conservative and assume that they can throw. 2459 if (!CPT->hasEmptyExceptionSpec() || CPT->getNumArgs() > 1) { 2460 AllNoThrow = false; 2461 break; 2462 } 2463 } 2464 } 2465 2466 return FoundConstructor && AllNoThrow; 2467 } 2468 return false; 2469 case UTT_HasNothrowConstructor: 2470 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2471 // If __has_trivial_constructor (type) is true then the trait is 2472 // true, else if type is a cv class or union type (or array 2473 // thereof) with a default constructor that is known not to 2474 // throw an exception then the trait is true, else it is false. 2475 if (T->isPODType()) 2476 return true; 2477 if (const RecordType *RT = C.getBaseElementType(T)->getAs<RecordType>()) { 2478 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 2479 if (RD->hasTrivialConstructor()) 2480 return true; 2481 2482 DeclContext::lookup_const_iterator Con, ConEnd; 2483 for (llvm::tie(Con, ConEnd) = Self.LookupConstructors(RD); 2484 Con != ConEnd; ++Con) { 2485 // FIXME: In C++0x, a constructor template can be a default constructor. 2486 if (isa<FunctionTemplateDecl>(*Con)) 2487 continue; 2488 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con); 2489 if (Constructor->isDefaultConstructor()) { 2490 const FunctionProtoType *CPT 2491 = Constructor->getType()->getAs<FunctionProtoType>(); 2492 // TODO: check whether evaluating default arguments can throw. 2493 // For now, we'll be conservative and assume that they can throw. 2494 return CPT->hasEmptyExceptionSpec() && CPT->getNumArgs() == 0; 2495 } 2496 } 2497 } 2498 return false; 2499 case UTT_HasVirtualDestructor: 2500 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2501 // If type is a class type with a virtual destructor ([class.dtor]) 2502 // then the trait is true, else it is false. 2503 if (const RecordType *Record = T->getAs<RecordType>()) { 2504 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); 2505 if (CXXDestructorDecl *Destructor = Self.LookupDestructor(RD)) 2506 return Destructor->isVirtual(); 2507 } 2508 return false; 2509 } 2510} 2511 2512ExprResult Sema::BuildUnaryTypeTrait(UnaryTypeTrait UTT, 2513 SourceLocation KWLoc, 2514 TypeSourceInfo *TSInfo, 2515 SourceLocation RParen) { 2516 QualType T = TSInfo->getType(); 2517 2518 // According to http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html 2519 // all traits except __is_class, __is_enum and __is_union require a the type 2520 // to be complete, an array of unknown bound, or void. 2521 if (UTT != UTT_IsClass && UTT != UTT_IsEnum && UTT != UTT_IsUnion) { 2522 QualType E = T; 2523 if (T->isIncompleteArrayType()) 2524 E = Context.getAsArrayType(T)->getElementType(); 2525 if (!T->isVoidType() && 2526 RequireCompleteType(KWLoc, E, 2527 diag::err_incomplete_type_used_in_type_trait_expr)) 2528 return ExprError(); 2529 } 2530 2531 bool Value = false; 2532 if (!T->isDependentType()) 2533 Value = EvaluateUnaryTypeTrait(*this, UTT, T, KWLoc); 2534 2535 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, UTT, TSInfo, Value, 2536 RParen, Context.BoolTy)); 2537} 2538 2539ExprResult Sema::ActOnBinaryTypeTrait(BinaryTypeTrait BTT, 2540 SourceLocation KWLoc, 2541 ParsedType LhsTy, 2542 ParsedType RhsTy, 2543 SourceLocation RParen) { 2544 TypeSourceInfo *LhsTSInfo; 2545 QualType LhsT = GetTypeFromParser(LhsTy, &LhsTSInfo); 2546 if (!LhsTSInfo) 2547 LhsTSInfo = Context.getTrivialTypeSourceInfo(LhsT); 2548 2549 TypeSourceInfo *RhsTSInfo; 2550 QualType RhsT = GetTypeFromParser(RhsTy, &RhsTSInfo); 2551 if (!RhsTSInfo) 2552 RhsTSInfo = Context.getTrivialTypeSourceInfo(RhsT); 2553 2554 return BuildBinaryTypeTrait(BTT, KWLoc, LhsTSInfo, RhsTSInfo, RParen); 2555} 2556 2557static bool EvaluateBinaryTypeTrait(Sema &Self, BinaryTypeTrait BTT, 2558 QualType LhsT, QualType RhsT, 2559 SourceLocation KeyLoc) { 2560 assert((!LhsT->isDependentType() || RhsT->isDependentType()) && 2561 "Cannot evaluate traits for dependent types."); 2562 2563 switch(BTT) { 2564 case BTT_IsBaseOf: { 2565 // C++0x [meta.rel]p2 2566 // Base is a base class of Derived without regard to cv-qualifiers or 2567 // Base and Derived are not unions and name the same class type without 2568 // regard to cv-qualifiers. 2569 2570 const RecordType *lhsRecord = LhsT->getAs<RecordType>(); 2571 if (!lhsRecord) return false; 2572 2573 const RecordType *rhsRecord = RhsT->getAs<RecordType>(); 2574 if (!rhsRecord) return false; 2575 2576 assert(Self.Context.hasSameUnqualifiedType(LhsT, RhsT) 2577 == (lhsRecord == rhsRecord)); 2578 2579 if (lhsRecord == rhsRecord) 2580 return !lhsRecord->getDecl()->isUnion(); 2581 2582 // C++0x [meta.rel]p2: 2583 // If Base and Derived are class types and are different types 2584 // (ignoring possible cv-qualifiers) then Derived shall be a 2585 // complete type. 2586 if (Self.RequireCompleteType(KeyLoc, RhsT, 2587 diag::err_incomplete_type_used_in_type_trait_expr)) 2588 return false; 2589 2590 return cast<CXXRecordDecl>(rhsRecord->getDecl()) 2591 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->getDecl())); 2592 } 2593 2594 case BTT_TypeCompatible: 2595 return Self.Context.typesAreCompatible(LhsT.getUnqualifiedType(), 2596 RhsT.getUnqualifiedType()); 2597 2598 case BTT_IsConvertibleTo: { 2599 // C++0x [meta.rel]p4: 2600 // Given the following function prototype: 2601 // 2602 // template <class T> 2603 // typename add_rvalue_reference<T>::type create(); 2604 // 2605 // the predicate condition for a template specialization 2606 // is_convertible<From, To> shall be satisfied if and only if 2607 // the return expression in the following code would be 2608 // well-formed, including any implicit conversions to the return 2609 // type of the function: 2610 // 2611 // To test() { 2612 // return create<From>(); 2613 // } 2614 // 2615 // Access checking is performed as if in a context unrelated to To and 2616 // From. Only the validity of the immediate context of the expression 2617 // of the return-statement (including conversions to the return type) 2618 // is considered. 2619 // 2620 // We model the initialization as a copy-initialization of a temporary 2621 // of the appropriate type, which for this expression is identical to the 2622 // return statement (since NRVO doesn't apply). 2623 if (LhsT->isObjectType() || LhsT->isFunctionType()) 2624 LhsT = Self.Context.getRValueReferenceType(LhsT); 2625 2626 InitializedEntity To(InitializedEntity::InitializeTemporary(RhsT)); 2627 OpaqueValueExpr From(KeyLoc, LhsT.getNonLValueExprType(Self.Context), 2628 Expr::getValueKindForType(LhsT)); 2629 Expr *FromPtr = &From; 2630 InitializationKind Kind(InitializationKind::CreateCopy(KeyLoc, 2631 SourceLocation())); 2632 2633 // Perform the initialization within a SFINAE trap at translation unit 2634 // scope. 2635 Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true); 2636 Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl()); 2637 InitializationSequence Init(Self, To, Kind, &FromPtr, 1); 2638 if (Init.getKind() == InitializationSequence::FailedSequence) 2639 return false; 2640 2641 ExprResult Result = Init.Perform(Self, To, Kind, MultiExprArg(&FromPtr, 1)); 2642 return !Result.isInvalid() && !SFINAE.hasErrorOccurred(); 2643 } 2644 } 2645 llvm_unreachable("Unknown type trait or not implemented"); 2646} 2647 2648ExprResult Sema::BuildBinaryTypeTrait(BinaryTypeTrait BTT, 2649 SourceLocation KWLoc, 2650 TypeSourceInfo *LhsTSInfo, 2651 TypeSourceInfo *RhsTSInfo, 2652 SourceLocation RParen) { 2653 QualType LhsT = LhsTSInfo->getType(); 2654 QualType RhsT = RhsTSInfo->getType(); 2655 2656 if (BTT == BTT_TypeCompatible) { 2657 if (getLangOptions().CPlusPlus) { 2658 Diag(KWLoc, diag::err_types_compatible_p_in_cplusplus) 2659 << SourceRange(KWLoc, RParen); 2660 return ExprError(); 2661 } 2662 } 2663 2664 bool Value = false; 2665 if (!LhsT->isDependentType() && !RhsT->isDependentType()) 2666 Value = EvaluateBinaryTypeTrait(*this, BTT, LhsT, RhsT, KWLoc); 2667 2668 // Select trait result type. 2669 QualType ResultType; 2670 switch (BTT) { 2671 case BTT_IsBaseOf: ResultType = Context.BoolTy; break; 2672 case BTT_TypeCompatible: ResultType = Context.IntTy; break; 2673 case BTT_IsConvertibleTo: ResultType = Context.BoolTy; break; 2674 } 2675 2676 return Owned(new (Context) BinaryTypeTraitExpr(KWLoc, BTT, LhsTSInfo, 2677 RhsTSInfo, Value, RParen, 2678 ResultType)); 2679} 2680 2681QualType Sema::CheckPointerToMemberOperands(Expr *&lex, Expr *&rex, 2682 ExprValueKind &VK, 2683 SourceLocation Loc, 2684 bool isIndirect) { 2685 const char *OpSpelling = isIndirect ? "->*" : ".*"; 2686 // C++ 5.5p2 2687 // The binary operator .* [p3: ->*] binds its second operand, which shall 2688 // be of type "pointer to member of T" (where T is a completely-defined 2689 // class type) [...] 2690 QualType RType = rex->getType(); 2691 const MemberPointerType *MemPtr = RType->getAs<MemberPointerType>(); 2692 if (!MemPtr) { 2693 Diag(Loc, diag::err_bad_memptr_rhs) 2694 << OpSpelling << RType << rex->getSourceRange(); 2695 return QualType(); 2696 } 2697 2698 QualType Class(MemPtr->getClass(), 0); 2699 2700 // Note: C++ [expr.mptr.oper]p2-3 says that the class type into which the 2701 // member pointer points must be completely-defined. However, there is no 2702 // reason for this semantic distinction, and the rule is not enforced by 2703 // other compilers. Therefore, we do not check this property, as it is 2704 // likely to be considered a defect. 2705 2706 // C++ 5.5p2 2707 // [...] to its first operand, which shall be of class T or of a class of 2708 // which T is an unambiguous and accessible base class. [p3: a pointer to 2709 // such a class] 2710 QualType LType = lex->getType(); 2711 if (isIndirect) { 2712 if (const PointerType *Ptr = LType->getAs<PointerType>()) 2713 LType = Ptr->getPointeeType(); 2714 else { 2715 Diag(Loc, diag::err_bad_memptr_lhs) 2716 << OpSpelling << 1 << LType 2717 << FixItHint::CreateReplacement(SourceRange(Loc), ".*"); 2718 return QualType(); 2719 } 2720 } 2721 2722 if (!Context.hasSameUnqualifiedType(Class, LType)) { 2723 // If we want to check the hierarchy, we need a complete type. 2724 if (RequireCompleteType(Loc, LType, PDiag(diag::err_bad_memptr_lhs) 2725 << OpSpelling << (int)isIndirect)) { 2726 return QualType(); 2727 } 2728 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 2729 /*DetectVirtual=*/false); 2730 // FIXME: Would it be useful to print full ambiguity paths, or is that 2731 // overkill? 2732 if (!IsDerivedFrom(LType, Class, Paths) || 2733 Paths.isAmbiguous(Context.getCanonicalType(Class))) { 2734 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling 2735 << (int)isIndirect << lex->getType(); 2736 return QualType(); 2737 } 2738 // Cast LHS to type of use. 2739 QualType UseType = isIndirect ? Context.getPointerType(Class) : Class; 2740 ExprValueKind VK = 2741 isIndirect ? VK_RValue : CastCategory(lex); 2742 2743 CXXCastPath BasePath; 2744 BuildBasePathArray(Paths, BasePath); 2745 ImpCastExprToType(lex, UseType, CK_DerivedToBase, VK, &BasePath); 2746 } 2747 2748 if (isa<CXXScalarValueInitExpr>(rex->IgnoreParens())) { 2749 // Diagnose use of pointer-to-member type which when used as 2750 // the functional cast in a pointer-to-member expression. 2751 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect; 2752 return QualType(); 2753 } 2754 2755 // C++ 5.5p2 2756 // The result is an object or a function of the type specified by the 2757 // second operand. 2758 // The cv qualifiers are the union of those in the pointer and the left side, 2759 // in accordance with 5.5p5 and 5.2.5. 2760 // FIXME: This returns a dereferenced member function pointer as a normal 2761 // function type. However, the only operation valid on such functions is 2762 // calling them. There's also a GCC extension to get a function pointer to the 2763 // thing, which is another complication, because this type - unlike the type 2764 // that is the result of this expression - takes the class as the first 2765 // argument. 2766 // We probably need a "MemberFunctionClosureType" or something like that. 2767 QualType Result = MemPtr->getPointeeType(); 2768 Result = Context.getCVRQualifiedType(Result, LType.getCVRQualifiers()); 2769 2770 // C++0x [expr.mptr.oper]p6: 2771 // In a .* expression whose object expression is an rvalue, the program is 2772 // ill-formed if the second operand is a pointer to member function with 2773 // ref-qualifier &. In a ->* expression or in a .* expression whose object 2774 // expression is an lvalue, the program is ill-formed if the second operand 2775 // is a pointer to member function with ref-qualifier &&. 2776 if (const FunctionProtoType *Proto = Result->getAs<FunctionProtoType>()) { 2777 switch (Proto->getRefQualifier()) { 2778 case RQ_None: 2779 // Do nothing 2780 break; 2781 2782 case RQ_LValue: 2783 if (!isIndirect && !lex->Classify(Context).isLValue()) 2784 Diag(Loc, diag::err_pointer_to_member_oper_value_classify) 2785 << RType << 1 << lex->getSourceRange(); 2786 break; 2787 2788 case RQ_RValue: 2789 if (isIndirect || !lex->Classify(Context).isRValue()) 2790 Diag(Loc, diag::err_pointer_to_member_oper_value_classify) 2791 << RType << 0 << lex->getSourceRange(); 2792 break; 2793 } 2794 } 2795 2796 // C++ [expr.mptr.oper]p6: 2797 // The result of a .* expression whose second operand is a pointer 2798 // to a data member is of the same value category as its 2799 // first operand. The result of a .* expression whose second 2800 // operand is a pointer to a member function is a prvalue. The 2801 // result of an ->* expression is an lvalue if its second operand 2802 // is a pointer to data member and a prvalue otherwise. 2803 if (Result->isFunctionType()) 2804 VK = VK_RValue; 2805 else if (isIndirect) 2806 VK = VK_LValue; 2807 else 2808 VK = lex->getValueKind(); 2809 2810 return Result; 2811} 2812 2813/// \brief Try to convert a type to another according to C++0x 5.16p3. 2814/// 2815/// This is part of the parameter validation for the ? operator. If either 2816/// value operand is a class type, the two operands are attempted to be 2817/// converted to each other. This function does the conversion in one direction. 2818/// It returns true if the program is ill-formed and has already been diagnosed 2819/// as such. 2820static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, 2821 SourceLocation QuestionLoc, 2822 bool &HaveConversion, 2823 QualType &ToType) { 2824 HaveConversion = false; 2825 ToType = To->getType(); 2826 2827 InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(), 2828 SourceLocation()); 2829 // C++0x 5.16p3 2830 // The process for determining whether an operand expression E1 of type T1 2831 // can be converted to match an operand expression E2 of type T2 is defined 2832 // as follows: 2833 // -- If E2 is an lvalue: 2834 bool ToIsLvalue = To->isLValue(); 2835 if (ToIsLvalue) { 2836 // E1 can be converted to match E2 if E1 can be implicitly converted to 2837 // type "lvalue reference to T2", subject to the constraint that in the 2838 // conversion the reference must bind directly to E1. 2839 QualType T = Self.Context.getLValueReferenceType(ToType); 2840 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 2841 2842 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 2843 if (InitSeq.isDirectReferenceBinding()) { 2844 ToType = T; 2845 HaveConversion = true; 2846 return false; 2847 } 2848 2849 if (InitSeq.isAmbiguous()) 2850 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 2851 } 2852 2853 // -- If E2 is an rvalue, or if the conversion above cannot be done: 2854 // -- if E1 and E2 have class type, and the underlying class types are 2855 // the same or one is a base class of the other: 2856 QualType FTy = From->getType(); 2857 QualType TTy = To->getType(); 2858 const RecordType *FRec = FTy->getAs<RecordType>(); 2859 const RecordType *TRec = TTy->getAs<RecordType>(); 2860 bool FDerivedFromT = FRec && TRec && FRec != TRec && 2861 Self.IsDerivedFrom(FTy, TTy); 2862 if (FRec && TRec && 2863 (FRec == TRec || FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) { 2864 // E1 can be converted to match E2 if the class of T2 is the 2865 // same type as, or a base class of, the class of T1, and 2866 // [cv2 > cv1]. 2867 if (FRec == TRec || FDerivedFromT) { 2868 if (TTy.isAtLeastAsQualifiedAs(FTy)) { 2869 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 2870 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 2871 if (InitSeq.getKind() != InitializationSequence::FailedSequence) { 2872 HaveConversion = true; 2873 return false; 2874 } 2875 2876 if (InitSeq.isAmbiguous()) 2877 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 2878 } 2879 } 2880 2881 return false; 2882 } 2883 2884 // -- Otherwise: E1 can be converted to match E2 if E1 can be 2885 // implicitly converted to the type that expression E2 would have 2886 // if E2 were converted to an rvalue (or the type it has, if E2 is 2887 // an rvalue). 2888 // 2889 // This actually refers very narrowly to the lvalue-to-rvalue conversion, not 2890 // to the array-to-pointer or function-to-pointer conversions. 2891 if (!TTy->getAs<TagType>()) 2892 TTy = TTy.getUnqualifiedType(); 2893 2894 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 2895 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 2896 HaveConversion = InitSeq.getKind() != InitializationSequence::FailedSequence; 2897 ToType = TTy; 2898 if (InitSeq.isAmbiguous()) 2899 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 2900 2901 return false; 2902} 2903 2904/// \brief Try to find a common type for two according to C++0x 5.16p5. 2905/// 2906/// This is part of the parameter validation for the ? operator. If either 2907/// value operand is a class type, overload resolution is used to find a 2908/// conversion to a common type. 2909static bool FindConditionalOverload(Sema &Self, Expr *&LHS, Expr *&RHS, 2910 SourceLocation QuestionLoc) { 2911 Expr *Args[2] = { LHS, RHS }; 2912 OverloadCandidateSet CandidateSet(QuestionLoc); 2913 Self.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args, 2, 2914 CandidateSet); 2915 2916 OverloadCandidateSet::iterator Best; 2917 switch (CandidateSet.BestViableFunction(Self, QuestionLoc, Best)) { 2918 case OR_Success: 2919 // We found a match. Perform the conversions on the arguments and move on. 2920 if (Self.PerformImplicitConversion(LHS, Best->BuiltinTypes.ParamTypes[0], 2921 Best->Conversions[0], Sema::AA_Converting) || 2922 Self.PerformImplicitConversion(RHS, Best->BuiltinTypes.ParamTypes[1], 2923 Best->Conversions[1], Sema::AA_Converting)) 2924 break; 2925 return false; 2926 2927 case OR_No_Viable_Function: 2928 2929 // Emit a better diagnostic if one of the expressions is a null pointer 2930 // constant and the other is a pointer type. In this case, the user most 2931 // likely forgot to take the address of the other expression. 2932 if (Self.DiagnoseConditionalForNull(LHS, RHS, QuestionLoc)) 2933 return true; 2934 2935 Self.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 2936 << LHS->getType() << RHS->getType() 2937 << LHS->getSourceRange() << RHS->getSourceRange(); 2938 return true; 2939 2940 case OR_Ambiguous: 2941 Self.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl) 2942 << LHS->getType() << RHS->getType() 2943 << LHS->getSourceRange() << RHS->getSourceRange(); 2944 // FIXME: Print the possible common types by printing the return types of 2945 // the viable candidates. 2946 break; 2947 2948 case OR_Deleted: 2949 assert(false && "Conditional operator has only built-in overloads"); 2950 break; 2951 } 2952 return true; 2953} 2954 2955/// \brief Perform an "extended" implicit conversion as returned by 2956/// TryClassUnification. 2957static bool ConvertForConditional(Sema &Self, Expr *&E, QualType T) { 2958 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 2959 InitializationKind Kind = InitializationKind::CreateCopy(E->getLocStart(), 2960 SourceLocation()); 2961 InitializationSequence InitSeq(Self, Entity, Kind, &E, 1); 2962 ExprResult Result = InitSeq.Perform(Self, Entity, Kind, MultiExprArg(&E, 1)); 2963 if (Result.isInvalid()) 2964 return true; 2965 2966 E = Result.takeAs<Expr>(); 2967 return false; 2968} 2969 2970/// \brief Check the operands of ?: under C++ semantics. 2971/// 2972/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y 2973/// extension. In this case, LHS == Cond. (But they're not aliases.) 2974QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, 2975 ExprValueKind &VK, ExprObjectKind &OK, 2976 SourceLocation QuestionLoc) { 2977 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++ 2978 // interface pointers. 2979 2980 // C++0x 5.16p1 2981 // The first expression is contextually converted to bool. 2982 if (!Cond->isTypeDependent()) { 2983 if (CheckCXXBooleanCondition(Cond)) 2984 return QualType(); 2985 } 2986 2987 // Assume r-value. 2988 VK = VK_RValue; 2989 OK = OK_Ordinary; 2990 2991 // Either of the arguments dependent? 2992 if (LHS->isTypeDependent() || RHS->isTypeDependent()) 2993 return Context.DependentTy; 2994 2995 // C++0x 5.16p2 2996 // If either the second or the third operand has type (cv) void, ... 2997 QualType LTy = LHS->getType(); 2998 QualType RTy = RHS->getType(); 2999 bool LVoid = LTy->isVoidType(); 3000 bool RVoid = RTy->isVoidType(); 3001 if (LVoid || RVoid) { 3002 // ... then the [l2r] conversions are performed on the second and third 3003 // operands ... 3004 DefaultFunctionArrayLvalueConversion(LHS); 3005 DefaultFunctionArrayLvalueConversion(RHS); 3006 LTy = LHS->getType(); 3007 RTy = RHS->getType(); 3008 3009 // ... and one of the following shall hold: 3010 // -- The second or the third operand (but not both) is a throw- 3011 // expression; the result is of the type of the other and is an rvalue. 3012 bool LThrow = isa<CXXThrowExpr>(LHS); 3013 bool RThrow = isa<CXXThrowExpr>(RHS); 3014 if (LThrow && !RThrow) 3015 return RTy; 3016 if (RThrow && !LThrow) 3017 return LTy; 3018 3019 // -- Both the second and third operands have type void; the result is of 3020 // type void and is an rvalue. 3021 if (LVoid && RVoid) 3022 return Context.VoidTy; 3023 3024 // Neither holds, error. 3025 Diag(QuestionLoc, diag::err_conditional_void_nonvoid) 3026 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1) 3027 << LHS->getSourceRange() << RHS->getSourceRange(); 3028 return QualType(); 3029 } 3030 3031 // Neither is void. 3032 3033 // C++0x 5.16p3 3034 // Otherwise, if the second and third operand have different types, and 3035 // either has (cv) class type, and attempt is made to convert each of those 3036 // operands to the other. 3037 if (!Context.hasSameType(LTy, RTy) && 3038 (LTy->isRecordType() || RTy->isRecordType())) { 3039 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft; 3040 // These return true if a single direction is already ambiguous. 3041 QualType L2RType, R2LType; 3042 bool HaveL2R, HaveR2L; 3043 if (TryClassUnification(*this, LHS, RHS, QuestionLoc, HaveL2R, L2RType)) 3044 return QualType(); 3045 if (TryClassUnification(*this, RHS, LHS, QuestionLoc, HaveR2L, R2LType)) 3046 return QualType(); 3047 3048 // If both can be converted, [...] the program is ill-formed. 3049 if (HaveL2R && HaveR2L) { 3050 Diag(QuestionLoc, diag::err_conditional_ambiguous) 3051 << LTy << RTy << LHS->getSourceRange() << RHS->getSourceRange(); 3052 return QualType(); 3053 } 3054 3055 // If exactly one conversion is possible, that conversion is applied to 3056 // the chosen operand and the converted operands are used in place of the 3057 // original operands for the remainder of this section. 3058 if (HaveL2R) { 3059 if (ConvertForConditional(*this, LHS, L2RType)) 3060 return QualType(); 3061 LTy = LHS->getType(); 3062 } else if (HaveR2L) { 3063 if (ConvertForConditional(*this, RHS, R2LType)) 3064 return QualType(); 3065 RTy = RHS->getType(); 3066 } 3067 } 3068 3069 // C++0x 5.16p4 3070 // If the second and third operands are glvalues of the same value 3071 // category and have the same type, the result is of that type and 3072 // value category and it is a bit-field if the second or the third 3073 // operand is a bit-field, or if both are bit-fields. 3074 // We only extend this to bitfields, not to the crazy other kinds of 3075 // l-values. 3076 bool Same = Context.hasSameType(LTy, RTy); 3077 if (Same && 3078 LHS->isGLValue() && 3079 LHS->getValueKind() == RHS->getValueKind() && 3080 LHS->isOrdinaryOrBitFieldObject() && 3081 RHS->isOrdinaryOrBitFieldObject()) { 3082 VK = LHS->getValueKind(); 3083 if (LHS->getObjectKind() == OK_BitField || 3084 RHS->getObjectKind() == OK_BitField) 3085 OK = OK_BitField; 3086 return LTy; 3087 } 3088 3089 // C++0x 5.16p5 3090 // Otherwise, the result is an rvalue. If the second and third operands 3091 // do not have the same type, and either has (cv) class type, ... 3092 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) { 3093 // ... overload resolution is used to determine the conversions (if any) 3094 // to be applied to the operands. If the overload resolution fails, the 3095 // program is ill-formed. 3096 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc)) 3097 return QualType(); 3098 } 3099 3100 // C++0x 5.16p6 3101 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard 3102 // conversions are performed on the second and third operands. 3103 DefaultFunctionArrayLvalueConversion(LHS); 3104 DefaultFunctionArrayLvalueConversion(RHS); 3105 LTy = LHS->getType(); 3106 RTy = RHS->getType(); 3107 3108 // After those conversions, one of the following shall hold: 3109 // -- The second and third operands have the same type; the result 3110 // is of that type. If the operands have class type, the result 3111 // is a prvalue temporary of the result type, which is 3112 // copy-initialized from either the second operand or the third 3113 // operand depending on the value of the first operand. 3114 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) { 3115 if (LTy->isRecordType()) { 3116 // The operands have class type. Make a temporary copy. 3117 InitializedEntity Entity = InitializedEntity::InitializeTemporary(LTy); 3118 ExprResult LHSCopy = PerformCopyInitialization(Entity, 3119 SourceLocation(), 3120 Owned(LHS)); 3121 if (LHSCopy.isInvalid()) 3122 return QualType(); 3123 3124 ExprResult RHSCopy = PerformCopyInitialization(Entity, 3125 SourceLocation(), 3126 Owned(RHS)); 3127 if (RHSCopy.isInvalid()) 3128 return QualType(); 3129 3130 LHS = LHSCopy.takeAs<Expr>(); 3131 RHS = RHSCopy.takeAs<Expr>(); 3132 } 3133 3134 return LTy; 3135 } 3136 3137 // Extension: conditional operator involving vector types. 3138 if (LTy->isVectorType() || RTy->isVectorType()) 3139 return CheckVectorOperands(QuestionLoc, LHS, RHS); 3140 3141 // -- The second and third operands have arithmetic or enumeration type; 3142 // the usual arithmetic conversions are performed to bring them to a 3143 // common type, and the result is of that type. 3144 if (LTy->isArithmeticType() && RTy->isArithmeticType()) { 3145 UsualArithmeticConversions(LHS, RHS); 3146 return LHS->getType(); 3147 } 3148 3149 // -- The second and third operands have pointer type, or one has pointer 3150 // type and the other is a null pointer constant; pointer conversions 3151 // and qualification conversions are performed to bring them to their 3152 // composite pointer type. The result is of the composite pointer type. 3153 // -- The second and third operands have pointer to member type, or one has 3154 // pointer to member type and the other is a null pointer constant; 3155 // pointer to member conversions and qualification conversions are 3156 // performed to bring them to a common type, whose cv-qualification 3157 // shall match the cv-qualification of either the second or the third 3158 // operand. The result is of the common type. 3159 bool NonStandardCompositeType = false; 3160 QualType Composite = FindCompositePointerType(QuestionLoc, LHS, RHS, 3161 isSFINAEContext()? 0 : &NonStandardCompositeType); 3162 if (!Composite.isNull()) { 3163 if (NonStandardCompositeType) 3164 Diag(QuestionLoc, 3165 diag::ext_typecheck_cond_incompatible_operands_nonstandard) 3166 << LTy << RTy << Composite 3167 << LHS->getSourceRange() << RHS->getSourceRange(); 3168 3169 return Composite; 3170 } 3171 3172 // Similarly, attempt to find composite type of two objective-c pointers. 3173 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc); 3174 if (!Composite.isNull()) 3175 return Composite; 3176 3177 // Check if we are using a null with a non-pointer type. 3178 if (DiagnoseConditionalForNull(LHS, RHS, QuestionLoc)) 3179 return QualType(); 3180 3181 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 3182 << LHS->getType() << RHS->getType() 3183 << LHS->getSourceRange() << RHS->getSourceRange(); 3184 return QualType(); 3185} 3186 3187/// \brief Find a merged pointer type and convert the two expressions to it. 3188/// 3189/// This finds the composite pointer type (or member pointer type) for @p E1 3190/// and @p E2 according to C++0x 5.9p2. It converts both expressions to this 3191/// type and returns it. 3192/// It does not emit diagnostics. 3193/// 3194/// \param Loc The location of the operator requiring these two expressions to 3195/// be converted to the composite pointer type. 3196/// 3197/// If \p NonStandardCompositeType is non-NULL, then we are permitted to find 3198/// a non-standard (but still sane) composite type to which both expressions 3199/// can be converted. When such a type is chosen, \c *NonStandardCompositeType 3200/// will be set true. 3201QualType Sema::FindCompositePointerType(SourceLocation Loc, 3202 Expr *&E1, Expr *&E2, 3203 bool *NonStandardCompositeType) { 3204 if (NonStandardCompositeType) 3205 *NonStandardCompositeType = false; 3206 3207 assert(getLangOptions().CPlusPlus && "This function assumes C++"); 3208 QualType T1 = E1->getType(), T2 = E2->getType(); 3209 3210 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() && 3211 !T2->isAnyPointerType() && !T2->isMemberPointerType()) 3212 return QualType(); 3213 3214 // C++0x 5.9p2 3215 // Pointer conversions and qualification conversions are performed on 3216 // pointer operands to bring them to their composite pointer type. If 3217 // one operand is a null pointer constant, the composite pointer type is 3218 // the type of the other operand. 3219 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 3220 if (T2->isMemberPointerType()) 3221 ImpCastExprToType(E1, T2, CK_NullToMemberPointer); 3222 else 3223 ImpCastExprToType(E1, T2, CK_NullToPointer); 3224 return T2; 3225 } 3226 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 3227 if (T1->isMemberPointerType()) 3228 ImpCastExprToType(E2, T1, CK_NullToMemberPointer); 3229 else 3230 ImpCastExprToType(E2, T1, CK_NullToPointer); 3231 return T1; 3232 } 3233 3234 // Now both have to be pointers or member pointers. 3235 if ((!T1->isPointerType() && !T1->isMemberPointerType()) || 3236 (!T2->isPointerType() && !T2->isMemberPointerType())) 3237 return QualType(); 3238 3239 // Otherwise, of one of the operands has type "pointer to cv1 void," then 3240 // the other has type "pointer to cv2 T" and the composite pointer type is 3241 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2. 3242 // Otherwise, the composite pointer type is a pointer type similar to the 3243 // type of one of the operands, with a cv-qualification signature that is 3244 // the union of the cv-qualification signatures of the operand types. 3245 // In practice, the first part here is redundant; it's subsumed by the second. 3246 // What we do here is, we build the two possible composite types, and try the 3247 // conversions in both directions. If only one works, or if the two composite 3248 // types are the same, we have succeeded. 3249 // FIXME: extended qualifiers? 3250 typedef llvm::SmallVector<unsigned, 4> QualifierVector; 3251 QualifierVector QualifierUnion; 3252 typedef llvm::SmallVector<std::pair<const Type *, const Type *>, 4> 3253 ContainingClassVector; 3254 ContainingClassVector MemberOfClass; 3255 QualType Composite1 = Context.getCanonicalType(T1), 3256 Composite2 = Context.getCanonicalType(T2); 3257 unsigned NeedConstBefore = 0; 3258 do { 3259 const PointerType *Ptr1, *Ptr2; 3260 if ((Ptr1 = Composite1->getAs<PointerType>()) && 3261 (Ptr2 = Composite2->getAs<PointerType>())) { 3262 Composite1 = Ptr1->getPointeeType(); 3263 Composite2 = Ptr2->getPointeeType(); 3264 3265 // If we're allowed to create a non-standard composite type, keep track 3266 // of where we need to fill in additional 'const' qualifiers. 3267 if (NonStandardCompositeType && 3268 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 3269 NeedConstBefore = QualifierUnion.size(); 3270 3271 QualifierUnion.push_back( 3272 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 3273 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0)); 3274 continue; 3275 } 3276 3277 const MemberPointerType *MemPtr1, *MemPtr2; 3278 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) && 3279 (MemPtr2 = Composite2->getAs<MemberPointerType>())) { 3280 Composite1 = MemPtr1->getPointeeType(); 3281 Composite2 = MemPtr2->getPointeeType(); 3282 3283 // If we're allowed to create a non-standard composite type, keep track 3284 // of where we need to fill in additional 'const' qualifiers. 3285 if (NonStandardCompositeType && 3286 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 3287 NeedConstBefore = QualifierUnion.size(); 3288 3289 QualifierUnion.push_back( 3290 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 3291 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(), 3292 MemPtr2->getClass())); 3293 continue; 3294 } 3295 3296 // FIXME: block pointer types? 3297 3298 // Cannot unwrap any more types. 3299 break; 3300 } while (true); 3301 3302 if (NeedConstBefore && NonStandardCompositeType) { 3303 // Extension: Add 'const' to qualifiers that come before the first qualifier 3304 // mismatch, so that our (non-standard!) composite type meets the 3305 // requirements of C++ [conv.qual]p4 bullet 3. 3306 for (unsigned I = 0; I != NeedConstBefore; ++I) { 3307 if ((QualifierUnion[I] & Qualifiers::Const) == 0) { 3308 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const; 3309 *NonStandardCompositeType = true; 3310 } 3311 } 3312 } 3313 3314 // Rewrap the composites as pointers or member pointers with the union CVRs. 3315 ContainingClassVector::reverse_iterator MOC 3316 = MemberOfClass.rbegin(); 3317 for (QualifierVector::reverse_iterator 3318 I = QualifierUnion.rbegin(), 3319 E = QualifierUnion.rend(); 3320 I != E; (void)++I, ++MOC) { 3321 Qualifiers Quals = Qualifiers::fromCVRMask(*I); 3322 if (MOC->first && MOC->second) { 3323 // Rebuild member pointer type 3324 Composite1 = Context.getMemberPointerType( 3325 Context.getQualifiedType(Composite1, Quals), 3326 MOC->first); 3327 Composite2 = Context.getMemberPointerType( 3328 Context.getQualifiedType(Composite2, Quals), 3329 MOC->second); 3330 } else { 3331 // Rebuild pointer type 3332 Composite1 3333 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals)); 3334 Composite2 3335 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals)); 3336 } 3337 } 3338 3339 // Try to convert to the first composite pointer type. 3340 InitializedEntity Entity1 3341 = InitializedEntity::InitializeTemporary(Composite1); 3342 InitializationKind Kind 3343 = InitializationKind::CreateCopy(Loc, SourceLocation()); 3344 InitializationSequence E1ToC1(*this, Entity1, Kind, &E1, 1); 3345 InitializationSequence E2ToC1(*this, Entity1, Kind, &E2, 1); 3346 3347 if (E1ToC1 && E2ToC1) { 3348 // Conversion to Composite1 is viable. 3349 if (!Context.hasSameType(Composite1, Composite2)) { 3350 // Composite2 is a different type from Composite1. Check whether 3351 // Composite2 is also viable. 3352 InitializedEntity Entity2 3353 = InitializedEntity::InitializeTemporary(Composite2); 3354 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1); 3355 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1); 3356 if (E1ToC2 && E2ToC2) { 3357 // Both Composite1 and Composite2 are viable and are different; 3358 // this is an ambiguity. 3359 return QualType(); 3360 } 3361 } 3362 3363 // Convert E1 to Composite1 3364 ExprResult E1Result 3365 = E1ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,&E1,1)); 3366 if (E1Result.isInvalid()) 3367 return QualType(); 3368 E1 = E1Result.takeAs<Expr>(); 3369 3370 // Convert E2 to Composite1 3371 ExprResult E2Result 3372 = E2ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,&E2,1)); 3373 if (E2Result.isInvalid()) 3374 return QualType(); 3375 E2 = E2Result.takeAs<Expr>(); 3376 3377 return Composite1; 3378 } 3379 3380 // Check whether Composite2 is viable. 3381 InitializedEntity Entity2 3382 = InitializedEntity::InitializeTemporary(Composite2); 3383 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1); 3384 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1); 3385 if (!E1ToC2 || !E2ToC2) 3386 return QualType(); 3387 3388 // Convert E1 to Composite2 3389 ExprResult E1Result 3390 = E1ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, &E1, 1)); 3391 if (E1Result.isInvalid()) 3392 return QualType(); 3393 E1 = E1Result.takeAs<Expr>(); 3394 3395 // Convert E2 to Composite2 3396 ExprResult E2Result 3397 = E2ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, &E2, 1)); 3398 if (E2Result.isInvalid()) 3399 return QualType(); 3400 E2 = E2Result.takeAs<Expr>(); 3401 3402 return Composite2; 3403} 3404 3405ExprResult Sema::MaybeBindToTemporary(Expr *E) { 3406 if (!E) 3407 return ExprError(); 3408 3409 if (!Context.getLangOptions().CPlusPlus) 3410 return Owned(E); 3411 3412 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?"); 3413 3414 const RecordType *RT = E->getType()->getAs<RecordType>(); 3415 if (!RT) 3416 return Owned(E); 3417 3418 // If the result is a glvalue, we shouldn't bind it. 3419 if (E->Classify(Context).isGLValue()) 3420 return Owned(E); 3421 3422 // That should be enough to guarantee that this type is complete. 3423 // If it has a trivial destructor, we can avoid the extra copy. 3424 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 3425 if (RD->isInvalidDecl() || RD->hasTrivialDestructor()) 3426 return Owned(E); 3427 3428 CXXTemporary *Temp = CXXTemporary::Create(Context, LookupDestructor(RD)); 3429 ExprTemporaries.push_back(Temp); 3430 if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) { 3431 MarkDeclarationReferenced(E->getExprLoc(), Destructor); 3432 CheckDestructorAccess(E->getExprLoc(), Destructor, 3433 PDiag(diag::err_access_dtor_temp) 3434 << E->getType()); 3435 } 3436 // FIXME: Add the temporary to the temporaries vector. 3437 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E)); 3438} 3439 3440Expr *Sema::MaybeCreateExprWithCleanups(Expr *SubExpr) { 3441 assert(SubExpr && "sub expression can't be null!"); 3442 3443 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 3444 assert(ExprTemporaries.size() >= FirstTemporary); 3445 if (ExprTemporaries.size() == FirstTemporary) 3446 return SubExpr; 3447 3448 Expr *E = ExprWithCleanups::Create(Context, SubExpr, 3449 &ExprTemporaries[FirstTemporary], 3450 ExprTemporaries.size() - FirstTemporary); 3451 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 3452 ExprTemporaries.end()); 3453 3454 return E; 3455} 3456 3457ExprResult 3458Sema::MaybeCreateExprWithCleanups(ExprResult SubExpr) { 3459 if (SubExpr.isInvalid()) 3460 return ExprError(); 3461 3462 return Owned(MaybeCreateExprWithCleanups(SubExpr.take())); 3463} 3464 3465Stmt *Sema::MaybeCreateStmtWithCleanups(Stmt *SubStmt) { 3466 assert(SubStmt && "sub statement can't be null!"); 3467 3468 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 3469 assert(ExprTemporaries.size() >= FirstTemporary); 3470 if (ExprTemporaries.size() == FirstTemporary) 3471 return SubStmt; 3472 3473 // FIXME: In order to attach the temporaries, wrap the statement into 3474 // a StmtExpr; currently this is only used for asm statements. 3475 // This is hacky, either create a new CXXStmtWithTemporaries statement or 3476 // a new AsmStmtWithTemporaries. 3477 CompoundStmt *CompStmt = new (Context) CompoundStmt(Context, &SubStmt, 1, 3478 SourceLocation(), 3479 SourceLocation()); 3480 Expr *E = new (Context) StmtExpr(CompStmt, Context.VoidTy, SourceLocation(), 3481 SourceLocation()); 3482 return MaybeCreateExprWithCleanups(E); 3483} 3484 3485ExprResult 3486Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, 3487 tok::TokenKind OpKind, ParsedType &ObjectType, 3488 bool &MayBePseudoDestructor) { 3489 // Since this might be a postfix expression, get rid of ParenListExprs. 3490 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base); 3491 if (Result.isInvalid()) return ExprError(); 3492 Base = Result.get(); 3493 3494 QualType BaseType = Base->getType(); 3495 MayBePseudoDestructor = false; 3496 if (BaseType->isDependentType()) { 3497 // If we have a pointer to a dependent type and are using the -> operator, 3498 // the object type is the type that the pointer points to. We might still 3499 // have enough information about that type to do something useful. 3500 if (OpKind == tok::arrow) 3501 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 3502 BaseType = Ptr->getPointeeType(); 3503 3504 ObjectType = ParsedType::make(BaseType); 3505 MayBePseudoDestructor = true; 3506 return Owned(Base); 3507 } 3508 3509 // C++ [over.match.oper]p8: 3510 // [...] When operator->returns, the operator-> is applied to the value 3511 // returned, with the original second operand. 3512 if (OpKind == tok::arrow) { 3513 // The set of types we've considered so far. 3514 llvm::SmallPtrSet<CanQualType,8> CTypes; 3515 llvm::SmallVector<SourceLocation, 8> Locations; 3516 CTypes.insert(Context.getCanonicalType(BaseType)); 3517 3518 while (BaseType->isRecordType()) { 3519 Result = BuildOverloadedArrowExpr(S, Base, OpLoc); 3520 if (Result.isInvalid()) 3521 return ExprError(); 3522 Base = Result.get(); 3523 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(Base)) 3524 Locations.push_back(OpCall->getDirectCallee()->getLocation()); 3525 BaseType = Base->getType(); 3526 CanQualType CBaseType = Context.getCanonicalType(BaseType); 3527 if (!CTypes.insert(CBaseType)) { 3528 Diag(OpLoc, diag::err_operator_arrow_circular); 3529 for (unsigned i = 0; i < Locations.size(); i++) 3530 Diag(Locations[i], diag::note_declared_at); 3531 return ExprError(); 3532 } 3533 } 3534 3535 if (BaseType->isPointerType()) 3536 BaseType = BaseType->getPointeeType(); 3537 } 3538 3539 // We could end up with various non-record types here, such as extended 3540 // vector types or Objective-C interfaces. Just return early and let 3541 // ActOnMemberReferenceExpr do the work. 3542 if (!BaseType->isRecordType()) { 3543 // C++ [basic.lookup.classref]p2: 3544 // [...] If the type of the object expression is of pointer to scalar 3545 // type, the unqualified-id is looked up in the context of the complete 3546 // postfix-expression. 3547 // 3548 // This also indicates that we should be parsing a 3549 // pseudo-destructor-name. 3550 ObjectType = ParsedType(); 3551 MayBePseudoDestructor = true; 3552 return Owned(Base); 3553 } 3554 3555 // The object type must be complete (or dependent). 3556 if (!BaseType->isDependentType() && 3557 RequireCompleteType(OpLoc, BaseType, 3558 PDiag(diag::err_incomplete_member_access))) 3559 return ExprError(); 3560 3561 // C++ [basic.lookup.classref]p2: 3562 // If the id-expression in a class member access (5.2.5) is an 3563 // unqualified-id, and the type of the object expression is of a class 3564 // type C (or of pointer to a class type C), the unqualified-id is looked 3565 // up in the scope of class C. [...] 3566 ObjectType = ParsedType::make(BaseType); 3567 return move(Base); 3568} 3569 3570ExprResult Sema::DiagnoseDtorReference(SourceLocation NameLoc, 3571 Expr *MemExpr) { 3572 SourceLocation ExpectedLParenLoc = PP.getLocForEndOfToken(NameLoc); 3573 Diag(MemExpr->getLocStart(), diag::err_dtor_expr_without_call) 3574 << isa<CXXPseudoDestructorExpr>(MemExpr) 3575 << FixItHint::CreateInsertion(ExpectedLParenLoc, "()"); 3576 3577 return ActOnCallExpr(/*Scope*/ 0, 3578 MemExpr, 3579 /*LPLoc*/ ExpectedLParenLoc, 3580 MultiExprArg(), 3581 /*RPLoc*/ ExpectedLParenLoc); 3582} 3583 3584ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base, 3585 SourceLocation OpLoc, 3586 tok::TokenKind OpKind, 3587 const CXXScopeSpec &SS, 3588 TypeSourceInfo *ScopeTypeInfo, 3589 SourceLocation CCLoc, 3590 SourceLocation TildeLoc, 3591 PseudoDestructorTypeStorage Destructed, 3592 bool HasTrailingLParen) { 3593 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo(); 3594 3595 // C++ [expr.pseudo]p2: 3596 // The left-hand side of the dot operator shall be of scalar type. The 3597 // left-hand side of the arrow operator shall be of pointer to scalar type. 3598 // This scalar type is the object type. 3599 QualType ObjectType = Base->getType(); 3600 if (OpKind == tok::arrow) { 3601 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 3602 ObjectType = Ptr->getPointeeType(); 3603 } else if (!Base->isTypeDependent()) { 3604 // The user wrote "p->" when she probably meant "p."; fix it. 3605 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 3606 << ObjectType << true 3607 << FixItHint::CreateReplacement(OpLoc, "."); 3608 if (isSFINAEContext()) 3609 return ExprError(); 3610 3611 OpKind = tok::period; 3612 } 3613 } 3614 3615 if (!ObjectType->isDependentType() && !ObjectType->isScalarType()) { 3616 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar) 3617 << ObjectType << Base->getSourceRange(); 3618 return ExprError(); 3619 } 3620 3621 // C++ [expr.pseudo]p2: 3622 // [...] The cv-unqualified versions of the object type and of the type 3623 // designated by the pseudo-destructor-name shall be the same type. 3624 if (DestructedTypeInfo) { 3625 QualType DestructedType = DestructedTypeInfo->getType(); 3626 SourceLocation DestructedTypeStart 3627 = DestructedTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(); 3628 if (!DestructedType->isDependentType() && !ObjectType->isDependentType() && 3629 !Context.hasSameUnqualifiedType(DestructedType, ObjectType)) { 3630 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch) 3631 << ObjectType << DestructedType << Base->getSourceRange() 3632 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange(); 3633 3634 // Recover by setting the destructed type to the object type. 3635 DestructedType = ObjectType; 3636 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType, 3637 DestructedTypeStart); 3638 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 3639 } 3640 } 3641 3642 // C++ [expr.pseudo]p2: 3643 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the 3644 // form 3645 // 3646 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name 3647 // 3648 // shall designate the same scalar type. 3649 if (ScopeTypeInfo) { 3650 QualType ScopeType = ScopeTypeInfo->getType(); 3651 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() && 3652 !Context.hasSameUnqualifiedType(ScopeType, ObjectType)) { 3653 3654 Diag(ScopeTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(), 3655 diag::err_pseudo_dtor_type_mismatch) 3656 << ObjectType << ScopeType << Base->getSourceRange() 3657 << ScopeTypeInfo->getTypeLoc().getLocalSourceRange(); 3658 3659 ScopeType = QualType(); 3660 ScopeTypeInfo = 0; 3661 } 3662 } 3663 3664 Expr *Result 3665 = new (Context) CXXPseudoDestructorExpr(Context, Base, 3666 OpKind == tok::arrow, OpLoc, 3667 SS.getScopeRep(), SS.getRange(), 3668 ScopeTypeInfo, 3669 CCLoc, 3670 TildeLoc, 3671 Destructed); 3672 3673 if (HasTrailingLParen) 3674 return Owned(Result); 3675 3676 return DiagnoseDtorReference(Destructed.getLocation(), Result); 3677} 3678 3679ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base, 3680 SourceLocation OpLoc, 3681 tok::TokenKind OpKind, 3682 CXXScopeSpec &SS, 3683 UnqualifiedId &FirstTypeName, 3684 SourceLocation CCLoc, 3685 SourceLocation TildeLoc, 3686 UnqualifiedId &SecondTypeName, 3687 bool HasTrailingLParen) { 3688 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 3689 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) && 3690 "Invalid first type name in pseudo-destructor"); 3691 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId || 3692 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) && 3693 "Invalid second type name in pseudo-destructor"); 3694 3695 // C++ [expr.pseudo]p2: 3696 // The left-hand side of the dot operator shall be of scalar type. The 3697 // left-hand side of the arrow operator shall be of pointer to scalar type. 3698 // This scalar type is the object type. 3699 QualType ObjectType = Base->getType(); 3700 if (OpKind == tok::arrow) { 3701 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 3702 ObjectType = Ptr->getPointeeType(); 3703 } else if (!ObjectType->isDependentType()) { 3704 // The user wrote "p->" when she probably meant "p."; fix it. 3705 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 3706 << ObjectType << true 3707 << FixItHint::CreateReplacement(OpLoc, "."); 3708 if (isSFINAEContext()) 3709 return ExprError(); 3710 3711 OpKind = tok::period; 3712 } 3713 } 3714 3715 // Compute the object type that we should use for name lookup purposes. Only 3716 // record types and dependent types matter. 3717 ParsedType ObjectTypePtrForLookup; 3718 if (!SS.isSet()) { 3719 if (ObjectType->isRecordType()) 3720 ObjectTypePtrForLookup = ParsedType::make(ObjectType); 3721 else if (ObjectType->isDependentType()) 3722 ObjectTypePtrForLookup = ParsedType::make(Context.DependentTy); 3723 } 3724 3725 // Convert the name of the type being destructed (following the ~) into a 3726 // type (with source-location information). 3727 QualType DestructedType; 3728 TypeSourceInfo *DestructedTypeInfo = 0; 3729 PseudoDestructorTypeStorage Destructed; 3730 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) { 3731 ParsedType T = getTypeName(*SecondTypeName.Identifier, 3732 SecondTypeName.StartLocation, 3733 S, &SS, true, false, ObjectTypePtrForLookup); 3734 if (!T && 3735 ((SS.isSet() && !computeDeclContext(SS, false)) || 3736 (!SS.isSet() && ObjectType->isDependentType()))) { 3737 // The name of the type being destroyed is a dependent name, and we 3738 // couldn't find anything useful in scope. Just store the identifier and 3739 // it's location, and we'll perform (qualified) name lookup again at 3740 // template instantiation time. 3741 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier, 3742 SecondTypeName.StartLocation); 3743 } else if (!T) { 3744 Diag(SecondTypeName.StartLocation, 3745 diag::err_pseudo_dtor_destructor_non_type) 3746 << SecondTypeName.Identifier << ObjectType; 3747 if (isSFINAEContext()) 3748 return ExprError(); 3749 3750 // Recover by assuming we had the right type all along. 3751 DestructedType = ObjectType; 3752 } else 3753 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo); 3754 } else { 3755 // Resolve the template-id to a type. 3756 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId; 3757 ASTTemplateArgsPtr TemplateArgsPtr(*this, 3758 TemplateId->getTemplateArgs(), 3759 TemplateId->NumArgs); 3760 TypeResult T = ActOnTemplateIdType(TemplateId->Template, 3761 TemplateId->TemplateNameLoc, 3762 TemplateId->LAngleLoc, 3763 TemplateArgsPtr, 3764 TemplateId->RAngleLoc); 3765 if (T.isInvalid() || !T.get()) { 3766 // Recover by assuming we had the right type all along. 3767 DestructedType = ObjectType; 3768 } else 3769 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo); 3770 } 3771 3772 // If we've performed some kind of recovery, (re-)build the type source 3773 // information. 3774 if (!DestructedType.isNull()) { 3775 if (!DestructedTypeInfo) 3776 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType, 3777 SecondTypeName.StartLocation); 3778 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 3779 } 3780 3781 // Convert the name of the scope type (the type prior to '::') into a type. 3782 TypeSourceInfo *ScopeTypeInfo = 0; 3783 QualType ScopeType; 3784 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 3785 FirstTypeName.Identifier) { 3786 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) { 3787 ParsedType T = getTypeName(*FirstTypeName.Identifier, 3788 FirstTypeName.StartLocation, 3789 S, &SS, false, false, ObjectTypePtrForLookup); 3790 if (!T) { 3791 Diag(FirstTypeName.StartLocation, 3792 diag::err_pseudo_dtor_destructor_non_type) 3793 << FirstTypeName.Identifier << ObjectType; 3794 3795 if (isSFINAEContext()) 3796 return ExprError(); 3797 3798 // Just drop this type. It's unnecessary anyway. 3799 ScopeType = QualType(); 3800 } else 3801 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo); 3802 } else { 3803 // Resolve the template-id to a type. 3804 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId; 3805 ASTTemplateArgsPtr TemplateArgsPtr(*this, 3806 TemplateId->getTemplateArgs(), 3807 TemplateId->NumArgs); 3808 TypeResult T = ActOnTemplateIdType(TemplateId->Template, 3809 TemplateId->TemplateNameLoc, 3810 TemplateId->LAngleLoc, 3811 TemplateArgsPtr, 3812 TemplateId->RAngleLoc); 3813 if (T.isInvalid() || !T.get()) { 3814 // Recover by dropping this type. 3815 ScopeType = QualType(); 3816 } else 3817 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo); 3818 } 3819 } 3820 3821 if (!ScopeType.isNull() && !ScopeTypeInfo) 3822 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType, 3823 FirstTypeName.StartLocation); 3824 3825 3826 return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, SS, 3827 ScopeTypeInfo, CCLoc, TildeLoc, 3828 Destructed, HasTrailingLParen); 3829} 3830 3831ExprResult Sema::BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, 3832 CXXMethodDecl *Method) { 3833 if (PerformObjectArgumentInitialization(Exp, /*Qualifier=*/0, 3834 FoundDecl, Method)) 3835 return true; 3836 3837 MemberExpr *ME = 3838 new (Context) MemberExpr(Exp, /*IsArrow=*/false, Method, 3839 SourceLocation(), Method->getType(), 3840 VK_RValue, OK_Ordinary); 3841 QualType ResultType = Method->getResultType(); 3842 ExprValueKind VK = Expr::getValueKindForType(ResultType); 3843 ResultType = ResultType.getNonLValueExprType(Context); 3844 3845 MarkDeclarationReferenced(Exp->getLocStart(), Method); 3846 CXXMemberCallExpr *CE = 3847 new (Context) CXXMemberCallExpr(Context, ME, 0, 0, ResultType, VK, 3848 Exp->getLocEnd()); 3849 return CE; 3850} 3851 3852ExprResult Sema::BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand, 3853 SourceLocation RParen) { 3854 return Owned(new (Context) CXXNoexceptExpr(Context.BoolTy, Operand, 3855 Operand->CanThrow(Context), 3856 KeyLoc, RParen)); 3857} 3858 3859ExprResult Sema::ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation, 3860 Expr *Operand, SourceLocation RParen) { 3861 return BuildCXXNoexceptExpr(KeyLoc, Operand, RParen); 3862} 3863 3864/// Perform the conversions required for an expression used in a 3865/// context that ignores the result. 3866void Sema::IgnoredValueConversions(Expr *&E) { 3867 // C99 6.3.2.1: 3868 // [Except in specific positions,] an lvalue that does not have 3869 // array type is converted to the value stored in the 3870 // designated object (and is no longer an lvalue). 3871 if (E->isRValue()) return; 3872 3873 // We always want to do this on ObjC property references. 3874 if (E->getObjectKind() == OK_ObjCProperty) { 3875 ConvertPropertyForRValue(E); 3876 if (E->isRValue()) return; 3877 } 3878 3879 // Otherwise, this rule does not apply in C++, at least not for the moment. 3880 if (getLangOptions().CPlusPlus) return; 3881 3882 // GCC seems to also exclude expressions of incomplete enum type. 3883 if (const EnumType *T = E->getType()->getAs<EnumType>()) { 3884 if (!T->getDecl()->isComplete()) { 3885 // FIXME: stupid workaround for a codegen bug! 3886 ImpCastExprToType(E, Context.VoidTy, CK_ToVoid); 3887 return; 3888 } 3889 } 3890 3891 DefaultFunctionArrayLvalueConversion(E); 3892 if (!E->getType()->isVoidType()) 3893 RequireCompleteType(E->getExprLoc(), E->getType(), 3894 diag::err_incomplete_type); 3895} 3896 3897ExprResult Sema::ActOnFinishFullExpr(Expr *FullExpr) { 3898 if (!FullExpr) 3899 return ExprError(); 3900 3901 if (DiagnoseUnexpandedParameterPack(FullExpr)) 3902 return ExprError(); 3903 3904 IgnoredValueConversions(FullExpr); 3905 CheckImplicitConversions(FullExpr); 3906 return MaybeCreateExprWithCleanups(FullExpr); 3907} 3908 3909StmtResult Sema::ActOnFinishFullStmt(Stmt *FullStmt) { 3910 if (!FullStmt) return StmtError(); 3911 3912 return MaybeCreateStmtWithCleanups(FullStmt); 3913} 3914