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