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