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