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