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