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