SemaExprCXX.cpp revision cc7a6484d8afd6f8bede2757666c42248228e408
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 assert(FD && "FIXME: aggregate initialization from init list"); 2133 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) { 2134 CastKind = CK_UserDefinedConversion; 2135 2136 // If the user-defined conversion is specified by a conversion function, 2137 // the initial standard conversion sequence converts the source type to 2138 // the implicit object parameter of the conversion function. 2139 BeforeToType = Context.getTagDeclType(Conv->getParent()); 2140 } else { 2141 const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(FD); 2142 CastKind = CK_ConstructorConversion; 2143 // Do no conversion if dealing with ... for the first conversion. 2144 if (!ICS.UserDefined.EllipsisConversion) { 2145 // If the user-defined conversion is specified by a constructor, the 2146 // initial standard conversion sequence converts the source type to the 2147 // type required by the argument of the constructor 2148 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType(); 2149 } 2150 } 2151 // Watch out for elipsis conversion. 2152 if (!ICS.UserDefined.EllipsisConversion) { 2153 ExprResult Res = 2154 PerformImplicitConversion(From, BeforeToType, 2155 ICS.UserDefined.Before, AA_Converting, 2156 CCK); 2157 if (Res.isInvalid()) 2158 return ExprError(); 2159 From = Res.take(); 2160 } 2161 2162 ExprResult CastArg 2163 = BuildCXXCastArgument(*this, 2164 From->getLocStart(), 2165 ToType.getNonReferenceType(), 2166 CastKind, cast<CXXMethodDecl>(FD), 2167 ICS.UserDefined.FoundConversionFunction, 2168 ICS.UserDefined.HadMultipleCandidates, 2169 From); 2170 2171 if (CastArg.isInvalid()) 2172 return ExprError(); 2173 2174 From = CastArg.take(); 2175 2176 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After, 2177 AA_Converting, CCK); 2178 } 2179 2180 case ImplicitConversionSequence::AmbiguousConversion: 2181 ICS.DiagnoseAmbiguousConversion(*this, From->getExprLoc(), 2182 PDiag(diag::err_typecheck_ambiguous_condition) 2183 << From->getSourceRange()); 2184 return ExprError(); 2185 2186 case ImplicitConversionSequence::EllipsisConversion: 2187 llvm_unreachable("Cannot perform an ellipsis conversion"); 2188 2189 case ImplicitConversionSequence::BadConversion: 2190 return ExprError(); 2191 } 2192 2193 // Everything went well. 2194 return Owned(From); 2195} 2196 2197/// PerformImplicitConversion - Perform an implicit conversion of the 2198/// expression From to the type ToType by following the standard 2199/// conversion sequence SCS. Returns the converted 2200/// expression. Flavor is the context in which we're performing this 2201/// conversion, for use in error messages. 2202ExprResult 2203Sema::PerformImplicitConversion(Expr *From, QualType ToType, 2204 const StandardConversionSequence& SCS, 2205 AssignmentAction Action, 2206 CheckedConversionKind CCK) { 2207 bool CStyle = (CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast); 2208 2209 // Overall FIXME: we are recomputing too many types here and doing far too 2210 // much extra work. What this means is that we need to keep track of more 2211 // information that is computed when we try the implicit conversion initially, 2212 // so that we don't need to recompute anything here. 2213 QualType FromType = From->getType(); 2214 2215 if (SCS.CopyConstructor) { 2216 // FIXME: When can ToType be a reference type? 2217 assert(!ToType->isReferenceType()); 2218 if (SCS.Second == ICK_Derived_To_Base) { 2219 ASTOwningVector<Expr*> ConstructorArgs(*this); 2220 if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor), 2221 MultiExprArg(*this, &From, 1), 2222 /*FIXME:ConstructLoc*/SourceLocation(), 2223 ConstructorArgs)) 2224 return ExprError(); 2225 return BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 2226 ToType, SCS.CopyConstructor, 2227 move_arg(ConstructorArgs), 2228 /*HadMultipleCandidates*/ false, 2229 /*ZeroInit*/ false, 2230 CXXConstructExpr::CK_Complete, 2231 SourceRange()); 2232 } 2233 return BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 2234 ToType, SCS.CopyConstructor, 2235 MultiExprArg(*this, &From, 1), 2236 /*HadMultipleCandidates*/ false, 2237 /*ZeroInit*/ false, 2238 CXXConstructExpr::CK_Complete, 2239 SourceRange()); 2240 } 2241 2242 // Resolve overloaded function references. 2243 if (Context.hasSameType(FromType, Context.OverloadTy)) { 2244 DeclAccessPair Found; 2245 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, 2246 true, Found); 2247 if (!Fn) 2248 return ExprError(); 2249 2250 if (DiagnoseUseOfDecl(Fn, From->getSourceRange().getBegin())) 2251 return ExprError(); 2252 2253 From = FixOverloadedFunctionReference(From, Found, Fn); 2254 FromType = From->getType(); 2255 } 2256 2257 // Perform the first implicit conversion. 2258 switch (SCS.First) { 2259 case ICK_Identity: 2260 // Nothing to do. 2261 break; 2262 2263 case ICK_Lvalue_To_Rvalue: 2264 assert(From->getObjectKind() != OK_ObjCProperty); 2265 FromType = FromType.getUnqualifiedType(); 2266 From = ImplicitCastExpr::Create(Context, FromType, CK_LValueToRValue, 2267 From, 0, VK_RValue); 2268 break; 2269 2270 case ICK_Array_To_Pointer: 2271 FromType = Context.getArrayDecayedType(FromType); 2272 From = ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay, 2273 VK_RValue, /*BasePath=*/0, CCK).take(); 2274 break; 2275 2276 case ICK_Function_To_Pointer: 2277 FromType = Context.getPointerType(FromType); 2278 From = ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay, 2279 VK_RValue, /*BasePath=*/0, CCK).take(); 2280 break; 2281 2282 default: 2283 llvm_unreachable("Improper first standard conversion"); 2284 } 2285 2286 // Perform the second implicit conversion 2287 switch (SCS.Second) { 2288 case ICK_Identity: 2289 // If both sides are functions (or pointers/references to them), there could 2290 // be incompatible exception declarations. 2291 if (CheckExceptionSpecCompatibility(From, ToType)) 2292 return ExprError(); 2293 // Nothing else to do. 2294 break; 2295 2296 case ICK_NoReturn_Adjustment: 2297 // If both sides are functions (or pointers/references to them), there could 2298 // be incompatible exception declarations. 2299 if (CheckExceptionSpecCompatibility(From, ToType)) 2300 return ExprError(); 2301 2302 From = ImpCastExprToType(From, ToType, CK_NoOp, 2303 VK_RValue, /*BasePath=*/0, CCK).take(); 2304 break; 2305 2306 case ICK_Integral_Promotion: 2307 case ICK_Integral_Conversion: 2308 From = ImpCastExprToType(From, ToType, CK_IntegralCast, 2309 VK_RValue, /*BasePath=*/0, CCK).take(); 2310 break; 2311 2312 case ICK_Floating_Promotion: 2313 case ICK_Floating_Conversion: 2314 From = ImpCastExprToType(From, ToType, CK_FloatingCast, 2315 VK_RValue, /*BasePath=*/0, CCK).take(); 2316 break; 2317 2318 case ICK_Complex_Promotion: 2319 case ICK_Complex_Conversion: { 2320 QualType FromEl = From->getType()->getAs<ComplexType>()->getElementType(); 2321 QualType ToEl = ToType->getAs<ComplexType>()->getElementType(); 2322 CastKind CK; 2323 if (FromEl->isRealFloatingType()) { 2324 if (ToEl->isRealFloatingType()) 2325 CK = CK_FloatingComplexCast; 2326 else 2327 CK = CK_FloatingComplexToIntegralComplex; 2328 } else if (ToEl->isRealFloatingType()) { 2329 CK = CK_IntegralComplexToFloatingComplex; 2330 } else { 2331 CK = CK_IntegralComplexCast; 2332 } 2333 From = ImpCastExprToType(From, ToType, CK, 2334 VK_RValue, /*BasePath=*/0, CCK).take(); 2335 break; 2336 } 2337 2338 case ICK_Floating_Integral: 2339 if (ToType->isRealFloatingType()) 2340 From = ImpCastExprToType(From, ToType, CK_IntegralToFloating, 2341 VK_RValue, /*BasePath=*/0, CCK).take(); 2342 else 2343 From = ImpCastExprToType(From, ToType, CK_FloatingToIntegral, 2344 VK_RValue, /*BasePath=*/0, CCK).take(); 2345 break; 2346 2347 case ICK_Compatible_Conversion: 2348 From = ImpCastExprToType(From, ToType, CK_NoOp, 2349 VK_RValue, /*BasePath=*/0, CCK).take(); 2350 break; 2351 2352 case ICK_Writeback_Conversion: 2353 case ICK_Pointer_Conversion: { 2354 if (SCS.IncompatibleObjC && Action != AA_Casting) { 2355 // Diagnose incompatible Objective-C conversions 2356 if (Action == AA_Initializing || Action == AA_Assigning) 2357 Diag(From->getSourceRange().getBegin(), 2358 diag::ext_typecheck_convert_incompatible_pointer) 2359 << ToType << From->getType() << Action 2360 << From->getSourceRange() << 0; 2361 else 2362 Diag(From->getSourceRange().getBegin(), 2363 diag::ext_typecheck_convert_incompatible_pointer) 2364 << From->getType() << ToType << Action 2365 << From->getSourceRange() << 0; 2366 2367 if (From->getType()->isObjCObjectPointerType() && 2368 ToType->isObjCObjectPointerType()) 2369 EmitRelatedResultTypeNote(From); 2370 } 2371 else if (getLangOptions().ObjCAutoRefCount && 2372 !CheckObjCARCUnavailableWeakConversion(ToType, 2373 From->getType())) { 2374 if (Action == AA_Initializing) 2375 Diag(From->getSourceRange().getBegin(), 2376 diag::err_arc_weak_unavailable_assign); 2377 else 2378 Diag(From->getSourceRange().getBegin(), 2379 diag::err_arc_convesion_of_weak_unavailable) 2380 << (Action == AA_Casting) << From->getType() << ToType 2381 << From->getSourceRange(); 2382 } 2383 2384 CastKind Kind = CK_Invalid; 2385 CXXCastPath BasePath; 2386 if (CheckPointerConversion(From, ToType, Kind, BasePath, CStyle)) 2387 return ExprError(); 2388 2389 // Make sure we extend blocks if necessary. 2390 // FIXME: doing this here is really ugly. 2391 if (Kind == CK_BlockPointerToObjCPointerCast) { 2392 ExprResult E = From; 2393 (void) PrepareCastToObjCObjectPointer(E); 2394 From = E.take(); 2395 } 2396 2397 From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK) 2398 .take(); 2399 break; 2400 } 2401 2402 case ICK_Pointer_Member: { 2403 CastKind Kind = CK_Invalid; 2404 CXXCastPath BasePath; 2405 if (CheckMemberPointerConversion(From, ToType, Kind, BasePath, CStyle)) 2406 return ExprError(); 2407 if (CheckExceptionSpecCompatibility(From, ToType)) 2408 return ExprError(); 2409 From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK) 2410 .take(); 2411 break; 2412 } 2413 2414 case ICK_Boolean_Conversion: 2415 // Perform half-to-boolean conversion via float. 2416 if (From->getType()->isHalfType()) { 2417 From = ImpCastExprToType(From, Context.FloatTy, CK_FloatingCast).take(); 2418 FromType = Context.FloatTy; 2419 } 2420 2421 From = ImpCastExprToType(From, Context.BoolTy, 2422 ScalarTypeToBooleanCastKind(FromType), 2423 VK_RValue, /*BasePath=*/0, CCK).take(); 2424 break; 2425 2426 case ICK_Derived_To_Base: { 2427 CXXCastPath BasePath; 2428 if (CheckDerivedToBaseConversion(From->getType(), 2429 ToType.getNonReferenceType(), 2430 From->getLocStart(), 2431 From->getSourceRange(), 2432 &BasePath, 2433 CStyle)) 2434 return ExprError(); 2435 2436 From = ImpCastExprToType(From, ToType.getNonReferenceType(), 2437 CK_DerivedToBase, From->getValueKind(), 2438 &BasePath, CCK).take(); 2439 break; 2440 } 2441 2442 case ICK_Vector_Conversion: 2443 From = ImpCastExprToType(From, ToType, CK_BitCast, 2444 VK_RValue, /*BasePath=*/0, CCK).take(); 2445 break; 2446 2447 case ICK_Vector_Splat: 2448 From = ImpCastExprToType(From, ToType, CK_VectorSplat, 2449 VK_RValue, /*BasePath=*/0, CCK).take(); 2450 break; 2451 2452 case ICK_Complex_Real: 2453 // Case 1. x -> _Complex y 2454 if (const ComplexType *ToComplex = ToType->getAs<ComplexType>()) { 2455 QualType ElType = ToComplex->getElementType(); 2456 bool isFloatingComplex = ElType->isRealFloatingType(); 2457 2458 // x -> y 2459 if (Context.hasSameUnqualifiedType(ElType, From->getType())) { 2460 // do nothing 2461 } else if (From->getType()->isRealFloatingType()) { 2462 From = ImpCastExprToType(From, ElType, 2463 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).take(); 2464 } else { 2465 assert(From->getType()->isIntegerType()); 2466 From = ImpCastExprToType(From, ElType, 2467 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).take(); 2468 } 2469 // y -> _Complex y 2470 From = ImpCastExprToType(From, ToType, 2471 isFloatingComplex ? CK_FloatingRealToComplex 2472 : CK_IntegralRealToComplex).take(); 2473 2474 // Case 2. _Complex x -> y 2475 } else { 2476 const ComplexType *FromComplex = From->getType()->getAs<ComplexType>(); 2477 assert(FromComplex); 2478 2479 QualType ElType = FromComplex->getElementType(); 2480 bool isFloatingComplex = ElType->isRealFloatingType(); 2481 2482 // _Complex x -> x 2483 From = ImpCastExprToType(From, ElType, 2484 isFloatingComplex ? CK_FloatingComplexToReal 2485 : CK_IntegralComplexToReal, 2486 VK_RValue, /*BasePath=*/0, CCK).take(); 2487 2488 // x -> y 2489 if (Context.hasSameUnqualifiedType(ElType, ToType)) { 2490 // do nothing 2491 } else if (ToType->isRealFloatingType()) { 2492 From = ImpCastExprToType(From, ToType, 2493 isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating, 2494 VK_RValue, /*BasePath=*/0, CCK).take(); 2495 } else { 2496 assert(ToType->isIntegerType()); 2497 From = ImpCastExprToType(From, ToType, 2498 isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast, 2499 VK_RValue, /*BasePath=*/0, CCK).take(); 2500 } 2501 } 2502 break; 2503 2504 case ICK_Block_Pointer_Conversion: { 2505 From = ImpCastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast, 2506 VK_RValue, /*BasePath=*/0, CCK).take(); 2507 break; 2508 } 2509 2510 case ICK_TransparentUnionConversion: { 2511 ExprResult FromRes = Owned(From); 2512 Sema::AssignConvertType ConvTy = 2513 CheckTransparentUnionArgumentConstraints(ToType, FromRes); 2514 if (FromRes.isInvalid()) 2515 return ExprError(); 2516 From = FromRes.take(); 2517 assert ((ConvTy == Sema::Compatible) && 2518 "Improper transparent union conversion"); 2519 (void)ConvTy; 2520 break; 2521 } 2522 2523 case ICK_Lvalue_To_Rvalue: 2524 case ICK_Array_To_Pointer: 2525 case ICK_Function_To_Pointer: 2526 case ICK_Qualification: 2527 case ICK_Num_Conversion_Kinds: 2528 llvm_unreachable("Improper second standard conversion"); 2529 } 2530 2531 switch (SCS.Third) { 2532 case ICK_Identity: 2533 // Nothing to do. 2534 break; 2535 2536 case ICK_Qualification: { 2537 // The qualification keeps the category of the inner expression, unless the 2538 // target type isn't a reference. 2539 ExprValueKind VK = ToType->isReferenceType() ? 2540 From->getValueKind() : VK_RValue; 2541 From = ImpCastExprToType(From, ToType.getNonLValueExprType(Context), 2542 CK_NoOp, VK, /*BasePath=*/0, CCK).take(); 2543 2544 if (SCS.DeprecatedStringLiteralToCharPtr && 2545 !getLangOptions().WritableStrings) 2546 Diag(From->getLocStart(), diag::warn_deprecated_string_literal_conversion) 2547 << ToType.getNonReferenceType(); 2548 2549 break; 2550 } 2551 2552 default: 2553 llvm_unreachable("Improper third standard conversion"); 2554 } 2555 2556 return Owned(From); 2557} 2558 2559ExprResult Sema::ActOnUnaryTypeTrait(UnaryTypeTrait UTT, 2560 SourceLocation KWLoc, 2561 ParsedType Ty, 2562 SourceLocation RParen) { 2563 TypeSourceInfo *TSInfo; 2564 QualType T = GetTypeFromParser(Ty, &TSInfo); 2565 2566 if (!TSInfo) 2567 TSInfo = Context.getTrivialTypeSourceInfo(T); 2568 return BuildUnaryTypeTrait(UTT, KWLoc, TSInfo, RParen); 2569} 2570 2571/// \brief Check the completeness of a type in a unary type trait. 2572/// 2573/// If the particular type trait requires a complete type, tries to complete 2574/// it. If completing the type fails, a diagnostic is emitted and false 2575/// returned. If completing the type succeeds or no completion was required, 2576/// returns true. 2577static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, 2578 UnaryTypeTrait UTT, 2579 SourceLocation Loc, 2580 QualType ArgTy) { 2581 // C++0x [meta.unary.prop]p3: 2582 // For all of the class templates X declared in this Clause, instantiating 2583 // that template with a template argument that is a class template 2584 // specialization may result in the implicit instantiation of the template 2585 // argument if and only if the semantics of X require that the argument 2586 // must be a complete type. 2587 // We apply this rule to all the type trait expressions used to implement 2588 // these class templates. We also try to follow any GCC documented behavior 2589 // in these expressions to ensure portability of standard libraries. 2590 switch (UTT) { 2591 // is_complete_type somewhat obviously cannot require a complete type. 2592 case UTT_IsCompleteType: 2593 // Fall-through 2594 2595 // These traits are modeled on the type predicates in C++0x 2596 // [meta.unary.cat] and [meta.unary.comp]. They are not specified as 2597 // requiring a complete type, as whether or not they return true cannot be 2598 // impacted by the completeness of the type. 2599 case UTT_IsVoid: 2600 case UTT_IsIntegral: 2601 case UTT_IsFloatingPoint: 2602 case UTT_IsArray: 2603 case UTT_IsPointer: 2604 case UTT_IsLvalueReference: 2605 case UTT_IsRvalueReference: 2606 case UTT_IsMemberFunctionPointer: 2607 case UTT_IsMemberObjectPointer: 2608 case UTT_IsEnum: 2609 case UTT_IsUnion: 2610 case UTT_IsClass: 2611 case UTT_IsFunction: 2612 case UTT_IsReference: 2613 case UTT_IsArithmetic: 2614 case UTT_IsFundamental: 2615 case UTT_IsObject: 2616 case UTT_IsScalar: 2617 case UTT_IsCompound: 2618 case UTT_IsMemberPointer: 2619 // Fall-through 2620 2621 // These traits are modeled on type predicates in C++0x [meta.unary.prop] 2622 // which requires some of its traits to have the complete type. However, 2623 // the completeness of the type cannot impact these traits' semantics, and 2624 // so they don't require it. This matches the comments on these traits in 2625 // Table 49. 2626 case UTT_IsConst: 2627 case UTT_IsVolatile: 2628 case UTT_IsSigned: 2629 case UTT_IsUnsigned: 2630 return true; 2631 2632 // C++0x [meta.unary.prop] Table 49 requires the following traits to be 2633 // applied to a complete type. 2634 case UTT_IsTrivial: 2635 case UTT_IsTriviallyCopyable: 2636 case UTT_IsStandardLayout: 2637 case UTT_IsPOD: 2638 case UTT_IsLiteral: 2639 case UTT_IsEmpty: 2640 case UTT_IsPolymorphic: 2641 case UTT_IsAbstract: 2642 // Fall-through 2643 2644 // These trait expressions are designed to help implement predicates in 2645 // [meta.unary.prop] despite not being named the same. They are specified 2646 // by both GCC and the Embarcadero C++ compiler, and require the complete 2647 // type due to the overarching C++0x type predicates being implemented 2648 // requiring the complete type. 2649 case UTT_HasNothrowAssign: 2650 case UTT_HasNothrowConstructor: 2651 case UTT_HasNothrowCopy: 2652 case UTT_HasTrivialAssign: 2653 case UTT_HasTrivialDefaultConstructor: 2654 case UTT_HasTrivialCopy: 2655 case UTT_HasTrivialDestructor: 2656 case UTT_HasVirtualDestructor: 2657 // Arrays of unknown bound are expressly allowed. 2658 QualType ElTy = ArgTy; 2659 if (ArgTy->isIncompleteArrayType()) 2660 ElTy = S.Context.getAsArrayType(ArgTy)->getElementType(); 2661 2662 // The void type is expressly allowed. 2663 if (ElTy->isVoidType()) 2664 return true; 2665 2666 return !S.RequireCompleteType( 2667 Loc, ElTy, diag::err_incomplete_type_used_in_type_trait_expr); 2668 } 2669 llvm_unreachable("Type trait not handled by switch"); 2670} 2671 2672static bool EvaluateUnaryTypeTrait(Sema &Self, UnaryTypeTrait UTT, 2673 SourceLocation KeyLoc, QualType T) { 2674 assert(!T->isDependentType() && "Cannot evaluate traits of dependent type"); 2675 2676 ASTContext &C = Self.Context; 2677 switch(UTT) { 2678 // Type trait expressions corresponding to the primary type category 2679 // predicates in C++0x [meta.unary.cat]. 2680 case UTT_IsVoid: 2681 return T->isVoidType(); 2682 case UTT_IsIntegral: 2683 return T->isIntegralType(C); 2684 case UTT_IsFloatingPoint: 2685 return T->isFloatingType(); 2686 case UTT_IsArray: 2687 return T->isArrayType(); 2688 case UTT_IsPointer: 2689 return T->isPointerType(); 2690 case UTT_IsLvalueReference: 2691 return T->isLValueReferenceType(); 2692 case UTT_IsRvalueReference: 2693 return T->isRValueReferenceType(); 2694 case UTT_IsMemberFunctionPointer: 2695 return T->isMemberFunctionPointerType(); 2696 case UTT_IsMemberObjectPointer: 2697 return T->isMemberDataPointerType(); 2698 case UTT_IsEnum: 2699 return T->isEnumeralType(); 2700 case UTT_IsUnion: 2701 return T->isUnionType(); 2702 case UTT_IsClass: 2703 return T->isClassType() || T->isStructureType(); 2704 case UTT_IsFunction: 2705 return T->isFunctionType(); 2706 2707 // Type trait expressions which correspond to the convenient composition 2708 // predicates in C++0x [meta.unary.comp]. 2709 case UTT_IsReference: 2710 return T->isReferenceType(); 2711 case UTT_IsArithmetic: 2712 return T->isArithmeticType() && !T->isEnumeralType(); 2713 case UTT_IsFundamental: 2714 return T->isFundamentalType(); 2715 case UTT_IsObject: 2716 return T->isObjectType(); 2717 case UTT_IsScalar: 2718 // Note: semantic analysis depends on Objective-C lifetime types to be 2719 // considered scalar types. However, such types do not actually behave 2720 // like scalar types at run time (since they may require retain/release 2721 // operations), so we report them as non-scalar. 2722 if (T->isObjCLifetimeType()) { 2723 switch (T.getObjCLifetime()) { 2724 case Qualifiers::OCL_None: 2725 case Qualifiers::OCL_ExplicitNone: 2726 return true; 2727 2728 case Qualifiers::OCL_Strong: 2729 case Qualifiers::OCL_Weak: 2730 case Qualifiers::OCL_Autoreleasing: 2731 return false; 2732 } 2733 } 2734 2735 return T->isScalarType(); 2736 case UTT_IsCompound: 2737 return T->isCompoundType(); 2738 case UTT_IsMemberPointer: 2739 return T->isMemberPointerType(); 2740 2741 // Type trait expressions which correspond to the type property predicates 2742 // in C++0x [meta.unary.prop]. 2743 case UTT_IsConst: 2744 return T.isConstQualified(); 2745 case UTT_IsVolatile: 2746 return T.isVolatileQualified(); 2747 case UTT_IsTrivial: 2748 return T.isTrivialType(Self.Context); 2749 case UTT_IsTriviallyCopyable: 2750 return T.isTriviallyCopyableType(Self.Context); 2751 case UTT_IsStandardLayout: 2752 return T->isStandardLayoutType(); 2753 case UTT_IsPOD: 2754 return T.isPODType(Self.Context); 2755 case UTT_IsLiteral: 2756 return T->isLiteralType(); 2757 case UTT_IsEmpty: 2758 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 2759 return !RD->isUnion() && RD->isEmpty(); 2760 return false; 2761 case UTT_IsPolymorphic: 2762 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 2763 return RD->isPolymorphic(); 2764 return false; 2765 case UTT_IsAbstract: 2766 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 2767 return RD->isAbstract(); 2768 return false; 2769 case UTT_IsSigned: 2770 return T->isSignedIntegerType(); 2771 case UTT_IsUnsigned: 2772 return T->isUnsignedIntegerType(); 2773 2774 // Type trait expressions which query classes regarding their construction, 2775 // destruction, and copying. Rather than being based directly on the 2776 // related type predicates in the standard, they are specified by both 2777 // GCC[1] and the Embarcadero C++ compiler[2], and Clang implements those 2778 // specifications. 2779 // 2780 // 1: http://gcc.gnu/.org/onlinedocs/gcc/Type-Traits.html 2781 // 2: http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index 2782 case UTT_HasTrivialDefaultConstructor: 2783 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2784 // If __is_pod (type) is true then the trait is true, else if type is 2785 // a cv class or union type (or array thereof) with a trivial default 2786 // constructor ([class.ctor]) then the trait is true, else it is false. 2787 if (T.isPODType(Self.Context)) 2788 return true; 2789 if (const RecordType *RT = 2790 C.getBaseElementType(T)->getAs<RecordType>()) 2791 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialDefaultConstructor(); 2792 return false; 2793 case UTT_HasTrivialCopy: 2794 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2795 // If __is_pod (type) is true or type is a reference type then 2796 // the trait is true, else if type is a cv class or union type 2797 // with a trivial copy constructor ([class.copy]) then the trait 2798 // is true, else it is false. 2799 if (T.isPODType(Self.Context) || T->isReferenceType()) 2800 return true; 2801 if (const RecordType *RT = T->getAs<RecordType>()) 2802 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialCopyConstructor(); 2803 return false; 2804 case UTT_HasTrivialAssign: 2805 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2806 // If type is const qualified or is a reference type then the 2807 // trait is false. Otherwise if __is_pod (type) is true then the 2808 // trait is true, else if type is a cv class or union type with 2809 // a trivial copy assignment ([class.copy]) then the trait is 2810 // true, else it is false. 2811 // Note: the const and reference restrictions are interesting, 2812 // given that const and reference members don't prevent a class 2813 // from having a trivial copy assignment operator (but do cause 2814 // errors if the copy assignment operator is actually used, q.v. 2815 // [class.copy]p12). 2816 2817 if (C.getBaseElementType(T).isConstQualified()) 2818 return false; 2819 if (T.isPODType(Self.Context)) 2820 return true; 2821 if (const RecordType *RT = T->getAs<RecordType>()) 2822 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialCopyAssignment(); 2823 return false; 2824 case UTT_HasTrivialDestructor: 2825 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2826 // If __is_pod (type) is true or type is a reference type 2827 // then the trait is true, else if type is a cv class or union 2828 // type (or array thereof) with a trivial destructor 2829 // ([class.dtor]) then the trait is true, else it is 2830 // false. 2831 if (T.isPODType(Self.Context) || T->isReferenceType()) 2832 return true; 2833 2834 // Objective-C++ ARC: autorelease types don't require destruction. 2835 if (T->isObjCLifetimeType() && 2836 T.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) 2837 return true; 2838 2839 if (const RecordType *RT = 2840 C.getBaseElementType(T)->getAs<RecordType>()) 2841 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialDestructor(); 2842 return false; 2843 // TODO: Propagate nothrowness for implicitly declared special members. 2844 case UTT_HasNothrowAssign: 2845 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2846 // If type is const qualified or is a reference type then the 2847 // trait is false. Otherwise if __has_trivial_assign (type) 2848 // is true then the trait is true, else if type is a cv class 2849 // or union type with copy assignment operators that are known 2850 // not to throw an exception then the trait is true, else it is 2851 // false. 2852 if (C.getBaseElementType(T).isConstQualified()) 2853 return false; 2854 if (T->isReferenceType()) 2855 return false; 2856 if (T.isPODType(Self.Context) || T->isObjCLifetimeType()) 2857 return true; 2858 if (const RecordType *RT = T->getAs<RecordType>()) { 2859 CXXRecordDecl* RD = cast<CXXRecordDecl>(RT->getDecl()); 2860 if (RD->hasTrivialCopyAssignment()) 2861 return true; 2862 2863 bool FoundAssign = false; 2864 DeclarationName Name = C.DeclarationNames.getCXXOperatorName(OO_Equal); 2865 LookupResult Res(Self, DeclarationNameInfo(Name, KeyLoc), 2866 Sema::LookupOrdinaryName); 2867 if (Self.LookupQualifiedName(Res, RD)) { 2868 Res.suppressDiagnostics(); 2869 for (LookupResult::iterator Op = Res.begin(), OpEnd = Res.end(); 2870 Op != OpEnd; ++Op) { 2871 if (isa<FunctionTemplateDecl>(*Op)) 2872 continue; 2873 2874 CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op); 2875 if (Operator->isCopyAssignmentOperator()) { 2876 FoundAssign = true; 2877 const FunctionProtoType *CPT 2878 = Operator->getType()->getAs<FunctionProtoType>(); 2879 if (CPT->getExceptionSpecType() == EST_Delayed) 2880 return false; 2881 if (!CPT->isNothrow(Self.Context)) 2882 return false; 2883 } 2884 } 2885 } 2886 2887 return FoundAssign; 2888 } 2889 return false; 2890 case UTT_HasNothrowCopy: 2891 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2892 // If __has_trivial_copy (type) is true then the trait is true, else 2893 // if type is a cv class or union type with copy constructors that are 2894 // known not to throw an exception then the trait is true, else it is 2895 // false. 2896 if (T.isPODType(C) || T->isReferenceType() || T->isObjCLifetimeType()) 2897 return true; 2898 if (const RecordType *RT = T->getAs<RecordType>()) { 2899 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 2900 if (RD->hasTrivialCopyConstructor()) 2901 return true; 2902 2903 bool FoundConstructor = false; 2904 unsigned FoundTQs; 2905 DeclContext::lookup_const_iterator Con, ConEnd; 2906 for (llvm::tie(Con, ConEnd) = Self.LookupConstructors(RD); 2907 Con != ConEnd; ++Con) { 2908 // A template constructor is never a copy constructor. 2909 // FIXME: However, it may actually be selected at the actual overload 2910 // resolution point. 2911 if (isa<FunctionTemplateDecl>(*Con)) 2912 continue; 2913 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con); 2914 if (Constructor->isCopyConstructor(FoundTQs)) { 2915 FoundConstructor = true; 2916 const FunctionProtoType *CPT 2917 = Constructor->getType()->getAs<FunctionProtoType>(); 2918 if (CPT->getExceptionSpecType() == EST_Delayed) 2919 return false; 2920 // FIXME: check whether evaluating default arguments can throw. 2921 // For now, we'll be conservative and assume that they can throw. 2922 if (!CPT->isNothrow(Self.Context) || CPT->getNumArgs() > 1) 2923 return false; 2924 } 2925 } 2926 2927 return FoundConstructor; 2928 } 2929 return false; 2930 case UTT_HasNothrowConstructor: 2931 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2932 // If __has_trivial_constructor (type) is true then the trait is 2933 // true, else if type is a cv class or union type (or array 2934 // thereof) with a default constructor that is known not to 2935 // throw an exception then the trait is true, else it is false. 2936 if (T.isPODType(C) || T->isObjCLifetimeType()) 2937 return true; 2938 if (const RecordType *RT = C.getBaseElementType(T)->getAs<RecordType>()) { 2939 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 2940 if (RD->hasTrivialDefaultConstructor()) 2941 return true; 2942 2943 DeclContext::lookup_const_iterator Con, ConEnd; 2944 for (llvm::tie(Con, ConEnd) = Self.LookupConstructors(RD); 2945 Con != ConEnd; ++Con) { 2946 // FIXME: In C++0x, a constructor template can be a default constructor. 2947 if (isa<FunctionTemplateDecl>(*Con)) 2948 continue; 2949 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con); 2950 if (Constructor->isDefaultConstructor()) { 2951 const FunctionProtoType *CPT 2952 = Constructor->getType()->getAs<FunctionProtoType>(); 2953 if (CPT->getExceptionSpecType() == EST_Delayed) 2954 return false; 2955 // TODO: check whether evaluating default arguments can throw. 2956 // For now, we'll be conservative and assume that they can throw. 2957 return CPT->isNothrow(Self.Context) && CPT->getNumArgs() == 0; 2958 } 2959 } 2960 } 2961 return false; 2962 case UTT_HasVirtualDestructor: 2963 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 2964 // If type is a class type with a virtual destructor ([class.dtor]) 2965 // then the trait is true, else it is false. 2966 if (const RecordType *Record = T->getAs<RecordType>()) { 2967 CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); 2968 if (CXXDestructorDecl *Destructor = Self.LookupDestructor(RD)) 2969 return Destructor->isVirtual(); 2970 } 2971 return false; 2972 2973 // These type trait expressions are modeled on the specifications for the 2974 // Embarcadero C++0x type trait functions: 2975 // http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index 2976 case UTT_IsCompleteType: 2977 // http://docwiki.embarcadero.com/RADStudio/XE/en/Is_complete_type_(typename_T_): 2978 // Returns True if and only if T is a complete type at the point of the 2979 // function call. 2980 return !T->isIncompleteType(); 2981 } 2982 llvm_unreachable("Type trait not covered by switch"); 2983} 2984 2985ExprResult Sema::BuildUnaryTypeTrait(UnaryTypeTrait UTT, 2986 SourceLocation KWLoc, 2987 TypeSourceInfo *TSInfo, 2988 SourceLocation RParen) { 2989 QualType T = TSInfo->getType(); 2990 if (!CheckUnaryTypeTraitTypeCompleteness(*this, UTT, KWLoc, T)) 2991 return ExprError(); 2992 2993 bool Value = false; 2994 if (!T->isDependentType()) 2995 Value = EvaluateUnaryTypeTrait(*this, UTT, KWLoc, T); 2996 2997 return Owned(new (Context) UnaryTypeTraitExpr(KWLoc, UTT, TSInfo, Value, 2998 RParen, Context.BoolTy)); 2999} 3000 3001ExprResult Sema::ActOnBinaryTypeTrait(BinaryTypeTrait BTT, 3002 SourceLocation KWLoc, 3003 ParsedType LhsTy, 3004 ParsedType RhsTy, 3005 SourceLocation RParen) { 3006 TypeSourceInfo *LhsTSInfo; 3007 QualType LhsT = GetTypeFromParser(LhsTy, &LhsTSInfo); 3008 if (!LhsTSInfo) 3009 LhsTSInfo = Context.getTrivialTypeSourceInfo(LhsT); 3010 3011 TypeSourceInfo *RhsTSInfo; 3012 QualType RhsT = GetTypeFromParser(RhsTy, &RhsTSInfo); 3013 if (!RhsTSInfo) 3014 RhsTSInfo = Context.getTrivialTypeSourceInfo(RhsT); 3015 3016 return BuildBinaryTypeTrait(BTT, KWLoc, LhsTSInfo, RhsTSInfo, RParen); 3017} 3018 3019static bool EvaluateBinaryTypeTrait(Sema &Self, BinaryTypeTrait BTT, 3020 QualType LhsT, QualType RhsT, 3021 SourceLocation KeyLoc) { 3022 assert(!LhsT->isDependentType() && !RhsT->isDependentType() && 3023 "Cannot evaluate traits of dependent types"); 3024 3025 switch(BTT) { 3026 case BTT_IsBaseOf: { 3027 // C++0x [meta.rel]p2 3028 // Base is a base class of Derived without regard to cv-qualifiers or 3029 // Base and Derived are not unions and name the same class type without 3030 // regard to cv-qualifiers. 3031 3032 const RecordType *lhsRecord = LhsT->getAs<RecordType>(); 3033 if (!lhsRecord) return false; 3034 3035 const RecordType *rhsRecord = RhsT->getAs<RecordType>(); 3036 if (!rhsRecord) return false; 3037 3038 assert(Self.Context.hasSameUnqualifiedType(LhsT, RhsT) 3039 == (lhsRecord == rhsRecord)); 3040 3041 if (lhsRecord == rhsRecord) 3042 return !lhsRecord->getDecl()->isUnion(); 3043 3044 // C++0x [meta.rel]p2: 3045 // If Base and Derived are class types and are different types 3046 // (ignoring possible cv-qualifiers) then Derived shall be a 3047 // complete type. 3048 if (Self.RequireCompleteType(KeyLoc, RhsT, 3049 diag::err_incomplete_type_used_in_type_trait_expr)) 3050 return false; 3051 3052 return cast<CXXRecordDecl>(rhsRecord->getDecl()) 3053 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->getDecl())); 3054 } 3055 case BTT_IsSame: 3056 return Self.Context.hasSameType(LhsT, RhsT); 3057 case BTT_TypeCompatible: 3058 return Self.Context.typesAreCompatible(LhsT.getUnqualifiedType(), 3059 RhsT.getUnqualifiedType()); 3060 case BTT_IsConvertible: 3061 case BTT_IsConvertibleTo: { 3062 // C++0x [meta.rel]p4: 3063 // Given the following function prototype: 3064 // 3065 // template <class T> 3066 // typename add_rvalue_reference<T>::type create(); 3067 // 3068 // the predicate condition for a template specialization 3069 // is_convertible<From, To> shall be satisfied if and only if 3070 // the return expression in the following code would be 3071 // well-formed, including any implicit conversions to the return 3072 // type of the function: 3073 // 3074 // To test() { 3075 // return create<From>(); 3076 // } 3077 // 3078 // Access checking is performed as if in a context unrelated to To and 3079 // From. Only the validity of the immediate context of the expression 3080 // of the return-statement (including conversions to the return type) 3081 // is considered. 3082 // 3083 // We model the initialization as a copy-initialization of a temporary 3084 // of the appropriate type, which for this expression is identical to the 3085 // return statement (since NRVO doesn't apply). 3086 if (LhsT->isObjectType() || LhsT->isFunctionType()) 3087 LhsT = Self.Context.getRValueReferenceType(LhsT); 3088 3089 InitializedEntity To(InitializedEntity::InitializeTemporary(RhsT)); 3090 OpaqueValueExpr From(KeyLoc, LhsT.getNonLValueExprType(Self.Context), 3091 Expr::getValueKindForType(LhsT)); 3092 Expr *FromPtr = &From; 3093 InitializationKind Kind(InitializationKind::CreateCopy(KeyLoc, 3094 SourceLocation())); 3095 3096 // Perform the initialization within a SFINAE trap at translation unit 3097 // scope. 3098 Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true); 3099 Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl()); 3100 InitializationSequence Init(Self, To, Kind, &FromPtr, 1); 3101 if (Init.Failed()) 3102 return false; 3103 3104 ExprResult Result = Init.Perform(Self, To, Kind, MultiExprArg(&FromPtr, 1)); 3105 return !Result.isInvalid() && !SFINAE.hasErrorOccurred(); 3106 } 3107 } 3108 llvm_unreachable("Unknown type trait or not implemented"); 3109} 3110 3111ExprResult Sema::BuildBinaryTypeTrait(BinaryTypeTrait BTT, 3112 SourceLocation KWLoc, 3113 TypeSourceInfo *LhsTSInfo, 3114 TypeSourceInfo *RhsTSInfo, 3115 SourceLocation RParen) { 3116 QualType LhsT = LhsTSInfo->getType(); 3117 QualType RhsT = RhsTSInfo->getType(); 3118 3119 if (BTT == BTT_TypeCompatible) { 3120 if (getLangOptions().CPlusPlus) { 3121 Diag(KWLoc, diag::err_types_compatible_p_in_cplusplus) 3122 << SourceRange(KWLoc, RParen); 3123 return ExprError(); 3124 } 3125 } 3126 3127 bool Value = false; 3128 if (!LhsT->isDependentType() && !RhsT->isDependentType()) 3129 Value = EvaluateBinaryTypeTrait(*this, BTT, LhsT, RhsT, KWLoc); 3130 3131 // Select trait result type. 3132 QualType ResultType; 3133 switch (BTT) { 3134 case BTT_IsBaseOf: ResultType = Context.BoolTy; break; 3135 case BTT_IsConvertible: ResultType = Context.BoolTy; break; 3136 case BTT_IsSame: ResultType = Context.BoolTy; break; 3137 case BTT_TypeCompatible: ResultType = Context.IntTy; break; 3138 case BTT_IsConvertibleTo: ResultType = Context.BoolTy; break; 3139 } 3140 3141 return Owned(new (Context) BinaryTypeTraitExpr(KWLoc, BTT, LhsTSInfo, 3142 RhsTSInfo, Value, RParen, 3143 ResultType)); 3144} 3145 3146ExprResult Sema::ActOnArrayTypeTrait(ArrayTypeTrait ATT, 3147 SourceLocation KWLoc, 3148 ParsedType Ty, 3149 Expr* DimExpr, 3150 SourceLocation RParen) { 3151 TypeSourceInfo *TSInfo; 3152 QualType T = GetTypeFromParser(Ty, &TSInfo); 3153 if (!TSInfo) 3154 TSInfo = Context.getTrivialTypeSourceInfo(T); 3155 3156 return BuildArrayTypeTrait(ATT, KWLoc, TSInfo, DimExpr, RParen); 3157} 3158 3159static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT, 3160 QualType T, Expr *DimExpr, 3161 SourceLocation KeyLoc) { 3162 assert(!T->isDependentType() && "Cannot evaluate traits of dependent type"); 3163 3164 switch(ATT) { 3165 case ATT_ArrayRank: 3166 if (T->isArrayType()) { 3167 unsigned Dim = 0; 3168 while (const ArrayType *AT = Self.Context.getAsArrayType(T)) { 3169 ++Dim; 3170 T = AT->getElementType(); 3171 } 3172 return Dim; 3173 } 3174 return 0; 3175 3176 case ATT_ArrayExtent: { 3177 llvm::APSInt Value; 3178 uint64_t Dim; 3179 if (DimExpr->isIntegerConstantExpr(Value, Self.Context, 0, false)) { 3180 if (Value < llvm::APSInt(Value.getBitWidth(), Value.isUnsigned())) { 3181 Self.Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer) << 3182 DimExpr->getSourceRange(); 3183 return false; 3184 } 3185 Dim = Value.getLimitedValue(); 3186 } else { 3187 Self.Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer) << 3188 DimExpr->getSourceRange(); 3189 return false; 3190 } 3191 3192 if (T->isArrayType()) { 3193 unsigned D = 0; 3194 bool Matched = false; 3195 while (const ArrayType *AT = Self.Context.getAsArrayType(T)) { 3196 if (Dim == D) { 3197 Matched = true; 3198 break; 3199 } 3200 ++D; 3201 T = AT->getElementType(); 3202 } 3203 3204 if (Matched && T->isArrayType()) { 3205 if (const ConstantArrayType *CAT = Self.Context.getAsConstantArrayType(T)) 3206 return CAT->getSize().getLimitedValue(); 3207 } 3208 } 3209 return 0; 3210 } 3211 } 3212 llvm_unreachable("Unknown type trait or not implemented"); 3213} 3214 3215ExprResult Sema::BuildArrayTypeTrait(ArrayTypeTrait ATT, 3216 SourceLocation KWLoc, 3217 TypeSourceInfo *TSInfo, 3218 Expr* DimExpr, 3219 SourceLocation RParen) { 3220 QualType T = TSInfo->getType(); 3221 3222 // FIXME: This should likely be tracked as an APInt to remove any host 3223 // assumptions about the width of size_t on the target. 3224 uint64_t Value = 0; 3225 if (!T->isDependentType()) 3226 Value = EvaluateArrayTypeTrait(*this, ATT, T, DimExpr, KWLoc); 3227 3228 // While the specification for these traits from the Embarcadero C++ 3229 // compiler's documentation says the return type is 'unsigned int', Clang 3230 // returns 'size_t'. On Windows, the primary platform for the Embarcadero 3231 // compiler, there is no difference. On several other platforms this is an 3232 // important distinction. 3233 return Owned(new (Context) ArrayTypeTraitExpr(KWLoc, ATT, TSInfo, Value, 3234 DimExpr, RParen, 3235 Context.getSizeType())); 3236} 3237 3238ExprResult Sema::ActOnExpressionTrait(ExpressionTrait ET, 3239 SourceLocation KWLoc, 3240 Expr *Queried, 3241 SourceLocation RParen) { 3242 // If error parsing the expression, ignore. 3243 if (!Queried) 3244 return ExprError(); 3245 3246 ExprResult Result = BuildExpressionTrait(ET, KWLoc, Queried, RParen); 3247 3248 return move(Result); 3249} 3250 3251static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E) { 3252 switch (ET) { 3253 case ET_IsLValueExpr: return E->isLValue(); 3254 case ET_IsRValueExpr: return E->isRValue(); 3255 } 3256 llvm_unreachable("Expression trait not covered by switch"); 3257} 3258 3259ExprResult Sema::BuildExpressionTrait(ExpressionTrait ET, 3260 SourceLocation KWLoc, 3261 Expr *Queried, 3262 SourceLocation RParen) { 3263 if (Queried->isTypeDependent()) { 3264 // Delay type-checking for type-dependent expressions. 3265 } else if (Queried->getType()->isPlaceholderType()) { 3266 ExprResult PE = CheckPlaceholderExpr(Queried); 3267 if (PE.isInvalid()) return ExprError(); 3268 return BuildExpressionTrait(ET, KWLoc, PE.take(), RParen); 3269 } 3270 3271 bool Value = EvaluateExpressionTrait(ET, Queried); 3272 3273 return Owned(new (Context) ExpressionTraitExpr(KWLoc, ET, Queried, Value, 3274 RParen, Context.BoolTy)); 3275} 3276 3277QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, 3278 ExprValueKind &VK, 3279 SourceLocation Loc, 3280 bool isIndirect) { 3281 assert(!LHS.get()->getType()->isPlaceholderType() && 3282 !RHS.get()->getType()->isPlaceholderType() && 3283 "placeholders should have been weeded out by now"); 3284 3285 // The LHS undergoes lvalue conversions if this is ->*. 3286 if (isIndirect) { 3287 LHS = DefaultLvalueConversion(LHS.take()); 3288 if (LHS.isInvalid()) return QualType(); 3289 } 3290 3291 // The RHS always undergoes lvalue conversions. 3292 RHS = DefaultLvalueConversion(RHS.take()); 3293 if (RHS.isInvalid()) return QualType(); 3294 3295 const char *OpSpelling = isIndirect ? "->*" : ".*"; 3296 // C++ 5.5p2 3297 // The binary operator .* [p3: ->*] binds its second operand, which shall 3298 // be of type "pointer to member of T" (where T is a completely-defined 3299 // class type) [...] 3300 QualType RHSType = RHS.get()->getType(); 3301 const MemberPointerType *MemPtr = RHSType->getAs<MemberPointerType>(); 3302 if (!MemPtr) { 3303 Diag(Loc, diag::err_bad_memptr_rhs) 3304 << OpSpelling << RHSType << RHS.get()->getSourceRange(); 3305 return QualType(); 3306 } 3307 3308 QualType Class(MemPtr->getClass(), 0); 3309 3310 // Note: C++ [expr.mptr.oper]p2-3 says that the class type into which the 3311 // member pointer points must be completely-defined. However, there is no 3312 // reason for this semantic distinction, and the rule is not enforced by 3313 // other compilers. Therefore, we do not check this property, as it is 3314 // likely to be considered a defect. 3315 3316 // C++ 5.5p2 3317 // [...] to its first operand, which shall be of class T or of a class of 3318 // which T is an unambiguous and accessible base class. [p3: a pointer to 3319 // such a class] 3320 QualType LHSType = LHS.get()->getType(); 3321 if (isIndirect) { 3322 if (const PointerType *Ptr = LHSType->getAs<PointerType>()) 3323 LHSType = Ptr->getPointeeType(); 3324 else { 3325 Diag(Loc, diag::err_bad_memptr_lhs) 3326 << OpSpelling << 1 << LHSType 3327 << FixItHint::CreateReplacement(SourceRange(Loc), ".*"); 3328 return QualType(); 3329 } 3330 } 3331 3332 if (!Context.hasSameUnqualifiedType(Class, LHSType)) { 3333 // If we want to check the hierarchy, we need a complete type. 3334 if (RequireCompleteType(Loc, LHSType, PDiag(diag::err_bad_memptr_lhs) 3335 << OpSpelling << (int)isIndirect)) { 3336 return QualType(); 3337 } 3338 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 3339 /*DetectVirtual=*/false); 3340 // FIXME: Would it be useful to print full ambiguity paths, or is that 3341 // overkill? 3342 if (!IsDerivedFrom(LHSType, Class, Paths) || 3343 Paths.isAmbiguous(Context.getCanonicalType(Class))) { 3344 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling 3345 << (int)isIndirect << LHS.get()->getType(); 3346 return QualType(); 3347 } 3348 // Cast LHS to type of use. 3349 QualType UseType = isIndirect ? Context.getPointerType(Class) : Class; 3350 ExprValueKind VK = isIndirect ? VK_RValue : LHS.get()->getValueKind(); 3351 3352 CXXCastPath BasePath; 3353 BuildBasePathArray(Paths, BasePath); 3354 LHS = ImpCastExprToType(LHS.take(), UseType, CK_DerivedToBase, VK, 3355 &BasePath); 3356 } 3357 3358 if (isa<CXXScalarValueInitExpr>(RHS.get()->IgnoreParens())) { 3359 // Diagnose use of pointer-to-member type which when used as 3360 // the functional cast in a pointer-to-member expression. 3361 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect; 3362 return QualType(); 3363 } 3364 3365 // C++ 5.5p2 3366 // The result is an object or a function of the type specified by the 3367 // second operand. 3368 // The cv qualifiers are the union of those in the pointer and the left side, 3369 // in accordance with 5.5p5 and 5.2.5. 3370 QualType Result = MemPtr->getPointeeType(); 3371 Result = Context.getCVRQualifiedType(Result, LHSType.getCVRQualifiers()); 3372 3373 // C++0x [expr.mptr.oper]p6: 3374 // In a .* expression whose object expression is an rvalue, the program is 3375 // ill-formed if the second operand is a pointer to member function with 3376 // ref-qualifier &. In a ->* expression or in a .* expression whose object 3377 // expression is an lvalue, the program is ill-formed if the second operand 3378 // is a pointer to member function with ref-qualifier &&. 3379 if (const FunctionProtoType *Proto = Result->getAs<FunctionProtoType>()) { 3380 switch (Proto->getRefQualifier()) { 3381 case RQ_None: 3382 // Do nothing 3383 break; 3384 3385 case RQ_LValue: 3386 if (!isIndirect && !LHS.get()->Classify(Context).isLValue()) 3387 Diag(Loc, diag::err_pointer_to_member_oper_value_classify) 3388 << RHSType << 1 << LHS.get()->getSourceRange(); 3389 break; 3390 3391 case RQ_RValue: 3392 if (isIndirect || !LHS.get()->Classify(Context).isRValue()) 3393 Diag(Loc, diag::err_pointer_to_member_oper_value_classify) 3394 << RHSType << 0 << LHS.get()->getSourceRange(); 3395 break; 3396 } 3397 } 3398 3399 // C++ [expr.mptr.oper]p6: 3400 // The result of a .* expression whose second operand is a pointer 3401 // to a data member is of the same value category as its 3402 // first operand. The result of a .* expression whose second 3403 // operand is a pointer to a member function is a prvalue. The 3404 // result of an ->* expression is an lvalue if its second operand 3405 // is a pointer to data member and a prvalue otherwise. 3406 if (Result->isFunctionType()) { 3407 VK = VK_RValue; 3408 return Context.BoundMemberTy; 3409 } else if (isIndirect) { 3410 VK = VK_LValue; 3411 } else { 3412 VK = LHS.get()->getValueKind(); 3413 } 3414 3415 return Result; 3416} 3417 3418/// \brief Try to convert a type to another according to C++0x 5.16p3. 3419/// 3420/// This is part of the parameter validation for the ? operator. If either 3421/// value operand is a class type, the two operands are attempted to be 3422/// converted to each other. This function does the conversion in one direction. 3423/// It returns true if the program is ill-formed and has already been diagnosed 3424/// as such. 3425static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, 3426 SourceLocation QuestionLoc, 3427 bool &HaveConversion, 3428 QualType &ToType) { 3429 HaveConversion = false; 3430 ToType = To->getType(); 3431 3432 InitializationKind Kind = InitializationKind::CreateCopy(To->getLocStart(), 3433 SourceLocation()); 3434 // C++0x 5.16p3 3435 // The process for determining whether an operand expression E1 of type T1 3436 // can be converted to match an operand expression E2 of type T2 is defined 3437 // as follows: 3438 // -- If E2 is an lvalue: 3439 bool ToIsLvalue = To->isLValue(); 3440 if (ToIsLvalue) { 3441 // E1 can be converted to match E2 if E1 can be implicitly converted to 3442 // type "lvalue reference to T2", subject to the constraint that in the 3443 // conversion the reference must bind directly to E1. 3444 QualType T = Self.Context.getLValueReferenceType(ToType); 3445 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 3446 3447 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 3448 if (InitSeq.isDirectReferenceBinding()) { 3449 ToType = T; 3450 HaveConversion = true; 3451 return false; 3452 } 3453 3454 if (InitSeq.isAmbiguous()) 3455 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 3456 } 3457 3458 // -- If E2 is an rvalue, or if the conversion above cannot be done: 3459 // -- if E1 and E2 have class type, and the underlying class types are 3460 // the same or one is a base class of the other: 3461 QualType FTy = From->getType(); 3462 QualType TTy = To->getType(); 3463 const RecordType *FRec = FTy->getAs<RecordType>(); 3464 const RecordType *TRec = TTy->getAs<RecordType>(); 3465 bool FDerivedFromT = FRec && TRec && FRec != TRec && 3466 Self.IsDerivedFrom(FTy, TTy); 3467 if (FRec && TRec && 3468 (FRec == TRec || FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) { 3469 // E1 can be converted to match E2 if the class of T2 is the 3470 // same type as, or a base class of, the class of T1, and 3471 // [cv2 > cv1]. 3472 if (FRec == TRec || FDerivedFromT) { 3473 if (TTy.isAtLeastAsQualifiedAs(FTy)) { 3474 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 3475 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 3476 if (InitSeq) { 3477 HaveConversion = true; 3478 return false; 3479 } 3480 3481 if (InitSeq.isAmbiguous()) 3482 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 3483 } 3484 } 3485 3486 return false; 3487 } 3488 3489 // -- Otherwise: E1 can be converted to match E2 if E1 can be 3490 // implicitly converted to the type that expression E2 would have 3491 // if E2 were converted to an rvalue (or the type it has, if E2 is 3492 // an rvalue). 3493 // 3494 // This actually refers very narrowly to the lvalue-to-rvalue conversion, not 3495 // to the array-to-pointer or function-to-pointer conversions. 3496 if (!TTy->getAs<TagType>()) 3497 TTy = TTy.getUnqualifiedType(); 3498 3499 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 3500 InitializationSequence InitSeq(Self, Entity, Kind, &From, 1); 3501 HaveConversion = !InitSeq.Failed(); 3502 ToType = TTy; 3503 if (InitSeq.isAmbiguous()) 3504 return InitSeq.Diagnose(Self, Entity, Kind, &From, 1); 3505 3506 return false; 3507} 3508 3509/// \brief Try to find a common type for two according to C++0x 5.16p5. 3510/// 3511/// This is part of the parameter validation for the ? operator. If either 3512/// value operand is a class type, overload resolution is used to find a 3513/// conversion to a common type. 3514static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS, 3515 SourceLocation QuestionLoc) { 3516 Expr *Args[2] = { LHS.get(), RHS.get() }; 3517 OverloadCandidateSet CandidateSet(QuestionLoc); 3518 Self.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args, 2, 3519 CandidateSet); 3520 3521 OverloadCandidateSet::iterator Best; 3522 switch (CandidateSet.BestViableFunction(Self, QuestionLoc, Best)) { 3523 case OR_Success: { 3524 // We found a match. Perform the conversions on the arguments and move on. 3525 ExprResult LHSRes = 3526 Self.PerformImplicitConversion(LHS.get(), Best->BuiltinTypes.ParamTypes[0], 3527 Best->Conversions[0], Sema::AA_Converting); 3528 if (LHSRes.isInvalid()) 3529 break; 3530 LHS = move(LHSRes); 3531 3532 ExprResult RHSRes = 3533 Self.PerformImplicitConversion(RHS.get(), Best->BuiltinTypes.ParamTypes[1], 3534 Best->Conversions[1], Sema::AA_Converting); 3535 if (RHSRes.isInvalid()) 3536 break; 3537 RHS = move(RHSRes); 3538 if (Best->Function) 3539 Self.MarkDeclarationReferenced(QuestionLoc, Best->Function); 3540 return false; 3541 } 3542 3543 case OR_No_Viable_Function: 3544 3545 // Emit a better diagnostic if one of the expressions is a null pointer 3546 // constant and the other is a pointer type. In this case, the user most 3547 // likely forgot to take the address of the other expression. 3548 if (Self.DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc)) 3549 return true; 3550 3551 Self.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 3552 << LHS.get()->getType() << RHS.get()->getType() 3553 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 3554 return true; 3555 3556 case OR_Ambiguous: 3557 Self.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl) 3558 << LHS.get()->getType() << RHS.get()->getType() 3559 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 3560 // FIXME: Print the possible common types by printing the return types of 3561 // the viable candidates. 3562 break; 3563 3564 case OR_Deleted: 3565 llvm_unreachable("Conditional operator has only built-in overloads"); 3566 } 3567 return true; 3568} 3569 3570/// \brief Perform an "extended" implicit conversion as returned by 3571/// TryClassUnification. 3572static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T) { 3573 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 3574 InitializationKind Kind = InitializationKind::CreateCopy(E.get()->getLocStart(), 3575 SourceLocation()); 3576 Expr *Arg = E.take(); 3577 InitializationSequence InitSeq(Self, Entity, Kind, &Arg, 1); 3578 ExprResult Result = InitSeq.Perform(Self, Entity, Kind, MultiExprArg(&Arg, 1)); 3579 if (Result.isInvalid()) 3580 return true; 3581 3582 E = Result; 3583 return false; 3584} 3585 3586/// \brief Check the operands of ?: under C++ semantics. 3587/// 3588/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y 3589/// extension. In this case, LHS == Cond. (But they're not aliases.) 3590QualType Sema::CXXCheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, 3591 ExprValueKind &VK, ExprObjectKind &OK, 3592 SourceLocation QuestionLoc) { 3593 // FIXME: Handle C99's complex types, vector types, block pointers and Obj-C++ 3594 // interface pointers. 3595 3596 // C++0x 5.16p1 3597 // The first expression is contextually converted to bool. 3598 if (!Cond.get()->isTypeDependent()) { 3599 ExprResult CondRes = CheckCXXBooleanCondition(Cond.take()); 3600 if (CondRes.isInvalid()) 3601 return QualType(); 3602 Cond = move(CondRes); 3603 } 3604 3605 // Assume r-value. 3606 VK = VK_RValue; 3607 OK = OK_Ordinary; 3608 3609 // Either of the arguments dependent? 3610 if (LHS.get()->isTypeDependent() || RHS.get()->isTypeDependent()) 3611 return Context.DependentTy; 3612 3613 // C++0x 5.16p2 3614 // If either the second or the third operand has type (cv) void, ... 3615 QualType LTy = LHS.get()->getType(); 3616 QualType RTy = RHS.get()->getType(); 3617 bool LVoid = LTy->isVoidType(); 3618 bool RVoid = RTy->isVoidType(); 3619 if (LVoid || RVoid) { 3620 // ... then the [l2r] conversions are performed on the second and third 3621 // operands ... 3622 LHS = DefaultFunctionArrayLvalueConversion(LHS.take()); 3623 RHS = DefaultFunctionArrayLvalueConversion(RHS.take()); 3624 if (LHS.isInvalid() || RHS.isInvalid()) 3625 return QualType(); 3626 LTy = LHS.get()->getType(); 3627 RTy = RHS.get()->getType(); 3628 3629 // ... and one of the following shall hold: 3630 // -- The second or the third operand (but not both) is a throw- 3631 // expression; the result is of the type of the other and is an rvalue. 3632 bool LThrow = isa<CXXThrowExpr>(LHS.get()); 3633 bool RThrow = isa<CXXThrowExpr>(RHS.get()); 3634 if (LThrow && !RThrow) 3635 return RTy; 3636 if (RThrow && !LThrow) 3637 return LTy; 3638 3639 // -- Both the second and third operands have type void; the result is of 3640 // type void and is an rvalue. 3641 if (LVoid && RVoid) 3642 return Context.VoidTy; 3643 3644 // Neither holds, error. 3645 Diag(QuestionLoc, diag::err_conditional_void_nonvoid) 3646 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1) 3647 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 3648 return QualType(); 3649 } 3650 3651 // Neither is void. 3652 3653 // C++0x 5.16p3 3654 // Otherwise, if the second and third operand have different types, and 3655 // either has (cv) class type, and attempt is made to convert each of those 3656 // operands to the other. 3657 if (!Context.hasSameType(LTy, RTy) && 3658 (LTy->isRecordType() || RTy->isRecordType())) { 3659 ImplicitConversionSequence ICSLeftToRight, ICSRightToLeft; 3660 // These return true if a single direction is already ambiguous. 3661 QualType L2RType, R2LType; 3662 bool HaveL2R, HaveR2L; 3663 if (TryClassUnification(*this, LHS.get(), RHS.get(), QuestionLoc, HaveL2R, L2RType)) 3664 return QualType(); 3665 if (TryClassUnification(*this, RHS.get(), LHS.get(), QuestionLoc, HaveR2L, R2LType)) 3666 return QualType(); 3667 3668 // If both can be converted, [...] the program is ill-formed. 3669 if (HaveL2R && HaveR2L) { 3670 Diag(QuestionLoc, diag::err_conditional_ambiguous) 3671 << LTy << RTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 3672 return QualType(); 3673 } 3674 3675 // If exactly one conversion is possible, that conversion is applied to 3676 // the chosen operand and the converted operands are used in place of the 3677 // original operands for the remainder of this section. 3678 if (HaveL2R) { 3679 if (ConvertForConditional(*this, LHS, L2RType) || LHS.isInvalid()) 3680 return QualType(); 3681 LTy = LHS.get()->getType(); 3682 } else if (HaveR2L) { 3683 if (ConvertForConditional(*this, RHS, R2LType) || RHS.isInvalid()) 3684 return QualType(); 3685 RTy = RHS.get()->getType(); 3686 } 3687 } 3688 3689 // C++0x 5.16p4 3690 // If the second and third operands are glvalues of the same value 3691 // category and have the same type, the result is of that type and 3692 // value category and it is a bit-field if the second or the third 3693 // operand is a bit-field, or if both are bit-fields. 3694 // We only extend this to bitfields, not to the crazy other kinds of 3695 // l-values. 3696 bool Same = Context.hasSameType(LTy, RTy); 3697 if (Same && 3698 LHS.get()->isGLValue() && 3699 LHS.get()->getValueKind() == RHS.get()->getValueKind() && 3700 LHS.get()->isOrdinaryOrBitFieldObject() && 3701 RHS.get()->isOrdinaryOrBitFieldObject()) { 3702 VK = LHS.get()->getValueKind(); 3703 if (LHS.get()->getObjectKind() == OK_BitField || 3704 RHS.get()->getObjectKind() == OK_BitField) 3705 OK = OK_BitField; 3706 return LTy; 3707 } 3708 3709 // C++0x 5.16p5 3710 // Otherwise, the result is an rvalue. If the second and third operands 3711 // do not have the same type, and either has (cv) class type, ... 3712 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) { 3713 // ... overload resolution is used to determine the conversions (if any) 3714 // to be applied to the operands. If the overload resolution fails, the 3715 // program is ill-formed. 3716 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc)) 3717 return QualType(); 3718 } 3719 3720 // C++0x 5.16p6 3721 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard 3722 // conversions are performed on the second and third operands. 3723 LHS = DefaultFunctionArrayLvalueConversion(LHS.take()); 3724 RHS = DefaultFunctionArrayLvalueConversion(RHS.take()); 3725 if (LHS.isInvalid() || RHS.isInvalid()) 3726 return QualType(); 3727 LTy = LHS.get()->getType(); 3728 RTy = RHS.get()->getType(); 3729 3730 // After those conversions, one of the following shall hold: 3731 // -- The second and third operands have the same type; the result 3732 // is of that type. If the operands have class type, the result 3733 // is a prvalue temporary of the result type, which is 3734 // copy-initialized from either the second operand or the third 3735 // operand depending on the value of the first operand. 3736 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) { 3737 if (LTy->isRecordType()) { 3738 // The operands have class type. Make a temporary copy. 3739 InitializedEntity Entity = InitializedEntity::InitializeTemporary(LTy); 3740 ExprResult LHSCopy = PerformCopyInitialization(Entity, 3741 SourceLocation(), 3742 LHS); 3743 if (LHSCopy.isInvalid()) 3744 return QualType(); 3745 3746 ExprResult RHSCopy = PerformCopyInitialization(Entity, 3747 SourceLocation(), 3748 RHS); 3749 if (RHSCopy.isInvalid()) 3750 return QualType(); 3751 3752 LHS = LHSCopy; 3753 RHS = RHSCopy; 3754 } 3755 3756 return LTy; 3757 } 3758 3759 // Extension: conditional operator involving vector types. 3760 if (LTy->isVectorType() || RTy->isVectorType()) 3761 return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false); 3762 3763 // -- The second and third operands have arithmetic or enumeration type; 3764 // the usual arithmetic conversions are performed to bring them to a 3765 // common type, and the result is of that type. 3766 if (LTy->isArithmeticType() && RTy->isArithmeticType()) { 3767 UsualArithmeticConversions(LHS, RHS); 3768 if (LHS.isInvalid() || RHS.isInvalid()) 3769 return QualType(); 3770 return LHS.get()->getType(); 3771 } 3772 3773 // -- The second and third operands have pointer type, or one has pointer 3774 // type and the other is a null pointer constant; pointer conversions 3775 // and qualification conversions are performed to bring them to their 3776 // composite pointer type. The result is of the composite pointer type. 3777 // -- The second and third operands have pointer to member type, or one has 3778 // pointer to member type and the other is a null pointer constant; 3779 // pointer to member conversions and qualification conversions are 3780 // performed to bring them to a common type, whose cv-qualification 3781 // shall match the cv-qualification of either the second or the third 3782 // operand. The result is of the common type. 3783 bool NonStandardCompositeType = false; 3784 QualType Composite = FindCompositePointerType(QuestionLoc, LHS, RHS, 3785 isSFINAEContext()? 0 : &NonStandardCompositeType); 3786 if (!Composite.isNull()) { 3787 if (NonStandardCompositeType) 3788 Diag(QuestionLoc, 3789 diag::ext_typecheck_cond_incompatible_operands_nonstandard) 3790 << LTy << RTy << Composite 3791 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 3792 3793 return Composite; 3794 } 3795 3796 // Similarly, attempt to find composite type of two objective-c pointers. 3797 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc); 3798 if (!Composite.isNull()) 3799 return Composite; 3800 3801 // Check if we are using a null with a non-pointer type. 3802 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc)) 3803 return QualType(); 3804 3805 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 3806 << LHS.get()->getType() << RHS.get()->getType() 3807 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 3808 return QualType(); 3809} 3810 3811/// \brief Find a merged pointer type and convert the two expressions to it. 3812/// 3813/// This finds the composite pointer type (or member pointer type) for @p E1 3814/// and @p E2 according to C++0x 5.9p2. It converts both expressions to this 3815/// type and returns it. 3816/// It does not emit diagnostics. 3817/// 3818/// \param Loc The location of the operator requiring these two expressions to 3819/// be converted to the composite pointer type. 3820/// 3821/// If \p NonStandardCompositeType is non-NULL, then we are permitted to find 3822/// a non-standard (but still sane) composite type to which both expressions 3823/// can be converted. When such a type is chosen, \c *NonStandardCompositeType 3824/// will be set true. 3825QualType Sema::FindCompositePointerType(SourceLocation Loc, 3826 Expr *&E1, Expr *&E2, 3827 bool *NonStandardCompositeType) { 3828 if (NonStandardCompositeType) 3829 *NonStandardCompositeType = false; 3830 3831 assert(getLangOptions().CPlusPlus && "This function assumes C++"); 3832 QualType T1 = E1->getType(), T2 = E2->getType(); 3833 3834 if (!T1->isAnyPointerType() && !T1->isMemberPointerType() && 3835 !T2->isAnyPointerType() && !T2->isMemberPointerType()) 3836 return QualType(); 3837 3838 // C++0x 5.9p2 3839 // Pointer conversions and qualification conversions are performed on 3840 // pointer operands to bring them to their composite pointer type. If 3841 // one operand is a null pointer constant, the composite pointer type is 3842 // the type of the other operand. 3843 if (E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 3844 if (T2->isMemberPointerType()) 3845 E1 = ImpCastExprToType(E1, T2, CK_NullToMemberPointer).take(); 3846 else 3847 E1 = ImpCastExprToType(E1, T2, CK_NullToPointer).take(); 3848 return T2; 3849 } 3850 if (E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 3851 if (T1->isMemberPointerType()) 3852 E2 = ImpCastExprToType(E2, T1, CK_NullToMemberPointer).take(); 3853 else 3854 E2 = ImpCastExprToType(E2, T1, CK_NullToPointer).take(); 3855 return T1; 3856 } 3857 3858 // Now both have to be pointers or member pointers. 3859 if ((!T1->isPointerType() && !T1->isMemberPointerType()) || 3860 (!T2->isPointerType() && !T2->isMemberPointerType())) 3861 return QualType(); 3862 3863 // Otherwise, of one of the operands has type "pointer to cv1 void," then 3864 // the other has type "pointer to cv2 T" and the composite pointer type is 3865 // "pointer to cv12 void," where cv12 is the union of cv1 and cv2. 3866 // Otherwise, the composite pointer type is a pointer type similar to the 3867 // type of one of the operands, with a cv-qualification signature that is 3868 // the union of the cv-qualification signatures of the operand types. 3869 // In practice, the first part here is redundant; it's subsumed by the second. 3870 // What we do here is, we build the two possible composite types, and try the 3871 // conversions in both directions. If only one works, or if the two composite 3872 // types are the same, we have succeeded. 3873 // FIXME: extended qualifiers? 3874 typedef SmallVector<unsigned, 4> QualifierVector; 3875 QualifierVector QualifierUnion; 3876 typedef SmallVector<std::pair<const Type *, const Type *>, 4> 3877 ContainingClassVector; 3878 ContainingClassVector MemberOfClass; 3879 QualType Composite1 = Context.getCanonicalType(T1), 3880 Composite2 = Context.getCanonicalType(T2); 3881 unsigned NeedConstBefore = 0; 3882 do { 3883 const PointerType *Ptr1, *Ptr2; 3884 if ((Ptr1 = Composite1->getAs<PointerType>()) && 3885 (Ptr2 = Composite2->getAs<PointerType>())) { 3886 Composite1 = Ptr1->getPointeeType(); 3887 Composite2 = Ptr2->getPointeeType(); 3888 3889 // If we're allowed to create a non-standard composite type, keep track 3890 // of where we need to fill in additional 'const' qualifiers. 3891 if (NonStandardCompositeType && 3892 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 3893 NeedConstBefore = QualifierUnion.size(); 3894 3895 QualifierUnion.push_back( 3896 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 3897 MemberOfClass.push_back(std::make_pair((const Type *)0, (const Type *)0)); 3898 continue; 3899 } 3900 3901 const MemberPointerType *MemPtr1, *MemPtr2; 3902 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) && 3903 (MemPtr2 = Composite2->getAs<MemberPointerType>())) { 3904 Composite1 = MemPtr1->getPointeeType(); 3905 Composite2 = MemPtr2->getPointeeType(); 3906 3907 // If we're allowed to create a non-standard composite type, keep track 3908 // of where we need to fill in additional 'const' qualifiers. 3909 if (NonStandardCompositeType && 3910 Composite1.getCVRQualifiers() != Composite2.getCVRQualifiers()) 3911 NeedConstBefore = QualifierUnion.size(); 3912 3913 QualifierUnion.push_back( 3914 Composite1.getCVRQualifiers() | Composite2.getCVRQualifiers()); 3915 MemberOfClass.push_back(std::make_pair(MemPtr1->getClass(), 3916 MemPtr2->getClass())); 3917 continue; 3918 } 3919 3920 // FIXME: block pointer types? 3921 3922 // Cannot unwrap any more types. 3923 break; 3924 } while (true); 3925 3926 if (NeedConstBefore && NonStandardCompositeType) { 3927 // Extension: Add 'const' to qualifiers that come before the first qualifier 3928 // mismatch, so that our (non-standard!) composite type meets the 3929 // requirements of C++ [conv.qual]p4 bullet 3. 3930 for (unsigned I = 0; I != NeedConstBefore; ++I) { 3931 if ((QualifierUnion[I] & Qualifiers::Const) == 0) { 3932 QualifierUnion[I] = QualifierUnion[I] | Qualifiers::Const; 3933 *NonStandardCompositeType = true; 3934 } 3935 } 3936 } 3937 3938 // Rewrap the composites as pointers or member pointers with the union CVRs. 3939 ContainingClassVector::reverse_iterator MOC 3940 = MemberOfClass.rbegin(); 3941 for (QualifierVector::reverse_iterator 3942 I = QualifierUnion.rbegin(), 3943 E = QualifierUnion.rend(); 3944 I != E; (void)++I, ++MOC) { 3945 Qualifiers Quals = Qualifiers::fromCVRMask(*I); 3946 if (MOC->first && MOC->second) { 3947 // Rebuild member pointer type 3948 Composite1 = Context.getMemberPointerType( 3949 Context.getQualifiedType(Composite1, Quals), 3950 MOC->first); 3951 Composite2 = Context.getMemberPointerType( 3952 Context.getQualifiedType(Composite2, Quals), 3953 MOC->second); 3954 } else { 3955 // Rebuild pointer type 3956 Composite1 3957 = Context.getPointerType(Context.getQualifiedType(Composite1, Quals)); 3958 Composite2 3959 = Context.getPointerType(Context.getQualifiedType(Composite2, Quals)); 3960 } 3961 } 3962 3963 // Try to convert to the first composite pointer type. 3964 InitializedEntity Entity1 3965 = InitializedEntity::InitializeTemporary(Composite1); 3966 InitializationKind Kind 3967 = InitializationKind::CreateCopy(Loc, SourceLocation()); 3968 InitializationSequence E1ToC1(*this, Entity1, Kind, &E1, 1); 3969 InitializationSequence E2ToC1(*this, Entity1, Kind, &E2, 1); 3970 3971 if (E1ToC1 && E2ToC1) { 3972 // Conversion to Composite1 is viable. 3973 if (!Context.hasSameType(Composite1, Composite2)) { 3974 // Composite2 is a different type from Composite1. Check whether 3975 // Composite2 is also viable. 3976 InitializedEntity Entity2 3977 = InitializedEntity::InitializeTemporary(Composite2); 3978 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1); 3979 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1); 3980 if (E1ToC2 && E2ToC2) { 3981 // Both Composite1 and Composite2 are viable and are different; 3982 // this is an ambiguity. 3983 return QualType(); 3984 } 3985 } 3986 3987 // Convert E1 to Composite1 3988 ExprResult E1Result 3989 = E1ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,&E1,1)); 3990 if (E1Result.isInvalid()) 3991 return QualType(); 3992 E1 = E1Result.takeAs<Expr>(); 3993 3994 // Convert E2 to Composite1 3995 ExprResult E2Result 3996 = E2ToC1.Perform(*this, Entity1, Kind, MultiExprArg(*this,&E2,1)); 3997 if (E2Result.isInvalid()) 3998 return QualType(); 3999 E2 = E2Result.takeAs<Expr>(); 4000 4001 return Composite1; 4002 } 4003 4004 // Check whether Composite2 is viable. 4005 InitializedEntity Entity2 4006 = InitializedEntity::InitializeTemporary(Composite2); 4007 InitializationSequence E1ToC2(*this, Entity2, Kind, &E1, 1); 4008 InitializationSequence E2ToC2(*this, Entity2, Kind, &E2, 1); 4009 if (!E1ToC2 || !E2ToC2) 4010 return QualType(); 4011 4012 // Convert E1 to Composite2 4013 ExprResult E1Result 4014 = E1ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, &E1, 1)); 4015 if (E1Result.isInvalid()) 4016 return QualType(); 4017 E1 = E1Result.takeAs<Expr>(); 4018 4019 // Convert E2 to Composite2 4020 ExprResult E2Result 4021 = E2ToC2.Perform(*this, Entity2, Kind, MultiExprArg(*this, &E2, 1)); 4022 if (E2Result.isInvalid()) 4023 return QualType(); 4024 E2 = E2Result.takeAs<Expr>(); 4025 4026 return Composite2; 4027} 4028 4029ExprResult Sema::MaybeBindToTemporary(Expr *E) { 4030 if (!E) 4031 return ExprError(); 4032 4033 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?"); 4034 4035 // If the result is a glvalue, we shouldn't bind it. 4036 if (!E->isRValue()) 4037 return Owned(E); 4038 4039 // In ARC, calls that return a retainable type can return retained, 4040 // in which case we have to insert a consuming cast. 4041 if (getLangOptions().ObjCAutoRefCount && 4042 E->getType()->isObjCRetainableType()) { 4043 4044 bool ReturnsRetained; 4045 4046 // For actual calls, we compute this by examining the type of the 4047 // called value. 4048 if (CallExpr *Call = dyn_cast<CallExpr>(E)) { 4049 Expr *Callee = Call->getCallee()->IgnoreParens(); 4050 QualType T = Callee->getType(); 4051 4052 if (T == Context.BoundMemberTy) { 4053 // Handle pointer-to-members. 4054 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Callee)) 4055 T = BinOp->getRHS()->getType(); 4056 else if (MemberExpr *Mem = dyn_cast<MemberExpr>(Callee)) 4057 T = Mem->getMemberDecl()->getType(); 4058 } 4059 4060 if (const PointerType *Ptr = T->getAs<PointerType>()) 4061 T = Ptr->getPointeeType(); 4062 else if (const BlockPointerType *Ptr = T->getAs<BlockPointerType>()) 4063 T = Ptr->getPointeeType(); 4064 else if (const MemberPointerType *MemPtr = T->getAs<MemberPointerType>()) 4065 T = MemPtr->getPointeeType(); 4066 4067 const FunctionType *FTy = T->getAs<FunctionType>(); 4068 assert(FTy && "call to value not of function type?"); 4069 ReturnsRetained = FTy->getExtInfo().getProducesResult(); 4070 4071 // ActOnStmtExpr arranges things so that StmtExprs of retainable 4072 // type always produce a +1 object. 4073 } else if (isa<StmtExpr>(E)) { 4074 ReturnsRetained = true; 4075 4076 // For message sends and property references, we try to find an 4077 // actual method. FIXME: we should infer retention by selector in 4078 // cases where we don't have an actual method. 4079 } else { 4080 ObjCMethodDecl *D = 0; 4081 if (ObjCMessageExpr *Send = dyn_cast<ObjCMessageExpr>(E)) { 4082 D = Send->getMethodDecl(); 4083 } else { 4084 CastExpr *CE = cast<CastExpr>(E); 4085 assert(CE->getCastKind() == CK_GetObjCProperty); 4086 const ObjCPropertyRefExpr *PRE = CE->getSubExpr()->getObjCProperty(); 4087 D = (PRE->isImplicitProperty() ? PRE->getImplicitPropertyGetter() : 0); 4088 } 4089 4090 ReturnsRetained = (D && D->hasAttr<NSReturnsRetainedAttr>()); 4091 4092 // Don't do reclaims on performSelector calls; despite their 4093 // return type, the invoked method doesn't necessarily actually 4094 // return an object. 4095 if (!ReturnsRetained && 4096 D && D->getMethodFamily() == OMF_performSelector) 4097 return Owned(E); 4098 } 4099 4100 ExprNeedsCleanups = true; 4101 4102 CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject 4103 : CK_ARCReclaimReturnedObject); 4104 return Owned(ImplicitCastExpr::Create(Context, E->getType(), ck, E, 0, 4105 VK_RValue)); 4106 } 4107 4108 if (!getLangOptions().CPlusPlus) 4109 return Owned(E); 4110 4111 const RecordType *RT = E->getType()->getAs<RecordType>(); 4112 if (!RT) 4113 return Owned(E); 4114 4115 // That should be enough to guarantee that this type is complete. 4116 // If it has a trivial destructor, we can avoid the extra copy. 4117 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 4118 if (RD->isInvalidDecl() || RD->hasTrivialDestructor()) 4119 return Owned(E); 4120 4121 CXXDestructorDecl *Destructor = LookupDestructor(RD); 4122 4123 CXXTemporary *Temp = CXXTemporary::Create(Context, Destructor); 4124 if (Destructor) { 4125 MarkDeclarationReferenced(E->getExprLoc(), Destructor); 4126 CheckDestructorAccess(E->getExprLoc(), Destructor, 4127 PDiag(diag::err_access_dtor_temp) 4128 << E->getType()); 4129 4130 ExprTemporaries.push_back(Temp); 4131 ExprNeedsCleanups = true; 4132 } 4133 return Owned(CXXBindTemporaryExpr::Create(Context, Temp, E)); 4134} 4135 4136Expr *Sema::MaybeCreateExprWithCleanups(Expr *SubExpr) { 4137 assert(SubExpr && "sub expression can't be null!"); 4138 4139 unsigned FirstTemporary = ExprEvalContexts.back().NumTemporaries; 4140 assert(ExprTemporaries.size() >= FirstTemporary); 4141 assert(ExprNeedsCleanups || ExprTemporaries.size() == FirstTemporary); 4142 if (!ExprNeedsCleanups) 4143 return SubExpr; 4144 4145 Expr *E = ExprWithCleanups::Create(Context, SubExpr, 4146 ExprTemporaries.begin() + FirstTemporary, 4147 ExprTemporaries.size() - FirstTemporary); 4148 ExprTemporaries.erase(ExprTemporaries.begin() + FirstTemporary, 4149 ExprTemporaries.end()); 4150 ExprNeedsCleanups = false; 4151 4152 return E; 4153} 4154 4155ExprResult 4156Sema::MaybeCreateExprWithCleanups(ExprResult SubExpr) { 4157 if (SubExpr.isInvalid()) 4158 return ExprError(); 4159 4160 return Owned(MaybeCreateExprWithCleanups(SubExpr.take())); 4161} 4162 4163Stmt *Sema::MaybeCreateStmtWithCleanups(Stmt *SubStmt) { 4164 assert(SubStmt && "sub statement can't be null!"); 4165 4166 if (!ExprNeedsCleanups) 4167 return SubStmt; 4168 4169 // FIXME: In order to attach the temporaries, wrap the statement into 4170 // a StmtExpr; currently this is only used for asm statements. 4171 // This is hacky, either create a new CXXStmtWithTemporaries statement or 4172 // a new AsmStmtWithTemporaries. 4173 CompoundStmt *CompStmt = new (Context) CompoundStmt(Context, &SubStmt, 1, 4174 SourceLocation(), 4175 SourceLocation()); 4176 Expr *E = new (Context) StmtExpr(CompStmt, Context.VoidTy, SourceLocation(), 4177 SourceLocation()); 4178 return MaybeCreateExprWithCleanups(E); 4179} 4180 4181ExprResult 4182Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, 4183 tok::TokenKind OpKind, ParsedType &ObjectType, 4184 bool &MayBePseudoDestructor) { 4185 // Since this might be a postfix expression, get rid of ParenListExprs. 4186 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base); 4187 if (Result.isInvalid()) return ExprError(); 4188 Base = Result.get(); 4189 4190 Result = CheckPlaceholderExpr(Base); 4191 if (Result.isInvalid()) return ExprError(); 4192 Base = Result.take(); 4193 4194 QualType BaseType = Base->getType(); 4195 MayBePseudoDestructor = false; 4196 if (BaseType->isDependentType()) { 4197 // If we have a pointer to a dependent type and are using the -> operator, 4198 // the object type is the type that the pointer points to. We might still 4199 // have enough information about that type to do something useful. 4200 if (OpKind == tok::arrow) 4201 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 4202 BaseType = Ptr->getPointeeType(); 4203 4204 ObjectType = ParsedType::make(BaseType); 4205 MayBePseudoDestructor = true; 4206 return Owned(Base); 4207 } 4208 4209 // C++ [over.match.oper]p8: 4210 // [...] When operator->returns, the operator-> is applied to the value 4211 // returned, with the original second operand. 4212 if (OpKind == tok::arrow) { 4213 // The set of types we've considered so far. 4214 llvm::SmallPtrSet<CanQualType,8> CTypes; 4215 SmallVector<SourceLocation, 8> Locations; 4216 CTypes.insert(Context.getCanonicalType(BaseType)); 4217 4218 while (BaseType->isRecordType()) { 4219 Result = BuildOverloadedArrowExpr(S, Base, OpLoc); 4220 if (Result.isInvalid()) 4221 return ExprError(); 4222 Base = Result.get(); 4223 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(Base)) 4224 Locations.push_back(OpCall->getDirectCallee()->getLocation()); 4225 BaseType = Base->getType(); 4226 CanQualType CBaseType = Context.getCanonicalType(BaseType); 4227 if (!CTypes.insert(CBaseType)) { 4228 Diag(OpLoc, diag::err_operator_arrow_circular); 4229 for (unsigned i = 0; i < Locations.size(); i++) 4230 Diag(Locations[i], diag::note_declared_at); 4231 return ExprError(); 4232 } 4233 } 4234 4235 if (BaseType->isPointerType()) 4236 BaseType = BaseType->getPointeeType(); 4237 } 4238 4239 // We could end up with various non-record types here, such as extended 4240 // vector types or Objective-C interfaces. Just return early and let 4241 // ActOnMemberReferenceExpr do the work. 4242 if (!BaseType->isRecordType()) { 4243 // C++ [basic.lookup.classref]p2: 4244 // [...] If the type of the object expression is of pointer to scalar 4245 // type, the unqualified-id is looked up in the context of the complete 4246 // postfix-expression. 4247 // 4248 // This also indicates that we should be parsing a 4249 // pseudo-destructor-name. 4250 ObjectType = ParsedType(); 4251 MayBePseudoDestructor = true; 4252 return Owned(Base); 4253 } 4254 4255 // The object type must be complete (or dependent). 4256 if (!BaseType->isDependentType() && 4257 RequireCompleteType(OpLoc, BaseType, 4258 PDiag(diag::err_incomplete_member_access))) 4259 return ExprError(); 4260 4261 // C++ [basic.lookup.classref]p2: 4262 // If the id-expression in a class member access (5.2.5) is an 4263 // unqualified-id, and the type of the object expression is of a class 4264 // type C (or of pointer to a class type C), the unqualified-id is looked 4265 // up in the scope of class C. [...] 4266 ObjectType = ParsedType::make(BaseType); 4267 return move(Base); 4268} 4269 4270ExprResult Sema::DiagnoseDtorReference(SourceLocation NameLoc, 4271 Expr *MemExpr) { 4272 SourceLocation ExpectedLParenLoc = PP.getLocForEndOfToken(NameLoc); 4273 Diag(MemExpr->getLocStart(), diag::err_dtor_expr_without_call) 4274 << isa<CXXPseudoDestructorExpr>(MemExpr) 4275 << FixItHint::CreateInsertion(ExpectedLParenLoc, "()"); 4276 4277 return ActOnCallExpr(/*Scope*/ 0, 4278 MemExpr, 4279 /*LPLoc*/ ExpectedLParenLoc, 4280 MultiExprArg(), 4281 /*RPLoc*/ ExpectedLParenLoc); 4282} 4283 4284ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base, 4285 SourceLocation OpLoc, 4286 tok::TokenKind OpKind, 4287 const CXXScopeSpec &SS, 4288 TypeSourceInfo *ScopeTypeInfo, 4289 SourceLocation CCLoc, 4290 SourceLocation TildeLoc, 4291 PseudoDestructorTypeStorage Destructed, 4292 bool HasTrailingLParen) { 4293 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo(); 4294 4295 // C++ [expr.pseudo]p2: 4296 // The left-hand side of the dot operator shall be of scalar type. The 4297 // left-hand side of the arrow operator shall be of pointer to scalar type. 4298 // This scalar type is the object type. 4299 QualType ObjectType = Base->getType(); 4300 if (OpKind == tok::arrow) { 4301 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 4302 ObjectType = Ptr->getPointeeType(); 4303 } else if (!Base->isTypeDependent()) { 4304 // The user wrote "p->" when she probably meant "p."; fix it. 4305 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 4306 << ObjectType << true 4307 << FixItHint::CreateReplacement(OpLoc, "."); 4308 if (isSFINAEContext()) 4309 return ExprError(); 4310 4311 OpKind = tok::period; 4312 } 4313 } 4314 4315 if (!ObjectType->isDependentType() && !ObjectType->isScalarType()) { 4316 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar) 4317 << ObjectType << Base->getSourceRange(); 4318 return ExprError(); 4319 } 4320 4321 // C++ [expr.pseudo]p2: 4322 // [...] The cv-unqualified versions of the object type and of the type 4323 // designated by the pseudo-destructor-name shall be the same type. 4324 if (DestructedTypeInfo) { 4325 QualType DestructedType = DestructedTypeInfo->getType(); 4326 SourceLocation DestructedTypeStart 4327 = DestructedTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(); 4328 if (!DestructedType->isDependentType() && !ObjectType->isDependentType()) { 4329 if (!Context.hasSameUnqualifiedType(DestructedType, ObjectType)) { 4330 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch) 4331 << ObjectType << DestructedType << Base->getSourceRange() 4332 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange(); 4333 4334 // Recover by setting the destructed type to the object type. 4335 DestructedType = ObjectType; 4336 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType, 4337 DestructedTypeStart); 4338 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 4339 } else if (DestructedType.getObjCLifetime() != 4340 ObjectType.getObjCLifetime()) { 4341 4342 if (DestructedType.getObjCLifetime() == Qualifiers::OCL_None) { 4343 // Okay: just pretend that the user provided the correctly-qualified 4344 // type. 4345 } else { 4346 Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals) 4347 << ObjectType << DestructedType << Base->getSourceRange() 4348 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange(); 4349 } 4350 4351 // Recover by setting the destructed type to the object type. 4352 DestructedType = ObjectType; 4353 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType, 4354 DestructedTypeStart); 4355 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 4356 } 4357 } 4358 } 4359 4360 // C++ [expr.pseudo]p2: 4361 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the 4362 // form 4363 // 4364 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name 4365 // 4366 // shall designate the same scalar type. 4367 if (ScopeTypeInfo) { 4368 QualType ScopeType = ScopeTypeInfo->getType(); 4369 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() && 4370 !Context.hasSameUnqualifiedType(ScopeType, ObjectType)) { 4371 4372 Diag(ScopeTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(), 4373 diag::err_pseudo_dtor_type_mismatch) 4374 << ObjectType << ScopeType << Base->getSourceRange() 4375 << ScopeTypeInfo->getTypeLoc().getLocalSourceRange(); 4376 4377 ScopeType = QualType(); 4378 ScopeTypeInfo = 0; 4379 } 4380 } 4381 4382 Expr *Result 4383 = new (Context) CXXPseudoDestructorExpr(Context, Base, 4384 OpKind == tok::arrow, OpLoc, 4385 SS.getWithLocInContext(Context), 4386 ScopeTypeInfo, 4387 CCLoc, 4388 TildeLoc, 4389 Destructed); 4390 4391 if (HasTrailingLParen) 4392 return Owned(Result); 4393 4394 return DiagnoseDtorReference(Destructed.getLocation(), Result); 4395} 4396 4397ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base, 4398 SourceLocation OpLoc, 4399 tok::TokenKind OpKind, 4400 CXXScopeSpec &SS, 4401 UnqualifiedId &FirstTypeName, 4402 SourceLocation CCLoc, 4403 SourceLocation TildeLoc, 4404 UnqualifiedId &SecondTypeName, 4405 bool HasTrailingLParen) { 4406 assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 4407 FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) && 4408 "Invalid first type name in pseudo-destructor"); 4409 assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId || 4410 SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) && 4411 "Invalid second type name in pseudo-destructor"); 4412 4413 // C++ [expr.pseudo]p2: 4414 // The left-hand side of the dot operator shall be of scalar type. The 4415 // left-hand side of the arrow operator shall be of pointer to scalar type. 4416 // This scalar type is the object type. 4417 QualType ObjectType = Base->getType(); 4418 if (OpKind == tok::arrow) { 4419 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 4420 ObjectType = Ptr->getPointeeType(); 4421 } else if (!ObjectType->isDependentType()) { 4422 // The user wrote "p->" when she probably meant "p."; fix it. 4423 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 4424 << ObjectType << true 4425 << FixItHint::CreateReplacement(OpLoc, "."); 4426 if (isSFINAEContext()) 4427 return ExprError(); 4428 4429 OpKind = tok::period; 4430 } 4431 } 4432 4433 // Compute the object type that we should use for name lookup purposes. Only 4434 // record types and dependent types matter. 4435 ParsedType ObjectTypePtrForLookup; 4436 if (!SS.isSet()) { 4437 if (ObjectType->isRecordType()) 4438 ObjectTypePtrForLookup = ParsedType::make(ObjectType); 4439 else if (ObjectType->isDependentType()) 4440 ObjectTypePtrForLookup = ParsedType::make(Context.DependentTy); 4441 } 4442 4443 // Convert the name of the type being destructed (following the ~) into a 4444 // type (with source-location information). 4445 QualType DestructedType; 4446 TypeSourceInfo *DestructedTypeInfo = 0; 4447 PseudoDestructorTypeStorage Destructed; 4448 if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) { 4449 ParsedType T = getTypeName(*SecondTypeName.Identifier, 4450 SecondTypeName.StartLocation, 4451 S, &SS, true, false, ObjectTypePtrForLookup); 4452 if (!T && 4453 ((SS.isSet() && !computeDeclContext(SS, false)) || 4454 (!SS.isSet() && ObjectType->isDependentType()))) { 4455 // The name of the type being destroyed is a dependent name, and we 4456 // couldn't find anything useful in scope. Just store the identifier and 4457 // it's location, and we'll perform (qualified) name lookup again at 4458 // template instantiation time. 4459 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier, 4460 SecondTypeName.StartLocation); 4461 } else if (!T) { 4462 Diag(SecondTypeName.StartLocation, 4463 diag::err_pseudo_dtor_destructor_non_type) 4464 << SecondTypeName.Identifier << ObjectType; 4465 if (isSFINAEContext()) 4466 return ExprError(); 4467 4468 // Recover by assuming we had the right type all along. 4469 DestructedType = ObjectType; 4470 } else 4471 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo); 4472 } else { 4473 // Resolve the template-id to a type. 4474 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId; 4475 ASTTemplateArgsPtr TemplateArgsPtr(*this, 4476 TemplateId->getTemplateArgs(), 4477 TemplateId->NumArgs); 4478 TypeResult T = ActOnTemplateIdType(TemplateId->SS, 4479 TemplateId->Template, 4480 TemplateId->TemplateNameLoc, 4481 TemplateId->LAngleLoc, 4482 TemplateArgsPtr, 4483 TemplateId->RAngleLoc); 4484 if (T.isInvalid() || !T.get()) { 4485 // Recover by assuming we had the right type all along. 4486 DestructedType = ObjectType; 4487 } else 4488 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo); 4489 } 4490 4491 // If we've performed some kind of recovery, (re-)build the type source 4492 // information. 4493 if (!DestructedType.isNull()) { 4494 if (!DestructedTypeInfo) 4495 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType, 4496 SecondTypeName.StartLocation); 4497 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 4498 } 4499 4500 // Convert the name of the scope type (the type prior to '::') into a type. 4501 TypeSourceInfo *ScopeTypeInfo = 0; 4502 QualType ScopeType; 4503 if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId || 4504 FirstTypeName.Identifier) { 4505 if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) { 4506 ParsedType T = getTypeName(*FirstTypeName.Identifier, 4507 FirstTypeName.StartLocation, 4508 S, &SS, true, false, ObjectTypePtrForLookup); 4509 if (!T) { 4510 Diag(FirstTypeName.StartLocation, 4511 diag::err_pseudo_dtor_destructor_non_type) 4512 << FirstTypeName.Identifier << ObjectType; 4513 4514 if (isSFINAEContext()) 4515 return ExprError(); 4516 4517 // Just drop this type. It's unnecessary anyway. 4518 ScopeType = QualType(); 4519 } else 4520 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo); 4521 } else { 4522 // Resolve the template-id to a type. 4523 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId; 4524 ASTTemplateArgsPtr TemplateArgsPtr(*this, 4525 TemplateId->getTemplateArgs(), 4526 TemplateId->NumArgs); 4527 TypeResult T = ActOnTemplateIdType(TemplateId->SS, 4528 TemplateId->Template, 4529 TemplateId->TemplateNameLoc, 4530 TemplateId->LAngleLoc, 4531 TemplateArgsPtr, 4532 TemplateId->RAngleLoc); 4533 if (T.isInvalid() || !T.get()) { 4534 // Recover by dropping this type. 4535 ScopeType = QualType(); 4536 } else 4537 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo); 4538 } 4539 } 4540 4541 if (!ScopeType.isNull() && !ScopeTypeInfo) 4542 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType, 4543 FirstTypeName.StartLocation); 4544 4545 4546 return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, SS, 4547 ScopeTypeInfo, CCLoc, TildeLoc, 4548 Destructed, HasTrailingLParen); 4549} 4550 4551ExprResult Sema::BuildCXXMemberCallExpr(Expr *E, NamedDecl *FoundDecl, 4552 CXXMethodDecl *Method, 4553 bool HadMultipleCandidates) { 4554 ExprResult Exp = PerformObjectArgumentInitialization(E, /*Qualifier=*/0, 4555 FoundDecl, Method); 4556 if (Exp.isInvalid()) 4557 return true; 4558 4559 MemberExpr *ME = 4560 new (Context) MemberExpr(Exp.take(), /*IsArrow=*/false, Method, 4561 SourceLocation(), Method->getType(), 4562 VK_RValue, OK_Ordinary); 4563 if (HadMultipleCandidates) 4564 ME->setHadMultipleCandidates(true); 4565 4566 QualType ResultType = Method->getResultType(); 4567 ExprValueKind VK = Expr::getValueKindForType(ResultType); 4568 ResultType = ResultType.getNonLValueExprType(Context); 4569 4570 MarkDeclarationReferenced(Exp.get()->getLocStart(), Method); 4571 CXXMemberCallExpr *CE = 4572 new (Context) CXXMemberCallExpr(Context, ME, 0, 0, ResultType, VK, 4573 Exp.get()->getLocEnd()); 4574 return CE; 4575} 4576 4577ExprResult Sema::BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand, 4578 SourceLocation RParen) { 4579 return Owned(new (Context) CXXNoexceptExpr(Context.BoolTy, Operand, 4580 Operand->CanThrow(Context), 4581 KeyLoc, RParen)); 4582} 4583 4584ExprResult Sema::ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation, 4585 Expr *Operand, SourceLocation RParen) { 4586 return BuildCXXNoexceptExpr(KeyLoc, Operand, RParen); 4587} 4588 4589/// Perform the conversions required for an expression used in a 4590/// context that ignores the result. 4591ExprResult Sema::IgnoredValueConversions(Expr *E) { 4592 if (E->hasPlaceholderType()) { 4593 ExprResult result = CheckPlaceholderExpr(E); 4594 if (result.isInvalid()) return Owned(E); 4595 E = result.take(); 4596 } 4597 4598 // C99 6.3.2.1: 4599 // [Except in specific positions,] an lvalue that does not have 4600 // array type is converted to the value stored in the 4601 // designated object (and is no longer an lvalue). 4602 if (E->isRValue()) { 4603 // In C, function designators (i.e. expressions of function type) 4604 // are r-values, but we still want to do function-to-pointer decay 4605 // on them. This is both technically correct and convenient for 4606 // some clients. 4607 if (!getLangOptions().CPlusPlus && E->getType()->isFunctionType()) 4608 return DefaultFunctionArrayConversion(E); 4609 4610 return Owned(E); 4611 } 4612 4613 // Otherwise, this rule does not apply in C++, at least not for the moment. 4614 if (getLangOptions().CPlusPlus) return Owned(E); 4615 4616 // GCC seems to also exclude expressions of incomplete enum type. 4617 if (const EnumType *T = E->getType()->getAs<EnumType>()) { 4618 if (!T->getDecl()->isComplete()) { 4619 // FIXME: stupid workaround for a codegen bug! 4620 E = ImpCastExprToType(E, Context.VoidTy, CK_ToVoid).take(); 4621 return Owned(E); 4622 } 4623 } 4624 4625 ExprResult Res = DefaultFunctionArrayLvalueConversion(E); 4626 if (Res.isInvalid()) 4627 return Owned(E); 4628 E = Res.take(); 4629 4630 if (!E->getType()->isVoidType()) 4631 RequireCompleteType(E->getExprLoc(), E->getType(), 4632 diag::err_incomplete_type); 4633 return Owned(E); 4634} 4635 4636ExprResult Sema::ActOnFinishFullExpr(Expr *FE) { 4637 ExprResult FullExpr = Owned(FE); 4638 4639 if (!FullExpr.get()) 4640 return ExprError(); 4641 4642 if (DiagnoseUnexpandedParameterPack(FullExpr.get())) 4643 return ExprError(); 4644 4645 FullExpr = CheckPlaceholderExpr(FullExpr.take()); 4646 if (FullExpr.isInvalid()) 4647 return ExprError(); 4648 4649 FullExpr = IgnoredValueConversions(FullExpr.take()); 4650 if (FullExpr.isInvalid()) 4651 return ExprError(); 4652 4653 CheckImplicitConversions(FullExpr.get(), FullExpr.get()->getExprLoc()); 4654 return MaybeCreateExprWithCleanups(FullExpr); 4655} 4656 4657StmtResult Sema::ActOnFinishFullStmt(Stmt *FullStmt) { 4658 if (!FullStmt) return StmtError(); 4659 4660 return MaybeCreateStmtWithCleanups(FullStmt); 4661} 4662 4663Sema::IfExistsResult 4664Sema::CheckMicrosoftIfExistsSymbol(Scope *S, 4665 CXXScopeSpec &SS, 4666 const DeclarationNameInfo &TargetNameInfo) { 4667 DeclarationName TargetName = TargetNameInfo.getName(); 4668 if (!TargetName) 4669 return IER_DoesNotExist; 4670 4671 // If the name itself is dependent, then the result is dependent. 4672 if (TargetName.isDependentName()) 4673 return IER_Dependent; 4674 4675 // Do the redeclaration lookup in the current scope. 4676 LookupResult R(*this, TargetNameInfo, Sema::LookupAnyName, 4677 Sema::NotForRedeclaration); 4678 LookupParsedName(R, S, &SS); 4679 R.suppressDiagnostics(); 4680 4681 switch (R.getResultKind()) { 4682 case LookupResult::Found: 4683 case LookupResult::FoundOverloaded: 4684 case LookupResult::FoundUnresolvedValue: 4685 case LookupResult::Ambiguous: 4686 return IER_Exists; 4687 4688 case LookupResult::NotFound: 4689 return IER_DoesNotExist; 4690 4691 case LookupResult::NotFoundInCurrentInstantiation: 4692 return IER_Dependent; 4693 } 4694 4695 return IER_DoesNotExist; 4696} 4697 4698Sema::IfExistsResult 4699Sema::CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc, 4700 bool IsIfExists, CXXScopeSpec &SS, 4701 UnqualifiedId &Name) { 4702 DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name); 4703 4704 // Check for unexpanded parameter packs. 4705 SmallVector<UnexpandedParameterPack, 4> Unexpanded; 4706 collectUnexpandedParameterPacks(SS, Unexpanded); 4707 collectUnexpandedParameterPacks(TargetNameInfo, Unexpanded); 4708 if (!Unexpanded.empty()) { 4709 DiagnoseUnexpandedParameterPacks(KeywordLoc, 4710 IsIfExists? UPPC_IfExists 4711 : UPPC_IfNotExists, 4712 Unexpanded); 4713 return IER_Error; 4714 } 4715 4716 return CheckMicrosoftIfExistsSymbol(S, SS, TargetNameInfo); 4717} 4718 4719