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