SemaDeclCXX.cpp revision 243830
1//===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===// 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// This file implements semantic analysis for C++ declarations. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Sema/SemaInternal.h" 15#include "clang/Sema/CXXFieldCollector.h" 16#include "clang/Sema/Scope.h" 17#include "clang/Sema/Initialization.h" 18#include "clang/Sema/Lookup.h" 19#include "clang/Sema/ScopeInfo.h" 20#include "clang/AST/ASTConsumer.h" 21#include "clang/AST/ASTContext.h" 22#include "clang/AST/ASTMutationListener.h" 23#include "clang/AST/CharUnits.h" 24#include "clang/AST/CXXInheritance.h" 25#include "clang/AST/DeclVisitor.h" 26#include "clang/AST/EvaluatedExprVisitor.h" 27#include "clang/AST/ExprCXX.h" 28#include "clang/AST/RecordLayout.h" 29#include "clang/AST/RecursiveASTVisitor.h" 30#include "clang/AST/StmtVisitor.h" 31#include "clang/AST/TypeLoc.h" 32#include "clang/AST/TypeOrdering.h" 33#include "clang/Sema/DeclSpec.h" 34#include "clang/Sema/ParsedTemplate.h" 35#include "clang/Basic/PartialDiagnostic.h" 36#include "clang/Lex/Preprocessor.h" 37#include "llvm/ADT/SmallString.h" 38#include "llvm/ADT/STLExtras.h" 39#include <map> 40#include <set> 41 42using namespace clang; 43 44//===----------------------------------------------------------------------===// 45// CheckDefaultArgumentVisitor 46//===----------------------------------------------------------------------===// 47 48namespace { 49 /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses 50 /// the default argument of a parameter to determine whether it 51 /// contains any ill-formed subexpressions. For example, this will 52 /// diagnose the use of local variables or parameters within the 53 /// default argument expression. 54 class CheckDefaultArgumentVisitor 55 : public StmtVisitor<CheckDefaultArgumentVisitor, bool> { 56 Expr *DefaultArg; 57 Sema *S; 58 59 public: 60 CheckDefaultArgumentVisitor(Expr *defarg, Sema *s) 61 : DefaultArg(defarg), S(s) {} 62 63 bool VisitExpr(Expr *Node); 64 bool VisitDeclRefExpr(DeclRefExpr *DRE); 65 bool VisitCXXThisExpr(CXXThisExpr *ThisE); 66 bool VisitLambdaExpr(LambdaExpr *Lambda); 67 }; 68 69 /// VisitExpr - Visit all of the children of this expression. 70 bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) { 71 bool IsInvalid = false; 72 for (Stmt::child_range I = Node->children(); I; ++I) 73 IsInvalid |= Visit(*I); 74 return IsInvalid; 75 } 76 77 /// VisitDeclRefExpr - Visit a reference to a declaration, to 78 /// determine whether this declaration can be used in the default 79 /// argument expression. 80 bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) { 81 NamedDecl *Decl = DRE->getDecl(); 82 if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) { 83 // C++ [dcl.fct.default]p9 84 // Default arguments are evaluated each time the function is 85 // called. The order of evaluation of function arguments is 86 // unspecified. Consequently, parameters of a function shall not 87 // be used in default argument expressions, even if they are not 88 // evaluated. Parameters of a function declared before a default 89 // argument expression are in scope and can hide namespace and 90 // class member names. 91 return S->Diag(DRE->getLocStart(), 92 diag::err_param_default_argument_references_param) 93 << Param->getDeclName() << DefaultArg->getSourceRange(); 94 } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) { 95 // C++ [dcl.fct.default]p7 96 // Local variables shall not be used in default argument 97 // expressions. 98 if (VDecl->isLocalVarDecl()) 99 return S->Diag(DRE->getLocStart(), 100 diag::err_param_default_argument_references_local) 101 << VDecl->getDeclName() << DefaultArg->getSourceRange(); 102 } 103 104 return false; 105 } 106 107 /// VisitCXXThisExpr - Visit a C++ "this" expression. 108 bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) { 109 // C++ [dcl.fct.default]p8: 110 // The keyword this shall not be used in a default argument of a 111 // member function. 112 return S->Diag(ThisE->getLocStart(), 113 diag::err_param_default_argument_references_this) 114 << ThisE->getSourceRange(); 115 } 116 117 bool CheckDefaultArgumentVisitor::VisitLambdaExpr(LambdaExpr *Lambda) { 118 // C++11 [expr.lambda.prim]p13: 119 // A lambda-expression appearing in a default argument shall not 120 // implicitly or explicitly capture any entity. 121 if (Lambda->capture_begin() == Lambda->capture_end()) 122 return false; 123 124 return S->Diag(Lambda->getLocStart(), 125 diag::err_lambda_capture_default_arg); 126 } 127} 128 129void Sema::ImplicitExceptionSpecification::CalledDecl(SourceLocation CallLoc, 130 CXXMethodDecl *Method) { 131 // If we have an MSAny spec already, don't bother. 132 if (!Method || ComputedEST == EST_MSAny) 133 return; 134 135 const FunctionProtoType *Proto 136 = Method->getType()->getAs<FunctionProtoType>(); 137 Proto = Self->ResolveExceptionSpec(CallLoc, Proto); 138 if (!Proto) 139 return; 140 141 ExceptionSpecificationType EST = Proto->getExceptionSpecType(); 142 143 // If this function can throw any exceptions, make a note of that. 144 if (EST == EST_MSAny || EST == EST_None) { 145 ClearExceptions(); 146 ComputedEST = EST; 147 return; 148 } 149 150 // FIXME: If the call to this decl is using any of its default arguments, we 151 // need to search them for potentially-throwing calls. 152 153 // If this function has a basic noexcept, it doesn't affect the outcome. 154 if (EST == EST_BasicNoexcept) 155 return; 156 157 // If we have a throw-all spec at this point, ignore the function. 158 if (ComputedEST == EST_None) 159 return; 160 161 // If we're still at noexcept(true) and there's a nothrow() callee, 162 // change to that specification. 163 if (EST == EST_DynamicNone) { 164 if (ComputedEST == EST_BasicNoexcept) 165 ComputedEST = EST_DynamicNone; 166 return; 167 } 168 169 // Check out noexcept specs. 170 if (EST == EST_ComputedNoexcept) { 171 FunctionProtoType::NoexceptResult NR = 172 Proto->getNoexceptSpec(Self->Context); 173 assert(NR != FunctionProtoType::NR_NoNoexcept && 174 "Must have noexcept result for EST_ComputedNoexcept."); 175 assert(NR != FunctionProtoType::NR_Dependent && 176 "Should not generate implicit declarations for dependent cases, " 177 "and don't know how to handle them anyway."); 178 179 // noexcept(false) -> no spec on the new function 180 if (NR == FunctionProtoType::NR_Throw) { 181 ClearExceptions(); 182 ComputedEST = EST_None; 183 } 184 // noexcept(true) won't change anything either. 185 return; 186 } 187 188 assert(EST == EST_Dynamic && "EST case not considered earlier."); 189 assert(ComputedEST != EST_None && 190 "Shouldn't collect exceptions when throw-all is guaranteed."); 191 ComputedEST = EST_Dynamic; 192 // Record the exceptions in this function's exception specification. 193 for (FunctionProtoType::exception_iterator E = Proto->exception_begin(), 194 EEnd = Proto->exception_end(); 195 E != EEnd; ++E) 196 if (ExceptionsSeen.insert(Self->Context.getCanonicalType(*E))) 197 Exceptions.push_back(*E); 198} 199 200void Sema::ImplicitExceptionSpecification::CalledExpr(Expr *E) { 201 if (!E || ComputedEST == EST_MSAny) 202 return; 203 204 // FIXME: 205 // 206 // C++0x [except.spec]p14: 207 // [An] implicit exception-specification specifies the type-id T if and 208 // only if T is allowed by the exception-specification of a function directly 209 // invoked by f's implicit definition; f shall allow all exceptions if any 210 // function it directly invokes allows all exceptions, and f shall allow no 211 // exceptions if every function it directly invokes allows no exceptions. 212 // 213 // Note in particular that if an implicit exception-specification is generated 214 // for a function containing a throw-expression, that specification can still 215 // be noexcept(true). 216 // 217 // Note also that 'directly invoked' is not defined in the standard, and there 218 // is no indication that we should only consider potentially-evaluated calls. 219 // 220 // Ultimately we should implement the intent of the standard: the exception 221 // specification should be the set of exceptions which can be thrown by the 222 // implicit definition. For now, we assume that any non-nothrow expression can 223 // throw any exception. 224 225 if (Self->canThrow(E)) 226 ComputedEST = EST_None; 227} 228 229bool 230Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg, 231 SourceLocation EqualLoc) { 232 if (RequireCompleteType(Param->getLocation(), Param->getType(), 233 diag::err_typecheck_decl_incomplete_type)) { 234 Param->setInvalidDecl(); 235 return true; 236 } 237 238 // C++ [dcl.fct.default]p5 239 // A default argument expression is implicitly converted (clause 240 // 4) to the parameter type. The default argument expression has 241 // the same semantic constraints as the initializer expression in 242 // a declaration of a variable of the parameter type, using the 243 // copy-initialization semantics (8.5). 244 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context, 245 Param); 246 InitializationKind Kind = InitializationKind::CreateCopy(Param->getLocation(), 247 EqualLoc); 248 InitializationSequence InitSeq(*this, Entity, Kind, &Arg, 1); 249 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg); 250 if (Result.isInvalid()) 251 return true; 252 Arg = Result.takeAs<Expr>(); 253 254 CheckImplicitConversions(Arg, EqualLoc); 255 Arg = MaybeCreateExprWithCleanups(Arg); 256 257 // Okay: add the default argument to the parameter 258 Param->setDefaultArg(Arg); 259 260 // We have already instantiated this parameter; provide each of the 261 // instantiations with the uninstantiated default argument. 262 UnparsedDefaultArgInstantiationsMap::iterator InstPos 263 = UnparsedDefaultArgInstantiations.find(Param); 264 if (InstPos != UnparsedDefaultArgInstantiations.end()) { 265 for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I) 266 InstPos->second[I]->setUninstantiatedDefaultArg(Arg); 267 268 // We're done tracking this parameter's instantiations. 269 UnparsedDefaultArgInstantiations.erase(InstPos); 270 } 271 272 return false; 273} 274 275/// ActOnParamDefaultArgument - Check whether the default argument 276/// provided for a function parameter is well-formed. If so, attach it 277/// to the parameter declaration. 278void 279Sema::ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc, 280 Expr *DefaultArg) { 281 if (!param || !DefaultArg) 282 return; 283 284 ParmVarDecl *Param = cast<ParmVarDecl>(param); 285 UnparsedDefaultArgLocs.erase(Param); 286 287 // Default arguments are only permitted in C++ 288 if (!getLangOpts().CPlusPlus) { 289 Diag(EqualLoc, diag::err_param_default_argument) 290 << DefaultArg->getSourceRange(); 291 Param->setInvalidDecl(); 292 return; 293 } 294 295 // Check for unexpanded parameter packs. 296 if (DiagnoseUnexpandedParameterPack(DefaultArg, UPPC_DefaultArgument)) { 297 Param->setInvalidDecl(); 298 return; 299 } 300 301 // Check that the default argument is well-formed 302 CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg, this); 303 if (DefaultArgChecker.Visit(DefaultArg)) { 304 Param->setInvalidDecl(); 305 return; 306 } 307 308 SetParamDefaultArgument(Param, DefaultArg, EqualLoc); 309} 310 311/// ActOnParamUnparsedDefaultArgument - We've seen a default 312/// argument for a function parameter, but we can't parse it yet 313/// because we're inside a class definition. Note that this default 314/// argument will be parsed later. 315void Sema::ActOnParamUnparsedDefaultArgument(Decl *param, 316 SourceLocation EqualLoc, 317 SourceLocation ArgLoc) { 318 if (!param) 319 return; 320 321 ParmVarDecl *Param = cast<ParmVarDecl>(param); 322 if (Param) 323 Param->setUnparsedDefaultArg(); 324 325 UnparsedDefaultArgLocs[Param] = ArgLoc; 326} 327 328/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of 329/// the default argument for the parameter param failed. 330void Sema::ActOnParamDefaultArgumentError(Decl *param) { 331 if (!param) 332 return; 333 334 ParmVarDecl *Param = cast<ParmVarDecl>(param); 335 336 Param->setInvalidDecl(); 337 338 UnparsedDefaultArgLocs.erase(Param); 339} 340 341/// CheckExtraCXXDefaultArguments - Check for any extra default 342/// arguments in the declarator, which is not a function declaration 343/// or definition and therefore is not permitted to have default 344/// arguments. This routine should be invoked for every declarator 345/// that is not a function declaration or definition. 346void Sema::CheckExtraCXXDefaultArguments(Declarator &D) { 347 // C++ [dcl.fct.default]p3 348 // A default argument expression shall be specified only in the 349 // parameter-declaration-clause of a function declaration or in a 350 // template-parameter (14.1). It shall not be specified for a 351 // parameter pack. If it is specified in a 352 // parameter-declaration-clause, it shall not occur within a 353 // declarator or abstract-declarator of a parameter-declaration. 354 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 355 DeclaratorChunk &chunk = D.getTypeObject(i); 356 if (chunk.Kind == DeclaratorChunk::Function) { 357 for (unsigned argIdx = 0, e = chunk.Fun.NumArgs; argIdx != e; ++argIdx) { 358 ParmVarDecl *Param = 359 cast<ParmVarDecl>(chunk.Fun.ArgInfo[argIdx].Param); 360 if (Param->hasUnparsedDefaultArg()) { 361 CachedTokens *Toks = chunk.Fun.ArgInfo[argIdx].DefaultArgTokens; 362 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc) 363 << SourceRange((*Toks)[1].getLocation(), Toks->back().getLocation()); 364 delete Toks; 365 chunk.Fun.ArgInfo[argIdx].DefaultArgTokens = 0; 366 } else if (Param->getDefaultArg()) { 367 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc) 368 << Param->getDefaultArg()->getSourceRange(); 369 Param->setDefaultArg(0); 370 } 371 } 372 } 373 } 374} 375 376/// MergeCXXFunctionDecl - Merge two declarations of the same C++ 377/// function, once we already know that they have the same 378/// type. Subroutine of MergeFunctionDecl. Returns true if there was an 379/// error, false otherwise. 380bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, 381 Scope *S) { 382 bool Invalid = false; 383 384 // C++ [dcl.fct.default]p4: 385 // For non-template functions, default arguments can be added in 386 // later declarations of a function in the same 387 // scope. Declarations in different scopes have completely 388 // distinct sets of default arguments. That is, declarations in 389 // inner scopes do not acquire default arguments from 390 // declarations in outer scopes, and vice versa. In a given 391 // function declaration, all parameters subsequent to a 392 // parameter with a default argument shall have default 393 // arguments supplied in this or previous declarations. A 394 // default argument shall not be redefined by a later 395 // declaration (not even to the same value). 396 // 397 // C++ [dcl.fct.default]p6: 398 // Except for member functions of class templates, the default arguments 399 // in a member function definition that appears outside of the class 400 // definition are added to the set of default arguments provided by the 401 // member function declaration in the class definition. 402 for (unsigned p = 0, NumParams = Old->getNumParams(); p < NumParams; ++p) { 403 ParmVarDecl *OldParam = Old->getParamDecl(p); 404 ParmVarDecl *NewParam = New->getParamDecl(p); 405 406 bool OldParamHasDfl = OldParam->hasDefaultArg(); 407 bool NewParamHasDfl = NewParam->hasDefaultArg(); 408 409 NamedDecl *ND = Old; 410 if (S && !isDeclInScope(ND, New->getDeclContext(), S)) 411 // Ignore default parameters of old decl if they are not in 412 // the same scope. 413 OldParamHasDfl = false; 414 415 if (OldParamHasDfl && NewParamHasDfl) { 416 417 unsigned DiagDefaultParamID = 418 diag::err_param_default_argument_redefinition; 419 420 // MSVC accepts that default parameters be redefined for member functions 421 // of template class. The new default parameter's value is ignored. 422 Invalid = true; 423 if (getLangOpts().MicrosoftExt) { 424 CXXMethodDecl* MD = dyn_cast<CXXMethodDecl>(New); 425 if (MD && MD->getParent()->getDescribedClassTemplate()) { 426 // Merge the old default argument into the new parameter. 427 NewParam->setHasInheritedDefaultArg(); 428 if (OldParam->hasUninstantiatedDefaultArg()) 429 NewParam->setUninstantiatedDefaultArg( 430 OldParam->getUninstantiatedDefaultArg()); 431 else 432 NewParam->setDefaultArg(OldParam->getInit()); 433 DiagDefaultParamID = diag::warn_param_default_argument_redefinition; 434 Invalid = false; 435 } 436 } 437 438 // FIXME: If we knew where the '=' was, we could easily provide a fix-it 439 // hint here. Alternatively, we could walk the type-source information 440 // for NewParam to find the last source location in the type... but it 441 // isn't worth the effort right now. This is the kind of test case that 442 // is hard to get right: 443 // int f(int); 444 // void g(int (*fp)(int) = f); 445 // void g(int (*fp)(int) = &f); 446 Diag(NewParam->getLocation(), DiagDefaultParamID) 447 << NewParam->getDefaultArgRange(); 448 449 // Look for the function declaration where the default argument was 450 // actually written, which may be a declaration prior to Old. 451 for (FunctionDecl *Older = Old->getPreviousDecl(); 452 Older; Older = Older->getPreviousDecl()) { 453 if (!Older->getParamDecl(p)->hasDefaultArg()) 454 break; 455 456 OldParam = Older->getParamDecl(p); 457 } 458 459 Diag(OldParam->getLocation(), diag::note_previous_definition) 460 << OldParam->getDefaultArgRange(); 461 } else if (OldParamHasDfl) { 462 // Merge the old default argument into the new parameter. 463 // It's important to use getInit() here; getDefaultArg() 464 // strips off any top-level ExprWithCleanups. 465 NewParam->setHasInheritedDefaultArg(); 466 if (OldParam->hasUninstantiatedDefaultArg()) 467 NewParam->setUninstantiatedDefaultArg( 468 OldParam->getUninstantiatedDefaultArg()); 469 else 470 NewParam->setDefaultArg(OldParam->getInit()); 471 } else if (NewParamHasDfl) { 472 if (New->getDescribedFunctionTemplate()) { 473 // Paragraph 4, quoted above, only applies to non-template functions. 474 Diag(NewParam->getLocation(), 475 diag::err_param_default_argument_template_redecl) 476 << NewParam->getDefaultArgRange(); 477 Diag(Old->getLocation(), diag::note_template_prev_declaration) 478 << false; 479 } else if (New->getTemplateSpecializationKind() 480 != TSK_ImplicitInstantiation && 481 New->getTemplateSpecializationKind() != TSK_Undeclared) { 482 // C++ [temp.expr.spec]p21: 483 // Default function arguments shall not be specified in a declaration 484 // or a definition for one of the following explicit specializations: 485 // - the explicit specialization of a function template; 486 // - the explicit specialization of a member function template; 487 // - the explicit specialization of a member function of a class 488 // template where the class template specialization to which the 489 // member function specialization belongs is implicitly 490 // instantiated. 491 Diag(NewParam->getLocation(), diag::err_template_spec_default_arg) 492 << (New->getTemplateSpecializationKind() ==TSK_ExplicitSpecialization) 493 << New->getDeclName() 494 << NewParam->getDefaultArgRange(); 495 } else if (New->getDeclContext()->isDependentContext()) { 496 // C++ [dcl.fct.default]p6 (DR217): 497 // Default arguments for a member function of a class template shall 498 // be specified on the initial declaration of the member function 499 // within the class template. 500 // 501 // Reading the tea leaves a bit in DR217 and its reference to DR205 502 // leads me to the conclusion that one cannot add default function 503 // arguments for an out-of-line definition of a member function of a 504 // dependent type. 505 int WhichKind = 2; 506 if (CXXRecordDecl *Record 507 = dyn_cast<CXXRecordDecl>(New->getDeclContext())) { 508 if (Record->getDescribedClassTemplate()) 509 WhichKind = 0; 510 else if (isa<ClassTemplatePartialSpecializationDecl>(Record)) 511 WhichKind = 1; 512 else 513 WhichKind = 2; 514 } 515 516 Diag(NewParam->getLocation(), 517 diag::err_param_default_argument_member_template_redecl) 518 << WhichKind 519 << NewParam->getDefaultArgRange(); 520 } else if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(New)) { 521 CXXSpecialMember NewSM = getSpecialMember(Ctor), 522 OldSM = getSpecialMember(cast<CXXConstructorDecl>(Old)); 523 if (NewSM != OldSM) { 524 Diag(NewParam->getLocation(),diag::warn_default_arg_makes_ctor_special) 525 << NewParam->getDefaultArgRange() << NewSM; 526 Diag(Old->getLocation(), diag::note_previous_declaration_special) 527 << OldSM; 528 } 529 } 530 } 531 } 532 533 // C++11 [dcl.constexpr]p1: If any declaration of a function or function 534 // template has a constexpr specifier then all its declarations shall 535 // contain the constexpr specifier. 536 if (New->isConstexpr() != Old->isConstexpr()) { 537 Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch) 538 << New << New->isConstexpr(); 539 Diag(Old->getLocation(), diag::note_previous_declaration); 540 Invalid = true; 541 } 542 543 if (CheckEquivalentExceptionSpec(Old, New)) 544 Invalid = true; 545 546 return Invalid; 547} 548 549/// \brief Merge the exception specifications of two variable declarations. 550/// 551/// This is called when there's a redeclaration of a VarDecl. The function 552/// checks if the redeclaration might have an exception specification and 553/// validates compatibility and merges the specs if necessary. 554void Sema::MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old) { 555 // Shortcut if exceptions are disabled. 556 if (!getLangOpts().CXXExceptions) 557 return; 558 559 assert(Context.hasSameType(New->getType(), Old->getType()) && 560 "Should only be called if types are otherwise the same."); 561 562 QualType NewType = New->getType(); 563 QualType OldType = Old->getType(); 564 565 // We're only interested in pointers and references to functions, as well 566 // as pointers to member functions. 567 if (const ReferenceType *R = NewType->getAs<ReferenceType>()) { 568 NewType = R->getPointeeType(); 569 OldType = OldType->getAs<ReferenceType>()->getPointeeType(); 570 } else if (const PointerType *P = NewType->getAs<PointerType>()) { 571 NewType = P->getPointeeType(); 572 OldType = OldType->getAs<PointerType>()->getPointeeType(); 573 } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) { 574 NewType = M->getPointeeType(); 575 OldType = OldType->getAs<MemberPointerType>()->getPointeeType(); 576 } 577 578 if (!NewType->isFunctionProtoType()) 579 return; 580 581 // There's lots of special cases for functions. For function pointers, system 582 // libraries are hopefully not as broken so that we don't need these 583 // workarounds. 584 if (CheckEquivalentExceptionSpec( 585 OldType->getAs<FunctionProtoType>(), Old->getLocation(), 586 NewType->getAs<FunctionProtoType>(), New->getLocation())) { 587 New->setInvalidDecl(); 588 } 589} 590 591/// CheckCXXDefaultArguments - Verify that the default arguments for a 592/// function declaration are well-formed according to C++ 593/// [dcl.fct.default]. 594void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) { 595 unsigned NumParams = FD->getNumParams(); 596 unsigned p; 597 598 bool IsLambda = FD->getOverloadedOperator() == OO_Call && 599 isa<CXXMethodDecl>(FD) && 600 cast<CXXMethodDecl>(FD)->getParent()->isLambda(); 601 602 // Find first parameter with a default argument 603 for (p = 0; p < NumParams; ++p) { 604 ParmVarDecl *Param = FD->getParamDecl(p); 605 if (Param->hasDefaultArg()) { 606 // C++11 [expr.prim.lambda]p5: 607 // [...] Default arguments (8.3.6) shall not be specified in the 608 // parameter-declaration-clause of a lambda-declarator. 609 // 610 // FIXME: Core issue 974 strikes this sentence, we only provide an 611 // extension warning. 612 if (IsLambda) 613 Diag(Param->getLocation(), diag::ext_lambda_default_arguments) 614 << Param->getDefaultArgRange(); 615 break; 616 } 617 } 618 619 // C++ [dcl.fct.default]p4: 620 // In a given function declaration, all parameters 621 // subsequent to a parameter with a default argument shall 622 // have default arguments supplied in this or previous 623 // declarations. A default argument shall not be redefined 624 // by a later declaration (not even to the same value). 625 unsigned LastMissingDefaultArg = 0; 626 for (; p < NumParams; ++p) { 627 ParmVarDecl *Param = FD->getParamDecl(p); 628 if (!Param->hasDefaultArg()) { 629 if (Param->isInvalidDecl()) 630 /* We already complained about this parameter. */; 631 else if (Param->getIdentifier()) 632 Diag(Param->getLocation(), 633 diag::err_param_default_argument_missing_name) 634 << Param->getIdentifier(); 635 else 636 Diag(Param->getLocation(), 637 diag::err_param_default_argument_missing); 638 639 LastMissingDefaultArg = p; 640 } 641 } 642 643 if (LastMissingDefaultArg > 0) { 644 // Some default arguments were missing. Clear out all of the 645 // default arguments up to (and including) the last missing 646 // default argument, so that we leave the function parameters 647 // in a semantically valid state. 648 for (p = 0; p <= LastMissingDefaultArg; ++p) { 649 ParmVarDecl *Param = FD->getParamDecl(p); 650 if (Param->hasDefaultArg()) { 651 Param->setDefaultArg(0); 652 } 653 } 654 } 655} 656 657// CheckConstexprParameterTypes - Check whether a function's parameter types 658// are all literal types. If so, return true. If not, produce a suitable 659// diagnostic and return false. 660static bool CheckConstexprParameterTypes(Sema &SemaRef, 661 const FunctionDecl *FD) { 662 unsigned ArgIndex = 0; 663 const FunctionProtoType *FT = FD->getType()->getAs<FunctionProtoType>(); 664 for (FunctionProtoType::arg_type_iterator i = FT->arg_type_begin(), 665 e = FT->arg_type_end(); i != e; ++i, ++ArgIndex) { 666 const ParmVarDecl *PD = FD->getParamDecl(ArgIndex); 667 SourceLocation ParamLoc = PD->getLocation(); 668 if (!(*i)->isDependentType() && 669 SemaRef.RequireLiteralType(ParamLoc, *i, 670 diag::err_constexpr_non_literal_param, 671 ArgIndex+1, PD->getSourceRange(), 672 isa<CXXConstructorDecl>(FD))) 673 return false; 674 } 675 return true; 676} 677 678/// \brief Get diagnostic %select index for tag kind for 679/// record diagnostic message. 680/// WARNING: Indexes apply to particular diagnostics only! 681/// 682/// \returns diagnostic %select index. 683static unsigned getRecordDiagFromTagKind(TagTypeKind Tag) { 684 switch (Tag) { 685 case TTK_Struct: return 0; 686 case TTK_Interface: return 1; 687 case TTK_Class: return 2; 688 default: llvm_unreachable("Invalid tag kind for record diagnostic!"); 689 } 690} 691 692// CheckConstexprFunctionDecl - Check whether a function declaration satisfies 693// the requirements of a constexpr function definition or a constexpr 694// constructor definition. If so, return true. If not, produce appropriate 695// diagnostics and return false. 696// 697// This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360. 698bool Sema::CheckConstexprFunctionDecl(const FunctionDecl *NewFD) { 699 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 700 if (MD && MD->isInstance()) { 701 // C++11 [dcl.constexpr]p4: 702 // The definition of a constexpr constructor shall satisfy the following 703 // constraints: 704 // - the class shall not have any virtual base classes; 705 const CXXRecordDecl *RD = MD->getParent(); 706 if (RD->getNumVBases()) { 707 Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base) 708 << isa<CXXConstructorDecl>(NewFD) 709 << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getNumVBases(); 710 for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(), 711 E = RD->vbases_end(); I != E; ++I) 712 Diag(I->getLocStart(), 713 diag::note_constexpr_virtual_base_here) << I->getSourceRange(); 714 return false; 715 } 716 } 717 718 if (!isa<CXXConstructorDecl>(NewFD)) { 719 // C++11 [dcl.constexpr]p3: 720 // The definition of a constexpr function shall satisfy the following 721 // constraints: 722 // - it shall not be virtual; 723 const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD); 724 if (Method && Method->isVirtual()) { 725 Diag(NewFD->getLocation(), diag::err_constexpr_virtual); 726 727 // If it's not obvious why this function is virtual, find an overridden 728 // function which uses the 'virtual' keyword. 729 const CXXMethodDecl *WrittenVirtual = Method; 730 while (!WrittenVirtual->isVirtualAsWritten()) 731 WrittenVirtual = *WrittenVirtual->begin_overridden_methods(); 732 if (WrittenVirtual != Method) 733 Diag(WrittenVirtual->getLocation(), 734 diag::note_overridden_virtual_function); 735 return false; 736 } 737 738 // - its return type shall be a literal type; 739 QualType RT = NewFD->getResultType(); 740 if (!RT->isDependentType() && 741 RequireLiteralType(NewFD->getLocation(), RT, 742 diag::err_constexpr_non_literal_return)) 743 return false; 744 } 745 746 // - each of its parameter types shall be a literal type; 747 if (!CheckConstexprParameterTypes(*this, NewFD)) 748 return false; 749 750 return true; 751} 752 753/// Check the given declaration statement is legal within a constexpr function 754/// body. C++0x [dcl.constexpr]p3,p4. 755/// 756/// \return true if the body is OK, false if we have diagnosed a problem. 757static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl, 758 DeclStmt *DS) { 759 // C++0x [dcl.constexpr]p3 and p4: 760 // The definition of a constexpr function(p3) or constructor(p4) [...] shall 761 // contain only 762 for (DeclStmt::decl_iterator DclIt = DS->decl_begin(), 763 DclEnd = DS->decl_end(); DclIt != DclEnd; ++DclIt) { 764 switch ((*DclIt)->getKind()) { 765 case Decl::StaticAssert: 766 case Decl::Using: 767 case Decl::UsingShadow: 768 case Decl::UsingDirective: 769 case Decl::UnresolvedUsingTypename: 770 // - static_assert-declarations 771 // - using-declarations, 772 // - using-directives, 773 continue; 774 775 case Decl::Typedef: 776 case Decl::TypeAlias: { 777 // - typedef declarations and alias-declarations that do not define 778 // classes or enumerations, 779 TypedefNameDecl *TN = cast<TypedefNameDecl>(*DclIt); 780 if (TN->getUnderlyingType()->isVariablyModifiedType()) { 781 // Don't allow variably-modified types in constexpr functions. 782 TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc(); 783 SemaRef.Diag(TL.getBeginLoc(), diag::err_constexpr_vla) 784 << TL.getSourceRange() << TL.getType() 785 << isa<CXXConstructorDecl>(Dcl); 786 return false; 787 } 788 continue; 789 } 790 791 case Decl::Enum: 792 case Decl::CXXRecord: 793 // As an extension, we allow the declaration (but not the definition) of 794 // classes and enumerations in all declarations, not just in typedef and 795 // alias declarations. 796 if (cast<TagDecl>(*DclIt)->isThisDeclarationADefinition()) { 797 SemaRef.Diag(DS->getLocStart(), diag::err_constexpr_type_definition) 798 << isa<CXXConstructorDecl>(Dcl); 799 return false; 800 } 801 continue; 802 803 case Decl::Var: 804 SemaRef.Diag(DS->getLocStart(), diag::err_constexpr_var_declaration) 805 << isa<CXXConstructorDecl>(Dcl); 806 return false; 807 808 default: 809 SemaRef.Diag(DS->getLocStart(), diag::err_constexpr_body_invalid_stmt) 810 << isa<CXXConstructorDecl>(Dcl); 811 return false; 812 } 813 } 814 815 return true; 816} 817 818/// Check that the given field is initialized within a constexpr constructor. 819/// 820/// \param Dcl The constexpr constructor being checked. 821/// \param Field The field being checked. This may be a member of an anonymous 822/// struct or union nested within the class being checked. 823/// \param Inits All declarations, including anonymous struct/union members and 824/// indirect members, for which any initialization was provided. 825/// \param Diagnosed Set to true if an error is produced. 826static void CheckConstexprCtorInitializer(Sema &SemaRef, 827 const FunctionDecl *Dcl, 828 FieldDecl *Field, 829 llvm::SmallSet<Decl*, 16> &Inits, 830 bool &Diagnosed) { 831 if (Field->isUnnamedBitfield()) 832 return; 833 834 if (Field->isAnonymousStructOrUnion() && 835 Field->getType()->getAsCXXRecordDecl()->isEmpty()) 836 return; 837 838 if (!Inits.count(Field)) { 839 if (!Diagnosed) { 840 SemaRef.Diag(Dcl->getLocation(), diag::err_constexpr_ctor_missing_init); 841 Diagnosed = true; 842 } 843 SemaRef.Diag(Field->getLocation(), diag::note_constexpr_ctor_missing_init); 844 } else if (Field->isAnonymousStructOrUnion()) { 845 const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl(); 846 for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end(); 847 I != E; ++I) 848 // If an anonymous union contains an anonymous struct of which any member 849 // is initialized, all members must be initialized. 850 if (!RD->isUnion() || Inits.count(*I)) 851 CheckConstexprCtorInitializer(SemaRef, Dcl, *I, Inits, Diagnosed); 852 } 853} 854 855/// Check the body for the given constexpr function declaration only contains 856/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4. 857/// 858/// \return true if the body is OK, false if we have diagnosed a problem. 859bool Sema::CheckConstexprFunctionBody(const FunctionDecl *Dcl, Stmt *Body) { 860 if (isa<CXXTryStmt>(Body)) { 861 // C++11 [dcl.constexpr]p3: 862 // The definition of a constexpr function shall satisfy the following 863 // constraints: [...] 864 // - its function-body shall be = delete, = default, or a 865 // compound-statement 866 // 867 // C++11 [dcl.constexpr]p4: 868 // In the definition of a constexpr constructor, [...] 869 // - its function-body shall not be a function-try-block; 870 Diag(Body->getLocStart(), diag::err_constexpr_function_try_block) 871 << isa<CXXConstructorDecl>(Dcl); 872 return false; 873 } 874 875 // - its function-body shall be [...] a compound-statement that contains only 876 CompoundStmt *CompBody = cast<CompoundStmt>(Body); 877 878 llvm::SmallVector<SourceLocation, 4> ReturnStmts; 879 for (CompoundStmt::body_iterator BodyIt = CompBody->body_begin(), 880 BodyEnd = CompBody->body_end(); BodyIt != BodyEnd; ++BodyIt) { 881 switch ((*BodyIt)->getStmtClass()) { 882 case Stmt::NullStmtClass: 883 // - null statements, 884 continue; 885 886 case Stmt::DeclStmtClass: 887 // - static_assert-declarations 888 // - using-declarations, 889 // - using-directives, 890 // - typedef declarations and alias-declarations that do not define 891 // classes or enumerations, 892 if (!CheckConstexprDeclStmt(*this, Dcl, cast<DeclStmt>(*BodyIt))) 893 return false; 894 continue; 895 896 case Stmt::ReturnStmtClass: 897 // - and exactly one return statement; 898 if (isa<CXXConstructorDecl>(Dcl)) 899 break; 900 901 ReturnStmts.push_back((*BodyIt)->getLocStart()); 902 continue; 903 904 default: 905 break; 906 } 907 908 Diag((*BodyIt)->getLocStart(), diag::err_constexpr_body_invalid_stmt) 909 << isa<CXXConstructorDecl>(Dcl); 910 return false; 911 } 912 913 if (const CXXConstructorDecl *Constructor 914 = dyn_cast<CXXConstructorDecl>(Dcl)) { 915 const CXXRecordDecl *RD = Constructor->getParent(); 916 // DR1359: 917 // - every non-variant non-static data member and base class sub-object 918 // shall be initialized; 919 // - if the class is a non-empty union, or for each non-empty anonymous 920 // union member of a non-union class, exactly one non-static data member 921 // shall be initialized; 922 if (RD->isUnion()) { 923 if (Constructor->getNumCtorInitializers() == 0 && !RD->isEmpty()) { 924 Diag(Dcl->getLocation(), diag::err_constexpr_union_ctor_no_init); 925 return false; 926 } 927 } else if (!Constructor->isDependentContext() && 928 !Constructor->isDelegatingConstructor()) { 929 assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases"); 930 931 // Skip detailed checking if we have enough initializers, and we would 932 // allow at most one initializer per member. 933 bool AnyAnonStructUnionMembers = false; 934 unsigned Fields = 0; 935 for (CXXRecordDecl::field_iterator I = RD->field_begin(), 936 E = RD->field_end(); I != E; ++I, ++Fields) { 937 if (I->isAnonymousStructOrUnion()) { 938 AnyAnonStructUnionMembers = true; 939 break; 940 } 941 } 942 if (AnyAnonStructUnionMembers || 943 Constructor->getNumCtorInitializers() != RD->getNumBases() + Fields) { 944 // Check initialization of non-static data members. Base classes are 945 // always initialized so do not need to be checked. Dependent bases 946 // might not have initializers in the member initializer list. 947 llvm::SmallSet<Decl*, 16> Inits; 948 for (CXXConstructorDecl::init_const_iterator 949 I = Constructor->init_begin(), E = Constructor->init_end(); 950 I != E; ++I) { 951 if (FieldDecl *FD = (*I)->getMember()) 952 Inits.insert(FD); 953 else if (IndirectFieldDecl *ID = (*I)->getIndirectMember()) 954 Inits.insert(ID->chain_begin(), ID->chain_end()); 955 } 956 957 bool Diagnosed = false; 958 for (CXXRecordDecl::field_iterator I = RD->field_begin(), 959 E = RD->field_end(); I != E; ++I) 960 CheckConstexprCtorInitializer(*this, Dcl, *I, Inits, Diagnosed); 961 if (Diagnosed) 962 return false; 963 } 964 } 965 } else { 966 if (ReturnStmts.empty()) { 967 Diag(Dcl->getLocation(), diag::err_constexpr_body_no_return); 968 return false; 969 } 970 if (ReturnStmts.size() > 1) { 971 Diag(ReturnStmts.back(), diag::err_constexpr_body_multiple_return); 972 for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I) 973 Diag(ReturnStmts[I], diag::note_constexpr_body_previous_return); 974 return false; 975 } 976 } 977 978 // C++11 [dcl.constexpr]p5: 979 // if no function argument values exist such that the function invocation 980 // substitution would produce a constant expression, the program is 981 // ill-formed; no diagnostic required. 982 // C++11 [dcl.constexpr]p3: 983 // - every constructor call and implicit conversion used in initializing the 984 // return value shall be one of those allowed in a constant expression. 985 // C++11 [dcl.constexpr]p4: 986 // - every constructor involved in initializing non-static data members and 987 // base class sub-objects shall be a constexpr constructor. 988 llvm::SmallVector<PartialDiagnosticAt, 8> Diags; 989 if (!Expr::isPotentialConstantExpr(Dcl, Diags)) { 990 Diag(Dcl->getLocation(), diag::err_constexpr_function_never_constant_expr) 991 << isa<CXXConstructorDecl>(Dcl); 992 for (size_t I = 0, N = Diags.size(); I != N; ++I) 993 Diag(Diags[I].first, Diags[I].second); 994 return false; 995 } 996 997 return true; 998} 999 1000/// isCurrentClassName - Determine whether the identifier II is the 1001/// name of the class type currently being defined. In the case of 1002/// nested classes, this will only return true if II is the name of 1003/// the innermost class. 1004bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *, 1005 const CXXScopeSpec *SS) { 1006 assert(getLangOpts().CPlusPlus && "No class names in C!"); 1007 1008 CXXRecordDecl *CurDecl; 1009 if (SS && SS->isSet() && !SS->isInvalid()) { 1010 DeclContext *DC = computeDeclContext(*SS, true); 1011 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC); 1012 } else 1013 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext); 1014 1015 if (CurDecl && CurDecl->getIdentifier()) 1016 return &II == CurDecl->getIdentifier(); 1017 else 1018 return false; 1019} 1020 1021/// \brief Determine whether the given class is a base class of the given 1022/// class, including looking at dependent bases. 1023static bool findCircularInheritance(const CXXRecordDecl *Class, 1024 const CXXRecordDecl *Current) { 1025 SmallVector<const CXXRecordDecl*, 8> Queue; 1026 1027 Class = Class->getCanonicalDecl(); 1028 while (true) { 1029 for (CXXRecordDecl::base_class_const_iterator I = Current->bases_begin(), 1030 E = Current->bases_end(); 1031 I != E; ++I) { 1032 CXXRecordDecl *Base = I->getType()->getAsCXXRecordDecl(); 1033 if (!Base) 1034 continue; 1035 1036 Base = Base->getDefinition(); 1037 if (!Base) 1038 continue; 1039 1040 if (Base->getCanonicalDecl() == Class) 1041 return true; 1042 1043 Queue.push_back(Base); 1044 } 1045 1046 if (Queue.empty()) 1047 return false; 1048 1049 Current = Queue.back(); 1050 Queue.pop_back(); 1051 } 1052 1053 return false; 1054} 1055 1056/// \brief Check the validity of a C++ base class specifier. 1057/// 1058/// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics 1059/// and returns NULL otherwise. 1060CXXBaseSpecifier * 1061Sema::CheckBaseSpecifier(CXXRecordDecl *Class, 1062 SourceRange SpecifierRange, 1063 bool Virtual, AccessSpecifier Access, 1064 TypeSourceInfo *TInfo, 1065 SourceLocation EllipsisLoc) { 1066 QualType BaseType = TInfo->getType(); 1067 1068 // C++ [class.union]p1: 1069 // A union shall not have base classes. 1070 if (Class->isUnion()) { 1071 Diag(Class->getLocation(), diag::err_base_clause_on_union) 1072 << SpecifierRange; 1073 return 0; 1074 } 1075 1076 if (EllipsisLoc.isValid() && 1077 !TInfo->getType()->containsUnexpandedParameterPack()) { 1078 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) 1079 << TInfo->getTypeLoc().getSourceRange(); 1080 EllipsisLoc = SourceLocation(); 1081 } 1082 1083 SourceLocation BaseLoc = TInfo->getTypeLoc().getBeginLoc(); 1084 1085 if (BaseType->isDependentType()) { 1086 // Make sure that we don't have circular inheritance among our dependent 1087 // bases. For non-dependent bases, the check for completeness below handles 1088 // this. 1089 if (CXXRecordDecl *BaseDecl = BaseType->getAsCXXRecordDecl()) { 1090 if (BaseDecl->getCanonicalDecl() == Class->getCanonicalDecl() || 1091 ((BaseDecl = BaseDecl->getDefinition()) && 1092 findCircularInheritance(Class, BaseDecl))) { 1093 Diag(BaseLoc, diag::err_circular_inheritance) 1094 << BaseType << Context.getTypeDeclType(Class); 1095 1096 if (BaseDecl->getCanonicalDecl() != Class->getCanonicalDecl()) 1097 Diag(BaseDecl->getLocation(), diag::note_previous_decl) 1098 << BaseType; 1099 1100 return 0; 1101 } 1102 } 1103 1104 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual, 1105 Class->getTagKind() == TTK_Class, 1106 Access, TInfo, EllipsisLoc); 1107 } 1108 1109 // Base specifiers must be record types. 1110 if (!BaseType->isRecordType()) { 1111 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange; 1112 return 0; 1113 } 1114 1115 // C++ [class.union]p1: 1116 // A union shall not be used as a base class. 1117 if (BaseType->isUnionType()) { 1118 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange; 1119 return 0; 1120 } 1121 1122 // C++ [class.derived]p2: 1123 // The class-name in a base-specifier shall not be an incompletely 1124 // defined class. 1125 if (RequireCompleteType(BaseLoc, BaseType, 1126 diag::err_incomplete_base_class, SpecifierRange)) { 1127 Class->setInvalidDecl(); 1128 return 0; 1129 } 1130 1131 // If the base class is polymorphic or isn't empty, the new one is/isn't, too. 1132 RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl(); 1133 assert(BaseDecl && "Record type has no declaration"); 1134 BaseDecl = BaseDecl->getDefinition(); 1135 assert(BaseDecl && "Base type is not incomplete, but has no definition"); 1136 CXXRecordDecl * CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl); 1137 assert(CXXBaseDecl && "Base type is not a C++ type"); 1138 1139 // C++ [class]p3: 1140 // If a class is marked final and it appears as a base-type-specifier in 1141 // base-clause, the program is ill-formed. 1142 if (CXXBaseDecl->hasAttr<FinalAttr>()) { 1143 Diag(BaseLoc, diag::err_class_marked_final_used_as_base) 1144 << CXXBaseDecl->getDeclName(); 1145 Diag(CXXBaseDecl->getLocation(), diag::note_previous_decl) 1146 << CXXBaseDecl->getDeclName(); 1147 return 0; 1148 } 1149 1150 if (BaseDecl->isInvalidDecl()) 1151 Class->setInvalidDecl(); 1152 1153 // Create the base specifier. 1154 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual, 1155 Class->getTagKind() == TTK_Class, 1156 Access, TInfo, EllipsisLoc); 1157} 1158 1159/// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is 1160/// one entry in the base class list of a class specifier, for 1161/// example: 1162/// class foo : public bar, virtual private baz { 1163/// 'public bar' and 'virtual private baz' are each base-specifiers. 1164BaseResult 1165Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange, 1166 bool Virtual, AccessSpecifier Access, 1167 ParsedType basetype, SourceLocation BaseLoc, 1168 SourceLocation EllipsisLoc) { 1169 if (!classdecl) 1170 return true; 1171 1172 AdjustDeclIfTemplate(classdecl); 1173 CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl); 1174 if (!Class) 1175 return true; 1176 1177 TypeSourceInfo *TInfo = 0; 1178 GetTypeFromParser(basetype, &TInfo); 1179 1180 if (EllipsisLoc.isInvalid() && 1181 DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo, 1182 UPPC_BaseType)) 1183 return true; 1184 1185 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange, 1186 Virtual, Access, TInfo, 1187 EllipsisLoc)) 1188 return BaseSpec; 1189 else 1190 Class->setInvalidDecl(); 1191 1192 return true; 1193} 1194 1195/// \brief Performs the actual work of attaching the given base class 1196/// specifiers to a C++ class. 1197bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases, 1198 unsigned NumBases) { 1199 if (NumBases == 0) 1200 return false; 1201 1202 // Used to keep track of which base types we have already seen, so 1203 // that we can properly diagnose redundant direct base types. Note 1204 // that the key is always the unqualified canonical type of the base 1205 // class. 1206 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes; 1207 1208 // Copy non-redundant base specifiers into permanent storage. 1209 unsigned NumGoodBases = 0; 1210 bool Invalid = false; 1211 for (unsigned idx = 0; idx < NumBases; ++idx) { 1212 QualType NewBaseType 1213 = Context.getCanonicalType(Bases[idx]->getType()); 1214 NewBaseType = NewBaseType.getLocalUnqualifiedType(); 1215 1216 CXXBaseSpecifier *&KnownBase = KnownBaseTypes[NewBaseType]; 1217 if (KnownBase) { 1218 // C++ [class.mi]p3: 1219 // A class shall not be specified as a direct base class of a 1220 // derived class more than once. 1221 Diag(Bases[idx]->getLocStart(), 1222 diag::err_duplicate_base_class) 1223 << KnownBase->getType() 1224 << Bases[idx]->getSourceRange(); 1225 1226 // Delete the duplicate base class specifier; we're going to 1227 // overwrite its pointer later. 1228 Context.Deallocate(Bases[idx]); 1229 1230 Invalid = true; 1231 } else { 1232 // Okay, add this new base class. 1233 KnownBase = Bases[idx]; 1234 Bases[NumGoodBases++] = Bases[idx]; 1235 if (const RecordType *Record = NewBaseType->getAs<RecordType>()) { 1236 const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); 1237 if (Class->isInterface() && 1238 (!RD->isInterface() || 1239 KnownBase->getAccessSpecifier() != AS_public)) { 1240 // The Microsoft extension __interface does not permit bases that 1241 // are not themselves public interfaces. 1242 Diag(KnownBase->getLocStart(), diag::err_invalid_base_in_interface) 1243 << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getName() 1244 << RD->getSourceRange(); 1245 Invalid = true; 1246 } 1247 if (RD->hasAttr<WeakAttr>()) 1248 Class->addAttr(::new (Context) WeakAttr(SourceRange(), Context)); 1249 } 1250 } 1251 } 1252 1253 // Attach the remaining base class specifiers to the derived class. 1254 Class->setBases(Bases, NumGoodBases); 1255 1256 // Delete the remaining (good) base class specifiers, since their 1257 // data has been copied into the CXXRecordDecl. 1258 for (unsigned idx = 0; idx < NumGoodBases; ++idx) 1259 Context.Deallocate(Bases[idx]); 1260 1261 return Invalid; 1262} 1263 1264/// ActOnBaseSpecifiers - Attach the given base specifiers to the 1265/// class, after checking whether there are any duplicate base 1266/// classes. 1267void Sema::ActOnBaseSpecifiers(Decl *ClassDecl, CXXBaseSpecifier **Bases, 1268 unsigned NumBases) { 1269 if (!ClassDecl || !Bases || !NumBases) 1270 return; 1271 1272 AdjustDeclIfTemplate(ClassDecl); 1273 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), 1274 (CXXBaseSpecifier**)(Bases), NumBases); 1275} 1276 1277static CXXRecordDecl *GetClassForType(QualType T) { 1278 if (const RecordType *RT = T->getAs<RecordType>()) 1279 return cast<CXXRecordDecl>(RT->getDecl()); 1280 else if (const InjectedClassNameType *ICT = T->getAs<InjectedClassNameType>()) 1281 return ICT->getDecl(); 1282 else 1283 return 0; 1284} 1285 1286/// \brief Determine whether the type \p Derived is a C++ class that is 1287/// derived from the type \p Base. 1288bool Sema::IsDerivedFrom(QualType Derived, QualType Base) { 1289 if (!getLangOpts().CPlusPlus) 1290 return false; 1291 1292 CXXRecordDecl *DerivedRD = GetClassForType(Derived); 1293 if (!DerivedRD) 1294 return false; 1295 1296 CXXRecordDecl *BaseRD = GetClassForType(Base); 1297 if (!BaseRD) 1298 return false; 1299 1300 // FIXME: instantiate DerivedRD if necessary. We need a PoI for this. 1301 return DerivedRD->hasDefinition() && DerivedRD->isDerivedFrom(BaseRD); 1302} 1303 1304/// \brief Determine whether the type \p Derived is a C++ class that is 1305/// derived from the type \p Base. 1306bool Sema::IsDerivedFrom(QualType Derived, QualType Base, CXXBasePaths &Paths) { 1307 if (!getLangOpts().CPlusPlus) 1308 return false; 1309 1310 CXXRecordDecl *DerivedRD = GetClassForType(Derived); 1311 if (!DerivedRD) 1312 return false; 1313 1314 CXXRecordDecl *BaseRD = GetClassForType(Base); 1315 if (!BaseRD) 1316 return false; 1317 1318 return DerivedRD->isDerivedFrom(BaseRD, Paths); 1319} 1320 1321void Sema::BuildBasePathArray(const CXXBasePaths &Paths, 1322 CXXCastPath &BasePathArray) { 1323 assert(BasePathArray.empty() && "Base path array must be empty!"); 1324 assert(Paths.isRecordingPaths() && "Must record paths!"); 1325 1326 const CXXBasePath &Path = Paths.front(); 1327 1328 // We first go backward and check if we have a virtual base. 1329 // FIXME: It would be better if CXXBasePath had the base specifier for 1330 // the nearest virtual base. 1331 unsigned Start = 0; 1332 for (unsigned I = Path.size(); I != 0; --I) { 1333 if (Path[I - 1].Base->isVirtual()) { 1334 Start = I - 1; 1335 break; 1336 } 1337 } 1338 1339 // Now add all bases. 1340 for (unsigned I = Start, E = Path.size(); I != E; ++I) 1341 BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base)); 1342} 1343 1344/// \brief Determine whether the given base path includes a virtual 1345/// base class. 1346bool Sema::BasePathInvolvesVirtualBase(const CXXCastPath &BasePath) { 1347 for (CXXCastPath::const_iterator B = BasePath.begin(), 1348 BEnd = BasePath.end(); 1349 B != BEnd; ++B) 1350 if ((*B)->isVirtual()) 1351 return true; 1352 1353 return false; 1354} 1355 1356/// CheckDerivedToBaseConversion - Check whether the Derived-to-Base 1357/// conversion (where Derived and Base are class types) is 1358/// well-formed, meaning that the conversion is unambiguous (and 1359/// that all of the base classes are accessible). Returns true 1360/// and emits a diagnostic if the code is ill-formed, returns false 1361/// otherwise. Loc is the location where this routine should point to 1362/// if there is an error, and Range is the source range to highlight 1363/// if there is an error. 1364bool 1365Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base, 1366 unsigned InaccessibleBaseID, 1367 unsigned AmbigiousBaseConvID, 1368 SourceLocation Loc, SourceRange Range, 1369 DeclarationName Name, 1370 CXXCastPath *BasePath) { 1371 // First, determine whether the path from Derived to Base is 1372 // ambiguous. This is slightly more expensive than checking whether 1373 // the Derived to Base conversion exists, because here we need to 1374 // explore multiple paths to determine if there is an ambiguity. 1375 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 1376 /*DetectVirtual=*/false); 1377 bool DerivationOkay = IsDerivedFrom(Derived, Base, Paths); 1378 assert(DerivationOkay && 1379 "Can only be used with a derived-to-base conversion"); 1380 (void)DerivationOkay; 1381 1382 if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType())) { 1383 if (InaccessibleBaseID) { 1384 // Check that the base class can be accessed. 1385 switch (CheckBaseClassAccess(Loc, Base, Derived, Paths.front(), 1386 InaccessibleBaseID)) { 1387 case AR_inaccessible: 1388 return true; 1389 case AR_accessible: 1390 case AR_dependent: 1391 case AR_delayed: 1392 break; 1393 } 1394 } 1395 1396 // Build a base path if necessary. 1397 if (BasePath) 1398 BuildBasePathArray(Paths, *BasePath); 1399 return false; 1400 } 1401 1402 // We know that the derived-to-base conversion is ambiguous, and 1403 // we're going to produce a diagnostic. Perform the derived-to-base 1404 // search just one more time to compute all of the possible paths so 1405 // that we can print them out. This is more expensive than any of 1406 // the previous derived-to-base checks we've done, but at this point 1407 // performance isn't as much of an issue. 1408 Paths.clear(); 1409 Paths.setRecordingPaths(true); 1410 bool StillOkay = IsDerivedFrom(Derived, Base, Paths); 1411 assert(StillOkay && "Can only be used with a derived-to-base conversion"); 1412 (void)StillOkay; 1413 1414 // Build up a textual representation of the ambiguous paths, e.g., 1415 // D -> B -> A, that will be used to illustrate the ambiguous 1416 // conversions in the diagnostic. We only print one of the paths 1417 // to each base class subobject. 1418 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths); 1419 1420 Diag(Loc, AmbigiousBaseConvID) 1421 << Derived << Base << PathDisplayStr << Range << Name; 1422 return true; 1423} 1424 1425bool 1426Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base, 1427 SourceLocation Loc, SourceRange Range, 1428 CXXCastPath *BasePath, 1429 bool IgnoreAccess) { 1430 return CheckDerivedToBaseConversion(Derived, Base, 1431 IgnoreAccess ? 0 1432 : diag::err_upcast_to_inaccessible_base, 1433 diag::err_ambiguous_derived_to_base_conv, 1434 Loc, Range, DeclarationName(), 1435 BasePath); 1436} 1437 1438 1439/// @brief Builds a string representing ambiguous paths from a 1440/// specific derived class to different subobjects of the same base 1441/// class. 1442/// 1443/// This function builds a string that can be used in error messages 1444/// to show the different paths that one can take through the 1445/// inheritance hierarchy to go from the derived class to different 1446/// subobjects of a base class. The result looks something like this: 1447/// @code 1448/// struct D -> struct B -> struct A 1449/// struct D -> struct C -> struct A 1450/// @endcode 1451std::string Sema::getAmbiguousPathsDisplayString(CXXBasePaths &Paths) { 1452 std::string PathDisplayStr; 1453 std::set<unsigned> DisplayedPaths; 1454 for (CXXBasePaths::paths_iterator Path = Paths.begin(); 1455 Path != Paths.end(); ++Path) { 1456 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) { 1457 // We haven't displayed a path to this particular base 1458 // class subobject yet. 1459 PathDisplayStr += "\n "; 1460 PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString(); 1461 for (CXXBasePath::const_iterator Element = Path->begin(); 1462 Element != Path->end(); ++Element) 1463 PathDisplayStr += " -> " + Element->Base->getType().getAsString(); 1464 } 1465 } 1466 1467 return PathDisplayStr; 1468} 1469 1470//===----------------------------------------------------------------------===// 1471// C++ class member Handling 1472//===----------------------------------------------------------------------===// 1473 1474/// ActOnAccessSpecifier - Parsed an access specifier followed by a colon. 1475bool Sema::ActOnAccessSpecifier(AccessSpecifier Access, 1476 SourceLocation ASLoc, 1477 SourceLocation ColonLoc, 1478 AttributeList *Attrs) { 1479 assert(Access != AS_none && "Invalid kind for syntactic access specifier!"); 1480 AccessSpecDecl *ASDecl = AccessSpecDecl::Create(Context, Access, CurContext, 1481 ASLoc, ColonLoc); 1482 CurContext->addHiddenDecl(ASDecl); 1483 return ProcessAccessDeclAttributeList(ASDecl, Attrs); 1484} 1485 1486/// CheckOverrideControl - Check C++11 override control semantics. 1487void Sema::CheckOverrideControl(Decl *D) { 1488 if (D->isInvalidDecl()) 1489 return; 1490 1491 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D); 1492 1493 // Do we know which functions this declaration might be overriding? 1494 bool OverridesAreKnown = !MD || 1495 (!MD->getParent()->hasAnyDependentBases() && 1496 !MD->getType()->isDependentType()); 1497 1498 if (!MD || !MD->isVirtual()) { 1499 if (OverridesAreKnown) { 1500 if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) { 1501 Diag(OA->getLocation(), 1502 diag::override_keyword_only_allowed_on_virtual_member_functions) 1503 << "override" << FixItHint::CreateRemoval(OA->getLocation()); 1504 D->dropAttr<OverrideAttr>(); 1505 } 1506 if (FinalAttr *FA = D->getAttr<FinalAttr>()) { 1507 Diag(FA->getLocation(), 1508 diag::override_keyword_only_allowed_on_virtual_member_functions) 1509 << "final" << FixItHint::CreateRemoval(FA->getLocation()); 1510 D->dropAttr<FinalAttr>(); 1511 } 1512 } 1513 return; 1514 } 1515 1516 if (!OverridesAreKnown) 1517 return; 1518 1519 // C++11 [class.virtual]p5: 1520 // If a virtual function is marked with the virt-specifier override and 1521 // does not override a member function of a base class, the program is 1522 // ill-formed. 1523 bool HasOverriddenMethods = 1524 MD->begin_overridden_methods() != MD->end_overridden_methods(); 1525 if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods) 1526 Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding) 1527 << MD->getDeclName(); 1528} 1529 1530/// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member 1531/// function overrides a virtual member function marked 'final', according to 1532/// C++11 [class.virtual]p4. 1533bool Sema::CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, 1534 const CXXMethodDecl *Old) { 1535 if (!Old->hasAttr<FinalAttr>()) 1536 return false; 1537 1538 Diag(New->getLocation(), diag::err_final_function_overridden) 1539 << New->getDeclName(); 1540 Diag(Old->getLocation(), diag::note_overridden_virtual_function); 1541 return true; 1542} 1543 1544static bool InitializationHasSideEffects(const FieldDecl &FD) { 1545 const Type *T = FD.getType()->getBaseElementTypeUnsafe(); 1546 // FIXME: Destruction of ObjC lifetime types has side-effects. 1547 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 1548 return !RD->isCompleteDefinition() || 1549 !RD->hasTrivialDefaultConstructor() || 1550 !RD->hasTrivialDestructor(); 1551 return false; 1552} 1553 1554/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member 1555/// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the 1556/// bitfield width if there is one, 'InitExpr' specifies the initializer if 1557/// one has been parsed, and 'InitStyle' is set if an in-class initializer is 1558/// present (but parsing it has been deferred). 1559Decl * 1560Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D, 1561 MultiTemplateParamsArg TemplateParameterLists, 1562 Expr *BW, const VirtSpecifiers &VS, 1563 InClassInitStyle InitStyle) { 1564 const DeclSpec &DS = D.getDeclSpec(); 1565 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 1566 DeclarationName Name = NameInfo.getName(); 1567 SourceLocation Loc = NameInfo.getLoc(); 1568 1569 // For anonymous bitfields, the location should point to the type. 1570 if (Loc.isInvalid()) 1571 Loc = D.getLocStart(); 1572 1573 Expr *BitWidth = static_cast<Expr*>(BW); 1574 1575 assert(isa<CXXRecordDecl>(CurContext)); 1576 assert(!DS.isFriendSpecified()); 1577 1578 bool isFunc = D.isDeclarationOfFunction(); 1579 1580 if (cast<CXXRecordDecl>(CurContext)->isInterface()) { 1581 // The Microsoft extension __interface only permits public member functions 1582 // and prohibits constructors, destructors, operators, non-public member 1583 // functions, static methods and data members. 1584 unsigned InvalidDecl; 1585 bool ShowDeclName = true; 1586 if (!isFunc) 1587 InvalidDecl = (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) ? 0 : 1; 1588 else if (AS != AS_public) 1589 InvalidDecl = 2; 1590 else if (DS.getStorageClassSpec() == DeclSpec::SCS_static) 1591 InvalidDecl = 3; 1592 else switch (Name.getNameKind()) { 1593 case DeclarationName::CXXConstructorName: 1594 InvalidDecl = 4; 1595 ShowDeclName = false; 1596 break; 1597 1598 case DeclarationName::CXXDestructorName: 1599 InvalidDecl = 5; 1600 ShowDeclName = false; 1601 break; 1602 1603 case DeclarationName::CXXOperatorName: 1604 case DeclarationName::CXXConversionFunctionName: 1605 InvalidDecl = 6; 1606 break; 1607 1608 default: 1609 InvalidDecl = 0; 1610 break; 1611 } 1612 1613 if (InvalidDecl) { 1614 if (ShowDeclName) 1615 Diag(Loc, diag::err_invalid_member_in_interface) 1616 << (InvalidDecl-1) << Name; 1617 else 1618 Diag(Loc, diag::err_invalid_member_in_interface) 1619 << (InvalidDecl-1) << ""; 1620 return 0; 1621 } 1622 } 1623 1624 // C++ 9.2p6: A member shall not be declared to have automatic storage 1625 // duration (auto, register) or with the extern storage-class-specifier. 1626 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class 1627 // data members and cannot be applied to names declared const or static, 1628 // and cannot be applied to reference members. 1629 switch (DS.getStorageClassSpec()) { 1630 case DeclSpec::SCS_unspecified: 1631 case DeclSpec::SCS_typedef: 1632 case DeclSpec::SCS_static: 1633 // FALL THROUGH. 1634 break; 1635 case DeclSpec::SCS_mutable: 1636 if (isFunc) { 1637 if (DS.getStorageClassSpecLoc().isValid()) 1638 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function); 1639 else 1640 Diag(DS.getThreadSpecLoc(), diag::err_mutable_function); 1641 1642 // FIXME: It would be nicer if the keyword was ignored only for this 1643 // declarator. Otherwise we could get follow-up errors. 1644 D.getMutableDeclSpec().ClearStorageClassSpecs(); 1645 } 1646 break; 1647 default: 1648 if (DS.getStorageClassSpecLoc().isValid()) 1649 Diag(DS.getStorageClassSpecLoc(), 1650 diag::err_storageclass_invalid_for_member); 1651 else 1652 Diag(DS.getThreadSpecLoc(), diag::err_storageclass_invalid_for_member); 1653 D.getMutableDeclSpec().ClearStorageClassSpecs(); 1654 } 1655 1656 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified || 1657 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) && 1658 !isFunc); 1659 1660 Decl *Member; 1661 if (isInstField) { 1662 CXXScopeSpec &SS = D.getCXXScopeSpec(); 1663 1664 // Data members must have identifiers for names. 1665 if (!Name.isIdentifier()) { 1666 Diag(Loc, diag::err_bad_variable_name) 1667 << Name; 1668 return 0; 1669 } 1670 1671 IdentifierInfo *II = Name.getAsIdentifierInfo(); 1672 1673 // Member field could not be with "template" keyword. 1674 // So TemplateParameterLists should be empty in this case. 1675 if (TemplateParameterLists.size()) { 1676 TemplateParameterList* TemplateParams = TemplateParameterLists[0]; 1677 if (TemplateParams->size()) { 1678 // There is no such thing as a member field template. 1679 Diag(D.getIdentifierLoc(), diag::err_template_member) 1680 << II 1681 << SourceRange(TemplateParams->getTemplateLoc(), 1682 TemplateParams->getRAngleLoc()); 1683 } else { 1684 // There is an extraneous 'template<>' for this member. 1685 Diag(TemplateParams->getTemplateLoc(), 1686 diag::err_template_member_noparams) 1687 << II 1688 << SourceRange(TemplateParams->getTemplateLoc(), 1689 TemplateParams->getRAngleLoc()); 1690 } 1691 return 0; 1692 } 1693 1694 if (SS.isSet() && !SS.isInvalid()) { 1695 // The user provided a superfluous scope specifier inside a class 1696 // definition: 1697 // 1698 // class X { 1699 // int X::member; 1700 // }; 1701 if (DeclContext *DC = computeDeclContext(SS, false)) 1702 diagnoseQualifiedDeclaration(SS, DC, Name, D.getIdentifierLoc()); 1703 else 1704 Diag(D.getIdentifierLoc(), diag::err_member_qualification) 1705 << Name << SS.getRange(); 1706 1707 SS.clear(); 1708 } 1709 1710 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D, BitWidth, 1711 InitStyle, AS); 1712 assert(Member && "HandleField never returns null"); 1713 } else { 1714 assert(InitStyle == ICIS_NoInit); 1715 1716 Member = HandleDeclarator(S, D, TemplateParameterLists); 1717 if (!Member) { 1718 return 0; 1719 } 1720 1721 // Non-instance-fields can't have a bitfield. 1722 if (BitWidth) { 1723 if (Member->isInvalidDecl()) { 1724 // don't emit another diagnostic. 1725 } else if (isa<VarDecl>(Member)) { 1726 // C++ 9.6p3: A bit-field shall not be a static member. 1727 // "static member 'A' cannot be a bit-field" 1728 Diag(Loc, diag::err_static_not_bitfield) 1729 << Name << BitWidth->getSourceRange(); 1730 } else if (isa<TypedefDecl>(Member)) { 1731 // "typedef member 'x' cannot be a bit-field" 1732 Diag(Loc, diag::err_typedef_not_bitfield) 1733 << Name << BitWidth->getSourceRange(); 1734 } else { 1735 // A function typedef ("typedef int f(); f a;"). 1736 // C++ 9.6p3: A bit-field shall have integral or enumeration type. 1737 Diag(Loc, diag::err_not_integral_type_bitfield) 1738 << Name << cast<ValueDecl>(Member)->getType() 1739 << BitWidth->getSourceRange(); 1740 } 1741 1742 BitWidth = 0; 1743 Member->setInvalidDecl(); 1744 } 1745 1746 Member->setAccess(AS); 1747 1748 // If we have declared a member function template, set the access of the 1749 // templated declaration as well. 1750 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member)) 1751 FunTmpl->getTemplatedDecl()->setAccess(AS); 1752 } 1753 1754 if (VS.isOverrideSpecified()) 1755 Member->addAttr(new (Context) OverrideAttr(VS.getOverrideLoc(), Context)); 1756 if (VS.isFinalSpecified()) 1757 Member->addAttr(new (Context) FinalAttr(VS.getFinalLoc(), Context)); 1758 1759 if (VS.getLastLocation().isValid()) { 1760 // Update the end location of a method that has a virt-specifiers. 1761 if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member)) 1762 MD->setRangeEnd(VS.getLastLocation()); 1763 } 1764 1765 CheckOverrideControl(Member); 1766 1767 assert((Name || isInstField) && "No identifier for non-field ?"); 1768 1769 if (isInstField) { 1770 FieldDecl *FD = cast<FieldDecl>(Member); 1771 FieldCollector->Add(FD); 1772 1773 if (Diags.getDiagnosticLevel(diag::warn_unused_private_field, 1774 FD->getLocation()) 1775 != DiagnosticsEngine::Ignored) { 1776 // Remember all explicit private FieldDecls that have a name, no side 1777 // effects and are not part of a dependent type declaration. 1778 if (!FD->isImplicit() && FD->getDeclName() && 1779 FD->getAccess() == AS_private && 1780 !FD->hasAttr<UnusedAttr>() && 1781 !FD->getParent()->isDependentContext() && 1782 !InitializationHasSideEffects(*FD)) 1783 UnusedPrivateFields.insert(FD); 1784 } 1785 } 1786 1787 return Member; 1788} 1789 1790namespace { 1791 class UninitializedFieldVisitor 1792 : public EvaluatedExprVisitor<UninitializedFieldVisitor> { 1793 Sema &S; 1794 ValueDecl *VD; 1795 public: 1796 typedef EvaluatedExprVisitor<UninitializedFieldVisitor> Inherited; 1797 UninitializedFieldVisitor(Sema &S, ValueDecl *VD) : Inherited(S.Context), 1798 S(S), VD(VD) { 1799 } 1800 1801 void HandleExpr(Expr *E) { 1802 if (!E) return; 1803 1804 // Expressions like x(x) sometimes lack the surrounding expressions 1805 // but need to be checked anyways. 1806 HandleValue(E); 1807 Visit(E); 1808 } 1809 1810 void HandleValue(Expr *E) { 1811 E = E->IgnoreParens(); 1812 1813 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 1814 if (isa<EnumConstantDecl>(ME->getMemberDecl())) 1815 return; 1816 Expr *Base = E; 1817 while (isa<MemberExpr>(Base)) { 1818 ME = dyn_cast<MemberExpr>(Base); 1819 if (VarDecl *VarD = dyn_cast<VarDecl>(ME->getMemberDecl())) 1820 if (VarD->hasGlobalStorage()) 1821 return; 1822 Base = ME->getBase(); 1823 } 1824 1825 if (VD == ME->getMemberDecl() && isa<CXXThisExpr>(Base)) { 1826 unsigned diag = VD->getType()->isReferenceType() 1827 ? diag::warn_reference_field_is_uninit 1828 : diag::warn_field_is_uninit; 1829 S.Diag(ME->getExprLoc(), diag) << ME->getMemberNameInfo().getName(); 1830 return; 1831 } 1832 } 1833 1834 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 1835 HandleValue(CO->getTrueExpr()); 1836 HandleValue(CO->getFalseExpr()); 1837 return; 1838 } 1839 1840 if (BinaryConditionalOperator *BCO = 1841 dyn_cast<BinaryConditionalOperator>(E)) { 1842 HandleValue(BCO->getCommon()); 1843 HandleValue(BCO->getFalseExpr()); 1844 return; 1845 } 1846 1847 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 1848 switch (BO->getOpcode()) { 1849 default: 1850 return; 1851 case(BO_PtrMemD): 1852 case(BO_PtrMemI): 1853 HandleValue(BO->getLHS()); 1854 return; 1855 case(BO_Comma): 1856 HandleValue(BO->getRHS()); 1857 return; 1858 } 1859 } 1860 } 1861 1862 void VisitImplicitCastExpr(ImplicitCastExpr *E) { 1863 if (E->getCastKind() == CK_LValueToRValue) 1864 HandleValue(E->getSubExpr()); 1865 1866 Inherited::VisitImplicitCastExpr(E); 1867 } 1868 1869 void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 1870 Expr *Callee = E->getCallee(); 1871 if (isa<MemberExpr>(Callee)) 1872 HandleValue(Callee); 1873 1874 Inherited::VisitCXXMemberCallExpr(E); 1875 } 1876 }; 1877 static void CheckInitExprContainsUninitializedFields(Sema &S, Expr *E, 1878 ValueDecl *VD) { 1879 UninitializedFieldVisitor(S, VD).HandleExpr(E); 1880 } 1881} // namespace 1882 1883/// ActOnCXXInClassMemberInitializer - This is invoked after parsing an 1884/// in-class initializer for a non-static C++ class member, and after 1885/// instantiating an in-class initializer in a class template. Such actions 1886/// are deferred until the class is complete. 1887void 1888Sema::ActOnCXXInClassMemberInitializer(Decl *D, SourceLocation InitLoc, 1889 Expr *InitExpr) { 1890 FieldDecl *FD = cast<FieldDecl>(D); 1891 assert(FD->getInClassInitStyle() != ICIS_NoInit && 1892 "must set init style when field is created"); 1893 1894 if (!InitExpr) { 1895 FD->setInvalidDecl(); 1896 FD->removeInClassInitializer(); 1897 return; 1898 } 1899 1900 if (DiagnoseUnexpandedParameterPack(InitExpr, UPPC_Initializer)) { 1901 FD->setInvalidDecl(); 1902 FD->removeInClassInitializer(); 1903 return; 1904 } 1905 1906 if (getDiagnostics().getDiagnosticLevel(diag::warn_field_is_uninit, InitLoc) 1907 != DiagnosticsEngine::Ignored) { 1908 CheckInitExprContainsUninitializedFields(*this, InitExpr, FD); 1909 } 1910 1911 ExprResult Init = InitExpr; 1912 if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent() && 1913 !FD->getDeclContext()->isDependentContext()) { 1914 // Note: We don't type-check when we're in a dependent context, because 1915 // the initialization-substitution code does not properly handle direct 1916 // list initialization. We have the same hackaround for ctor-initializers. 1917 if (isa<InitListExpr>(InitExpr) && isStdInitializerList(FD->getType(), 0)) { 1918 Diag(FD->getLocation(), diag::warn_dangling_std_initializer_list) 1919 << /*at end of ctor*/1 << InitExpr->getSourceRange(); 1920 } 1921 Expr **Inits = &InitExpr; 1922 unsigned NumInits = 1; 1923 InitializedEntity Entity = InitializedEntity::InitializeMember(FD); 1924 InitializationKind Kind = FD->getInClassInitStyle() == ICIS_ListInit 1925 ? InitializationKind::CreateDirectList(InitExpr->getLocStart()) 1926 : InitializationKind::CreateCopy(InitExpr->getLocStart(), InitLoc); 1927 InitializationSequence Seq(*this, Entity, Kind, Inits, NumInits); 1928 Init = Seq.Perform(*this, Entity, Kind, MultiExprArg(Inits, NumInits)); 1929 if (Init.isInvalid()) { 1930 FD->setInvalidDecl(); 1931 return; 1932 } 1933 1934 CheckImplicitConversions(Init.get(), InitLoc); 1935 } 1936 1937 // C++0x [class.base.init]p7: 1938 // The initialization of each base and member constitutes a 1939 // full-expression. 1940 Init = MaybeCreateExprWithCleanups(Init); 1941 if (Init.isInvalid()) { 1942 FD->setInvalidDecl(); 1943 return; 1944 } 1945 1946 InitExpr = Init.release(); 1947 1948 FD->setInClassInitializer(InitExpr); 1949} 1950 1951/// \brief Find the direct and/or virtual base specifiers that 1952/// correspond to the given base type, for use in base initialization 1953/// within a constructor. 1954static bool FindBaseInitializer(Sema &SemaRef, 1955 CXXRecordDecl *ClassDecl, 1956 QualType BaseType, 1957 const CXXBaseSpecifier *&DirectBaseSpec, 1958 const CXXBaseSpecifier *&VirtualBaseSpec) { 1959 // First, check for a direct base class. 1960 DirectBaseSpec = 0; 1961 for (CXXRecordDecl::base_class_const_iterator Base 1962 = ClassDecl->bases_begin(); 1963 Base != ClassDecl->bases_end(); ++Base) { 1964 if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base->getType())) { 1965 // We found a direct base of this type. That's what we're 1966 // initializing. 1967 DirectBaseSpec = &*Base; 1968 break; 1969 } 1970 } 1971 1972 // Check for a virtual base class. 1973 // FIXME: We might be able to short-circuit this if we know in advance that 1974 // there are no virtual bases. 1975 VirtualBaseSpec = 0; 1976 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) { 1977 // We haven't found a base yet; search the class hierarchy for a 1978 // virtual base class. 1979 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 1980 /*DetectVirtual=*/false); 1981 if (SemaRef.IsDerivedFrom(SemaRef.Context.getTypeDeclType(ClassDecl), 1982 BaseType, Paths)) { 1983 for (CXXBasePaths::paths_iterator Path = Paths.begin(); 1984 Path != Paths.end(); ++Path) { 1985 if (Path->back().Base->isVirtual()) { 1986 VirtualBaseSpec = Path->back().Base; 1987 break; 1988 } 1989 } 1990 } 1991 } 1992 1993 return DirectBaseSpec || VirtualBaseSpec; 1994} 1995 1996/// \brief Handle a C++ member initializer using braced-init-list syntax. 1997MemInitResult 1998Sema::ActOnMemInitializer(Decl *ConstructorD, 1999 Scope *S, 2000 CXXScopeSpec &SS, 2001 IdentifierInfo *MemberOrBase, 2002 ParsedType TemplateTypeTy, 2003 const DeclSpec &DS, 2004 SourceLocation IdLoc, 2005 Expr *InitList, 2006 SourceLocation EllipsisLoc) { 2007 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy, 2008 DS, IdLoc, InitList, 2009 EllipsisLoc); 2010} 2011 2012/// \brief Handle a C++ member initializer using parentheses syntax. 2013MemInitResult 2014Sema::ActOnMemInitializer(Decl *ConstructorD, 2015 Scope *S, 2016 CXXScopeSpec &SS, 2017 IdentifierInfo *MemberOrBase, 2018 ParsedType TemplateTypeTy, 2019 const DeclSpec &DS, 2020 SourceLocation IdLoc, 2021 SourceLocation LParenLoc, 2022 Expr **Args, unsigned NumArgs, 2023 SourceLocation RParenLoc, 2024 SourceLocation EllipsisLoc) { 2025 Expr *List = new (Context) ParenListExpr(Context, LParenLoc, 2026 llvm::makeArrayRef(Args, NumArgs), 2027 RParenLoc); 2028 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy, 2029 DS, IdLoc, List, EllipsisLoc); 2030} 2031 2032namespace { 2033 2034// Callback to only accept typo corrections that can be a valid C++ member 2035// intializer: either a non-static field member or a base class. 2036class MemInitializerValidatorCCC : public CorrectionCandidateCallback { 2037 public: 2038 explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl) 2039 : ClassDecl(ClassDecl) {} 2040 2041 virtual bool ValidateCandidate(const TypoCorrection &candidate) { 2042 if (NamedDecl *ND = candidate.getCorrectionDecl()) { 2043 if (FieldDecl *Member = dyn_cast<FieldDecl>(ND)) 2044 return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl); 2045 else 2046 return isa<TypeDecl>(ND); 2047 } 2048 return false; 2049 } 2050 2051 private: 2052 CXXRecordDecl *ClassDecl; 2053}; 2054 2055} 2056 2057/// \brief Handle a C++ member initializer. 2058MemInitResult 2059Sema::BuildMemInitializer(Decl *ConstructorD, 2060 Scope *S, 2061 CXXScopeSpec &SS, 2062 IdentifierInfo *MemberOrBase, 2063 ParsedType TemplateTypeTy, 2064 const DeclSpec &DS, 2065 SourceLocation IdLoc, 2066 Expr *Init, 2067 SourceLocation EllipsisLoc) { 2068 if (!ConstructorD) 2069 return true; 2070 2071 AdjustDeclIfTemplate(ConstructorD); 2072 2073 CXXConstructorDecl *Constructor 2074 = dyn_cast<CXXConstructorDecl>(ConstructorD); 2075 if (!Constructor) { 2076 // The user wrote a constructor initializer on a function that is 2077 // not a C++ constructor. Ignore the error for now, because we may 2078 // have more member initializers coming; we'll diagnose it just 2079 // once in ActOnMemInitializers. 2080 return true; 2081 } 2082 2083 CXXRecordDecl *ClassDecl = Constructor->getParent(); 2084 2085 // C++ [class.base.init]p2: 2086 // Names in a mem-initializer-id are looked up in the scope of the 2087 // constructor's class and, if not found in that scope, are looked 2088 // up in the scope containing the constructor's definition. 2089 // [Note: if the constructor's class contains a member with the 2090 // same name as a direct or virtual base class of the class, a 2091 // mem-initializer-id naming the member or base class and composed 2092 // of a single identifier refers to the class member. A 2093 // mem-initializer-id for the hidden base class may be specified 2094 // using a qualified name. ] 2095 if (!SS.getScopeRep() && !TemplateTypeTy) { 2096 // Look for a member, first. 2097 DeclContext::lookup_result Result 2098 = ClassDecl->lookup(MemberOrBase); 2099 if (Result.first != Result.second) { 2100 ValueDecl *Member; 2101 if ((Member = dyn_cast<FieldDecl>(*Result.first)) || 2102 (Member = dyn_cast<IndirectFieldDecl>(*Result.first))) { 2103 if (EllipsisLoc.isValid()) 2104 Diag(EllipsisLoc, diag::err_pack_expansion_member_init) 2105 << MemberOrBase 2106 << SourceRange(IdLoc, Init->getSourceRange().getEnd()); 2107 2108 return BuildMemberInitializer(Member, Init, IdLoc); 2109 } 2110 } 2111 } 2112 // It didn't name a member, so see if it names a class. 2113 QualType BaseType; 2114 TypeSourceInfo *TInfo = 0; 2115 2116 if (TemplateTypeTy) { 2117 BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo); 2118 } else if (DS.getTypeSpecType() == TST_decltype) { 2119 BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc()); 2120 } else { 2121 LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName); 2122 LookupParsedName(R, S, &SS); 2123 2124 TypeDecl *TyD = R.getAsSingle<TypeDecl>(); 2125 if (!TyD) { 2126 if (R.isAmbiguous()) return true; 2127 2128 // We don't want access-control diagnostics here. 2129 R.suppressDiagnostics(); 2130 2131 if (SS.isSet() && isDependentScopeSpecifier(SS)) { 2132 bool NotUnknownSpecialization = false; 2133 DeclContext *DC = computeDeclContext(SS, false); 2134 if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC)) 2135 NotUnknownSpecialization = !Record->hasAnyDependentBases(); 2136 2137 if (!NotUnknownSpecialization) { 2138 // When the scope specifier can refer to a member of an unknown 2139 // specialization, we take it as a type name. 2140 BaseType = CheckTypenameType(ETK_None, SourceLocation(), 2141 SS.getWithLocInContext(Context), 2142 *MemberOrBase, IdLoc); 2143 if (BaseType.isNull()) 2144 return true; 2145 2146 R.clear(); 2147 R.setLookupName(MemberOrBase); 2148 } 2149 } 2150 2151 // If no results were found, try to correct typos. 2152 TypoCorrection Corr; 2153 MemInitializerValidatorCCC Validator(ClassDecl); 2154 if (R.empty() && BaseType.isNull() && 2155 (Corr = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, &SS, 2156 Validator, ClassDecl))) { 2157 std::string CorrectedStr(Corr.getAsString(getLangOpts())); 2158 std::string CorrectedQuotedStr(Corr.getQuoted(getLangOpts())); 2159 if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) { 2160 // We have found a non-static data member with a similar 2161 // name to what was typed; complain and initialize that 2162 // member. 2163 Diag(R.getNameLoc(), diag::err_mem_init_not_member_or_class_suggest) 2164 << MemberOrBase << true << CorrectedQuotedStr 2165 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr); 2166 Diag(Member->getLocation(), diag::note_previous_decl) 2167 << CorrectedQuotedStr; 2168 2169 return BuildMemberInitializer(Member, Init, IdLoc); 2170 } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) { 2171 const CXXBaseSpecifier *DirectBaseSpec; 2172 const CXXBaseSpecifier *VirtualBaseSpec; 2173 if (FindBaseInitializer(*this, ClassDecl, 2174 Context.getTypeDeclType(Type), 2175 DirectBaseSpec, VirtualBaseSpec)) { 2176 // We have found a direct or virtual base class with a 2177 // similar name to what was typed; complain and initialize 2178 // that base class. 2179 Diag(R.getNameLoc(), diag::err_mem_init_not_member_or_class_suggest) 2180 << MemberOrBase << false << CorrectedQuotedStr 2181 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr); 2182 2183 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec? DirectBaseSpec 2184 : VirtualBaseSpec; 2185 Diag(BaseSpec->getLocStart(), 2186 diag::note_base_class_specified_here) 2187 << BaseSpec->getType() 2188 << BaseSpec->getSourceRange(); 2189 2190 TyD = Type; 2191 } 2192 } 2193 } 2194 2195 if (!TyD && BaseType.isNull()) { 2196 Diag(IdLoc, diag::err_mem_init_not_member_or_class) 2197 << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd()); 2198 return true; 2199 } 2200 } 2201 2202 if (BaseType.isNull()) { 2203 BaseType = Context.getTypeDeclType(TyD); 2204 if (SS.isSet()) { 2205 NestedNameSpecifier *Qualifier = 2206 static_cast<NestedNameSpecifier*>(SS.getScopeRep()); 2207 2208 // FIXME: preserve source range information 2209 BaseType = Context.getElaboratedType(ETK_None, Qualifier, BaseType); 2210 } 2211 } 2212 } 2213 2214 if (!TInfo) 2215 TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc); 2216 2217 return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc); 2218} 2219 2220/// Checks a member initializer expression for cases where reference (or 2221/// pointer) members are bound to by-value parameters (or their addresses). 2222static void CheckForDanglingReferenceOrPointer(Sema &S, ValueDecl *Member, 2223 Expr *Init, 2224 SourceLocation IdLoc) { 2225 QualType MemberTy = Member->getType(); 2226 2227 // We only handle pointers and references currently. 2228 // FIXME: Would this be relevant for ObjC object pointers? Or block pointers? 2229 if (!MemberTy->isReferenceType() && !MemberTy->isPointerType()) 2230 return; 2231 2232 const bool IsPointer = MemberTy->isPointerType(); 2233 if (IsPointer) { 2234 if (const UnaryOperator *Op 2235 = dyn_cast<UnaryOperator>(Init->IgnoreParenImpCasts())) { 2236 // The only case we're worried about with pointers requires taking the 2237 // address. 2238 if (Op->getOpcode() != UO_AddrOf) 2239 return; 2240 2241 Init = Op->getSubExpr(); 2242 } else { 2243 // We only handle address-of expression initializers for pointers. 2244 return; 2245 } 2246 } 2247 2248 if (isa<MaterializeTemporaryExpr>(Init->IgnoreParens())) { 2249 // Taking the address of a temporary will be diagnosed as a hard error. 2250 if (IsPointer) 2251 return; 2252 2253 S.Diag(Init->getExprLoc(), diag::warn_bind_ref_member_to_temporary) 2254 << Member << Init->getSourceRange(); 2255 } else if (const DeclRefExpr *DRE 2256 = dyn_cast<DeclRefExpr>(Init->IgnoreParens())) { 2257 // We only warn when referring to a non-reference parameter declaration. 2258 const ParmVarDecl *Parameter = dyn_cast<ParmVarDecl>(DRE->getDecl()); 2259 if (!Parameter || Parameter->getType()->isReferenceType()) 2260 return; 2261 2262 S.Diag(Init->getExprLoc(), 2263 IsPointer ? diag::warn_init_ptr_member_to_parameter_addr 2264 : diag::warn_bind_ref_member_to_parameter) 2265 << Member << Parameter << Init->getSourceRange(); 2266 } else { 2267 // Other initializers are fine. 2268 return; 2269 } 2270 2271 S.Diag(Member->getLocation(), diag::note_ref_or_ptr_member_declared_here) 2272 << (unsigned)IsPointer; 2273} 2274 2275MemInitResult 2276Sema::BuildMemberInitializer(ValueDecl *Member, Expr *Init, 2277 SourceLocation IdLoc) { 2278 FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member); 2279 IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member); 2280 assert((DirectMember || IndirectMember) && 2281 "Member must be a FieldDecl or IndirectFieldDecl"); 2282 2283 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) 2284 return true; 2285 2286 if (Member->isInvalidDecl()) 2287 return true; 2288 2289 // Diagnose value-uses of fields to initialize themselves, e.g. 2290 // foo(foo) 2291 // where foo is not also a parameter to the constructor. 2292 // TODO: implement -Wuninitialized and fold this into that framework. 2293 Expr **Args; 2294 unsigned NumArgs; 2295 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) { 2296 Args = ParenList->getExprs(); 2297 NumArgs = ParenList->getNumExprs(); 2298 } else { 2299 InitListExpr *InitList = cast<InitListExpr>(Init); 2300 Args = InitList->getInits(); 2301 NumArgs = InitList->getNumInits(); 2302 } 2303 2304 if (getDiagnostics().getDiagnosticLevel(diag::warn_field_is_uninit, IdLoc) 2305 != DiagnosticsEngine::Ignored) 2306 for (unsigned i = 0; i < NumArgs; ++i) 2307 // FIXME: Warn about the case when other fields are used before being 2308 // initialized. For example, let this field be the i'th field. When 2309 // initializing the i'th field, throw a warning if any of the >= i'th 2310 // fields are used, as they are not yet initialized. 2311 // Right now we are only handling the case where the i'th field uses 2312 // itself in its initializer. 2313 // Also need to take into account that some fields may be initialized by 2314 // in-class initializers, see C++11 [class.base.init]p9. 2315 CheckInitExprContainsUninitializedFields(*this, Args[i], Member); 2316 2317 SourceRange InitRange = Init->getSourceRange(); 2318 2319 if (Member->getType()->isDependentType() || Init->isTypeDependent()) { 2320 // Can't check initialization for a member of dependent type or when 2321 // any of the arguments are type-dependent expressions. 2322 DiscardCleanupsInEvaluationContext(); 2323 } else { 2324 bool InitList = false; 2325 if (isa<InitListExpr>(Init)) { 2326 InitList = true; 2327 Args = &Init; 2328 NumArgs = 1; 2329 2330 if (isStdInitializerList(Member->getType(), 0)) { 2331 Diag(IdLoc, diag::warn_dangling_std_initializer_list) 2332 << /*at end of ctor*/1 << InitRange; 2333 } 2334 } 2335 2336 // Initialize the member. 2337 InitializedEntity MemberEntity = 2338 DirectMember ? InitializedEntity::InitializeMember(DirectMember, 0) 2339 : InitializedEntity::InitializeMember(IndirectMember, 0); 2340 InitializationKind Kind = 2341 InitList ? InitializationKind::CreateDirectList(IdLoc) 2342 : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(), 2343 InitRange.getEnd()); 2344 2345 InitializationSequence InitSeq(*this, MemberEntity, Kind, Args, NumArgs); 2346 ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind, 2347 MultiExprArg(Args, NumArgs), 2348 0); 2349 if (MemberInit.isInvalid()) 2350 return true; 2351 2352 CheckImplicitConversions(MemberInit.get(), 2353 InitRange.getBegin()); 2354 2355 // C++0x [class.base.init]p7: 2356 // The initialization of each base and member constitutes a 2357 // full-expression. 2358 MemberInit = MaybeCreateExprWithCleanups(MemberInit); 2359 if (MemberInit.isInvalid()) 2360 return true; 2361 2362 // If we are in a dependent context, template instantiation will 2363 // perform this type-checking again. Just save the arguments that we 2364 // received. 2365 // FIXME: This isn't quite ideal, since our ASTs don't capture all 2366 // of the information that we have about the member 2367 // initializer. However, deconstructing the ASTs is a dicey process, 2368 // and this approach is far more likely to get the corner cases right. 2369 if (CurContext->isDependentContext()) { 2370 // The existing Init will do fine. 2371 } else { 2372 Init = MemberInit.get(); 2373 CheckForDanglingReferenceOrPointer(*this, Member, Init, IdLoc); 2374 } 2375 } 2376 2377 if (DirectMember) { 2378 return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc, 2379 InitRange.getBegin(), Init, 2380 InitRange.getEnd()); 2381 } else { 2382 return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc, 2383 InitRange.getBegin(), Init, 2384 InitRange.getEnd()); 2385 } 2386} 2387 2388MemInitResult 2389Sema::BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, 2390 CXXRecordDecl *ClassDecl) { 2391 SourceLocation NameLoc = TInfo->getTypeLoc().getLocalSourceRange().getBegin(); 2392 if (!LangOpts.CPlusPlus0x) 2393 return Diag(NameLoc, diag::err_delegating_ctor) 2394 << TInfo->getTypeLoc().getLocalSourceRange(); 2395 Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor); 2396 2397 bool InitList = true; 2398 Expr **Args = &Init; 2399 unsigned NumArgs = 1; 2400 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) { 2401 InitList = false; 2402 Args = ParenList->getExprs(); 2403 NumArgs = ParenList->getNumExprs(); 2404 } 2405 2406 SourceRange InitRange = Init->getSourceRange(); 2407 // Initialize the object. 2408 InitializedEntity DelegationEntity = InitializedEntity::InitializeDelegation( 2409 QualType(ClassDecl->getTypeForDecl(), 0)); 2410 InitializationKind Kind = 2411 InitList ? InitializationKind::CreateDirectList(NameLoc) 2412 : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(), 2413 InitRange.getEnd()); 2414 InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args, NumArgs); 2415 ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind, 2416 MultiExprArg(Args, NumArgs), 2417 0); 2418 if (DelegationInit.isInvalid()) 2419 return true; 2420 2421 assert(cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() && 2422 "Delegating constructor with no target?"); 2423 2424 CheckImplicitConversions(DelegationInit.get(), InitRange.getBegin()); 2425 2426 // C++0x [class.base.init]p7: 2427 // The initialization of each base and member constitutes a 2428 // full-expression. 2429 DelegationInit = MaybeCreateExprWithCleanups(DelegationInit); 2430 if (DelegationInit.isInvalid()) 2431 return true; 2432 2433 // If we are in a dependent context, template instantiation will 2434 // perform this type-checking again. Just save the arguments that we 2435 // received in a ParenListExpr. 2436 // FIXME: This isn't quite ideal, since our ASTs don't capture all 2437 // of the information that we have about the base 2438 // initializer. However, deconstructing the ASTs is a dicey process, 2439 // and this approach is far more likely to get the corner cases right. 2440 if (CurContext->isDependentContext()) 2441 DelegationInit = Owned(Init); 2442 2443 return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(), 2444 DelegationInit.takeAs<Expr>(), 2445 InitRange.getEnd()); 2446} 2447 2448MemInitResult 2449Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo, 2450 Expr *Init, CXXRecordDecl *ClassDecl, 2451 SourceLocation EllipsisLoc) { 2452 SourceLocation BaseLoc 2453 = BaseTInfo->getTypeLoc().getLocalSourceRange().getBegin(); 2454 2455 if (!BaseType->isDependentType() && !BaseType->isRecordType()) 2456 return Diag(BaseLoc, diag::err_base_init_does_not_name_class) 2457 << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange(); 2458 2459 // C++ [class.base.init]p2: 2460 // [...] Unless the mem-initializer-id names a nonstatic data 2461 // member of the constructor's class or a direct or virtual base 2462 // of that class, the mem-initializer is ill-formed. A 2463 // mem-initializer-list can initialize a base class using any 2464 // name that denotes that base class type. 2465 bool Dependent = BaseType->isDependentType() || Init->isTypeDependent(); 2466 2467 SourceRange InitRange = Init->getSourceRange(); 2468 if (EllipsisLoc.isValid()) { 2469 // This is a pack expansion. 2470 if (!BaseType->containsUnexpandedParameterPack()) { 2471 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) 2472 << SourceRange(BaseLoc, InitRange.getEnd()); 2473 2474 EllipsisLoc = SourceLocation(); 2475 } 2476 } else { 2477 // Check for any unexpanded parameter packs. 2478 if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer)) 2479 return true; 2480 2481 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) 2482 return true; 2483 } 2484 2485 // Check for direct and virtual base classes. 2486 const CXXBaseSpecifier *DirectBaseSpec = 0; 2487 const CXXBaseSpecifier *VirtualBaseSpec = 0; 2488 if (!Dependent) { 2489 if (Context.hasSameUnqualifiedType(QualType(ClassDecl->getTypeForDecl(),0), 2490 BaseType)) 2491 return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl); 2492 2493 FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec, 2494 VirtualBaseSpec); 2495 2496 // C++ [base.class.init]p2: 2497 // Unless the mem-initializer-id names a nonstatic data member of the 2498 // constructor's class or a direct or virtual base of that class, the 2499 // mem-initializer is ill-formed. 2500 if (!DirectBaseSpec && !VirtualBaseSpec) { 2501 // If the class has any dependent bases, then it's possible that 2502 // one of those types will resolve to the same type as 2503 // BaseType. Therefore, just treat this as a dependent base 2504 // class initialization. FIXME: Should we try to check the 2505 // initialization anyway? It seems odd. 2506 if (ClassDecl->hasAnyDependentBases()) 2507 Dependent = true; 2508 else 2509 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual) 2510 << BaseType << Context.getTypeDeclType(ClassDecl) 2511 << BaseTInfo->getTypeLoc().getLocalSourceRange(); 2512 } 2513 } 2514 2515 if (Dependent) { 2516 DiscardCleanupsInEvaluationContext(); 2517 2518 return new (Context) CXXCtorInitializer(Context, BaseTInfo, 2519 /*IsVirtual=*/false, 2520 InitRange.getBegin(), Init, 2521 InitRange.getEnd(), EllipsisLoc); 2522 } 2523 2524 // C++ [base.class.init]p2: 2525 // If a mem-initializer-id is ambiguous because it designates both 2526 // a direct non-virtual base class and an inherited virtual base 2527 // class, the mem-initializer is ill-formed. 2528 if (DirectBaseSpec && VirtualBaseSpec) 2529 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual) 2530 << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange(); 2531 2532 CXXBaseSpecifier *BaseSpec = const_cast<CXXBaseSpecifier *>(DirectBaseSpec); 2533 if (!BaseSpec) 2534 BaseSpec = const_cast<CXXBaseSpecifier *>(VirtualBaseSpec); 2535 2536 // Initialize the base. 2537 bool InitList = true; 2538 Expr **Args = &Init; 2539 unsigned NumArgs = 1; 2540 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) { 2541 InitList = false; 2542 Args = ParenList->getExprs(); 2543 NumArgs = ParenList->getNumExprs(); 2544 } 2545 2546 InitializedEntity BaseEntity = 2547 InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec); 2548 InitializationKind Kind = 2549 InitList ? InitializationKind::CreateDirectList(BaseLoc) 2550 : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(), 2551 InitRange.getEnd()); 2552 InitializationSequence InitSeq(*this, BaseEntity, Kind, Args, NumArgs); 2553 ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind, 2554 MultiExprArg(Args, NumArgs), 0); 2555 if (BaseInit.isInvalid()) 2556 return true; 2557 2558 CheckImplicitConversions(BaseInit.get(), InitRange.getBegin()); 2559 2560 // C++0x [class.base.init]p7: 2561 // The initialization of each base and member constitutes a 2562 // full-expression. 2563 BaseInit = MaybeCreateExprWithCleanups(BaseInit); 2564 if (BaseInit.isInvalid()) 2565 return true; 2566 2567 // If we are in a dependent context, template instantiation will 2568 // perform this type-checking again. Just save the arguments that we 2569 // received in a ParenListExpr. 2570 // FIXME: This isn't quite ideal, since our ASTs don't capture all 2571 // of the information that we have about the base 2572 // initializer. However, deconstructing the ASTs is a dicey process, 2573 // and this approach is far more likely to get the corner cases right. 2574 if (CurContext->isDependentContext()) 2575 BaseInit = Owned(Init); 2576 2577 return new (Context) CXXCtorInitializer(Context, BaseTInfo, 2578 BaseSpec->isVirtual(), 2579 InitRange.getBegin(), 2580 BaseInit.takeAs<Expr>(), 2581 InitRange.getEnd(), EllipsisLoc); 2582} 2583 2584// Create a static_cast\<T&&>(expr). 2585static Expr *CastForMoving(Sema &SemaRef, Expr *E) { 2586 QualType ExprType = E->getType(); 2587 QualType TargetType = SemaRef.Context.getRValueReferenceType(ExprType); 2588 SourceLocation ExprLoc = E->getLocStart(); 2589 TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo( 2590 TargetType, ExprLoc); 2591 2592 return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E, 2593 SourceRange(ExprLoc, ExprLoc), 2594 E->getSourceRange()).take(); 2595} 2596 2597/// ImplicitInitializerKind - How an implicit base or member initializer should 2598/// initialize its base or member. 2599enum ImplicitInitializerKind { 2600 IIK_Default, 2601 IIK_Copy, 2602 IIK_Move 2603}; 2604 2605static bool 2606BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, 2607 ImplicitInitializerKind ImplicitInitKind, 2608 CXXBaseSpecifier *BaseSpec, 2609 bool IsInheritedVirtualBase, 2610 CXXCtorInitializer *&CXXBaseInit) { 2611 InitializedEntity InitEntity 2612 = InitializedEntity::InitializeBase(SemaRef.Context, BaseSpec, 2613 IsInheritedVirtualBase); 2614 2615 ExprResult BaseInit; 2616 2617 switch (ImplicitInitKind) { 2618 case IIK_Default: { 2619 InitializationKind InitKind 2620 = InitializationKind::CreateDefault(Constructor->getLocation()); 2621 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, 0, 0); 2622 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, MultiExprArg()); 2623 break; 2624 } 2625 2626 case IIK_Move: 2627 case IIK_Copy: { 2628 bool Moving = ImplicitInitKind == IIK_Move; 2629 ParmVarDecl *Param = Constructor->getParamDecl(0); 2630 QualType ParamType = Param->getType().getNonReferenceType(); 2631 2632 Expr *CopyCtorArg = 2633 DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(), 2634 SourceLocation(), Param, false, 2635 Constructor->getLocation(), ParamType, 2636 VK_LValue, 0); 2637 2638 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg)); 2639 2640 // Cast to the base class to avoid ambiguities. 2641 QualType ArgTy = 2642 SemaRef.Context.getQualifiedType(BaseSpec->getType().getUnqualifiedType(), 2643 ParamType.getQualifiers()); 2644 2645 if (Moving) { 2646 CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg); 2647 } 2648 2649 CXXCastPath BasePath; 2650 BasePath.push_back(BaseSpec); 2651 CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy, 2652 CK_UncheckedDerivedToBase, 2653 Moving ? VK_XValue : VK_LValue, 2654 &BasePath).take(); 2655 2656 InitializationKind InitKind 2657 = InitializationKind::CreateDirect(Constructor->getLocation(), 2658 SourceLocation(), SourceLocation()); 2659 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, 2660 &CopyCtorArg, 1); 2661 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, 2662 MultiExprArg(&CopyCtorArg, 1)); 2663 break; 2664 } 2665 } 2666 2667 BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit); 2668 if (BaseInit.isInvalid()) 2669 return true; 2670 2671 CXXBaseInit = 2672 new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, 2673 SemaRef.Context.getTrivialTypeSourceInfo(BaseSpec->getType(), 2674 SourceLocation()), 2675 BaseSpec->isVirtual(), 2676 SourceLocation(), 2677 BaseInit.takeAs<Expr>(), 2678 SourceLocation(), 2679 SourceLocation()); 2680 2681 return false; 2682} 2683 2684static bool RefersToRValueRef(Expr *MemRef) { 2685 ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl(); 2686 return Referenced->getType()->isRValueReferenceType(); 2687} 2688 2689static bool 2690BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, 2691 ImplicitInitializerKind ImplicitInitKind, 2692 FieldDecl *Field, IndirectFieldDecl *Indirect, 2693 CXXCtorInitializer *&CXXMemberInit) { 2694 if (Field->isInvalidDecl()) 2695 return true; 2696 2697 SourceLocation Loc = Constructor->getLocation(); 2698 2699 if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) { 2700 bool Moving = ImplicitInitKind == IIK_Move; 2701 ParmVarDecl *Param = Constructor->getParamDecl(0); 2702 QualType ParamType = Param->getType().getNonReferenceType(); 2703 2704 // Suppress copying zero-width bitfields. 2705 if (Field->isBitField() && Field->getBitWidthValue(SemaRef.Context) == 0) 2706 return false; 2707 2708 Expr *MemberExprBase = 2709 DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(), 2710 SourceLocation(), Param, false, 2711 Loc, ParamType, VK_LValue, 0); 2712 2713 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase)); 2714 2715 if (Moving) { 2716 MemberExprBase = CastForMoving(SemaRef, MemberExprBase); 2717 } 2718 2719 // Build a reference to this field within the parameter. 2720 CXXScopeSpec SS; 2721 LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc, 2722 Sema::LookupMemberName); 2723 MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect) 2724 : cast<ValueDecl>(Field), AS_public); 2725 MemberLookup.resolveKind(); 2726 ExprResult CtorArg 2727 = SemaRef.BuildMemberReferenceExpr(MemberExprBase, 2728 ParamType, Loc, 2729 /*IsArrow=*/false, 2730 SS, 2731 /*TemplateKWLoc=*/SourceLocation(), 2732 /*FirstQualifierInScope=*/0, 2733 MemberLookup, 2734 /*TemplateArgs=*/0); 2735 if (CtorArg.isInvalid()) 2736 return true; 2737 2738 // C++11 [class.copy]p15: 2739 // - if a member m has rvalue reference type T&&, it is direct-initialized 2740 // with static_cast<T&&>(x.m); 2741 if (RefersToRValueRef(CtorArg.get())) { 2742 CtorArg = CastForMoving(SemaRef, CtorArg.take()); 2743 } 2744 2745 // When the field we are copying is an array, create index variables for 2746 // each dimension of the array. We use these index variables to subscript 2747 // the source array, and other clients (e.g., CodeGen) will perform the 2748 // necessary iteration with these index variables. 2749 SmallVector<VarDecl *, 4> IndexVariables; 2750 QualType BaseType = Field->getType(); 2751 QualType SizeType = SemaRef.Context.getSizeType(); 2752 bool InitializingArray = false; 2753 while (const ConstantArrayType *Array 2754 = SemaRef.Context.getAsConstantArrayType(BaseType)) { 2755 InitializingArray = true; 2756 // Create the iteration variable for this array index. 2757 IdentifierInfo *IterationVarName = 0; 2758 { 2759 SmallString<8> Str; 2760 llvm::raw_svector_ostream OS(Str); 2761 OS << "__i" << IndexVariables.size(); 2762 IterationVarName = &SemaRef.Context.Idents.get(OS.str()); 2763 } 2764 VarDecl *IterationVar 2765 = VarDecl::Create(SemaRef.Context, SemaRef.CurContext, Loc, Loc, 2766 IterationVarName, SizeType, 2767 SemaRef.Context.getTrivialTypeSourceInfo(SizeType, Loc), 2768 SC_None, SC_None); 2769 IndexVariables.push_back(IterationVar); 2770 2771 // Create a reference to the iteration variable. 2772 ExprResult IterationVarRef 2773 = SemaRef.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc); 2774 assert(!IterationVarRef.isInvalid() && 2775 "Reference to invented variable cannot fail!"); 2776 IterationVarRef = SemaRef.DefaultLvalueConversion(IterationVarRef.take()); 2777 assert(!IterationVarRef.isInvalid() && 2778 "Conversion of invented variable cannot fail!"); 2779 2780 // Subscript the array with this iteration variable. 2781 CtorArg = SemaRef.CreateBuiltinArraySubscriptExpr(CtorArg.take(), Loc, 2782 IterationVarRef.take(), 2783 Loc); 2784 if (CtorArg.isInvalid()) 2785 return true; 2786 2787 BaseType = Array->getElementType(); 2788 } 2789 2790 // The array subscript expression is an lvalue, which is wrong for moving. 2791 if (Moving && InitializingArray) 2792 CtorArg = CastForMoving(SemaRef, CtorArg.take()); 2793 2794 // Construct the entity that we will be initializing. For an array, this 2795 // will be first element in the array, which may require several levels 2796 // of array-subscript entities. 2797 SmallVector<InitializedEntity, 4> Entities; 2798 Entities.reserve(1 + IndexVariables.size()); 2799 if (Indirect) 2800 Entities.push_back(InitializedEntity::InitializeMember(Indirect)); 2801 else 2802 Entities.push_back(InitializedEntity::InitializeMember(Field)); 2803 for (unsigned I = 0, N = IndexVariables.size(); I != N; ++I) 2804 Entities.push_back(InitializedEntity::InitializeElement(SemaRef.Context, 2805 0, 2806 Entities.back())); 2807 2808 // Direct-initialize to use the copy constructor. 2809 InitializationKind InitKind = 2810 InitializationKind::CreateDirect(Loc, SourceLocation(), SourceLocation()); 2811 2812 Expr *CtorArgE = CtorArg.takeAs<Expr>(); 2813 InitializationSequence InitSeq(SemaRef, Entities.back(), InitKind, 2814 &CtorArgE, 1); 2815 2816 ExprResult MemberInit 2817 = InitSeq.Perform(SemaRef, Entities.back(), InitKind, 2818 MultiExprArg(&CtorArgE, 1)); 2819 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit); 2820 if (MemberInit.isInvalid()) 2821 return true; 2822 2823 if (Indirect) { 2824 assert(IndexVariables.size() == 0 && 2825 "Indirect field improperly initialized"); 2826 CXXMemberInit 2827 = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Indirect, 2828 Loc, Loc, 2829 MemberInit.takeAs<Expr>(), 2830 Loc); 2831 } else 2832 CXXMemberInit = CXXCtorInitializer::Create(SemaRef.Context, Field, Loc, 2833 Loc, MemberInit.takeAs<Expr>(), 2834 Loc, 2835 IndexVariables.data(), 2836 IndexVariables.size()); 2837 return false; 2838 } 2839 2840 assert(ImplicitInitKind == IIK_Default && "Unhandled implicit init kind!"); 2841 2842 QualType FieldBaseElementType = 2843 SemaRef.Context.getBaseElementType(Field->getType()); 2844 2845 if (FieldBaseElementType->isRecordType()) { 2846 InitializedEntity InitEntity 2847 = Indirect? InitializedEntity::InitializeMember(Indirect) 2848 : InitializedEntity::InitializeMember(Field); 2849 InitializationKind InitKind = 2850 InitializationKind::CreateDefault(Loc); 2851 2852 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, 0, 0); 2853 ExprResult MemberInit = 2854 InitSeq.Perform(SemaRef, InitEntity, InitKind, MultiExprArg()); 2855 2856 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit); 2857 if (MemberInit.isInvalid()) 2858 return true; 2859 2860 if (Indirect) 2861 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, 2862 Indirect, Loc, 2863 Loc, 2864 MemberInit.get(), 2865 Loc); 2866 else 2867 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, 2868 Field, Loc, Loc, 2869 MemberInit.get(), 2870 Loc); 2871 return false; 2872 } 2873 2874 if (!Field->getParent()->isUnion()) { 2875 if (FieldBaseElementType->isReferenceType()) { 2876 SemaRef.Diag(Constructor->getLocation(), 2877 diag::err_uninitialized_member_in_ctor) 2878 << (int)Constructor->isImplicit() 2879 << SemaRef.Context.getTagDeclType(Constructor->getParent()) 2880 << 0 << Field->getDeclName(); 2881 SemaRef.Diag(Field->getLocation(), diag::note_declared_at); 2882 return true; 2883 } 2884 2885 if (FieldBaseElementType.isConstQualified()) { 2886 SemaRef.Diag(Constructor->getLocation(), 2887 diag::err_uninitialized_member_in_ctor) 2888 << (int)Constructor->isImplicit() 2889 << SemaRef.Context.getTagDeclType(Constructor->getParent()) 2890 << 1 << Field->getDeclName(); 2891 SemaRef.Diag(Field->getLocation(), diag::note_declared_at); 2892 return true; 2893 } 2894 } 2895 2896 if (SemaRef.getLangOpts().ObjCAutoRefCount && 2897 FieldBaseElementType->isObjCRetainableType() && 2898 FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_None && 2899 FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_ExplicitNone) { 2900 // ARC: 2901 // Default-initialize Objective-C pointers to NULL. 2902 CXXMemberInit 2903 = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field, 2904 Loc, Loc, 2905 new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()), 2906 Loc); 2907 return false; 2908 } 2909 2910 // Nothing to initialize. 2911 CXXMemberInit = 0; 2912 return false; 2913} 2914 2915namespace { 2916struct BaseAndFieldInfo { 2917 Sema &S; 2918 CXXConstructorDecl *Ctor; 2919 bool AnyErrorsInInits; 2920 ImplicitInitializerKind IIK; 2921 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields; 2922 SmallVector<CXXCtorInitializer*, 8> AllToInit; 2923 2924 BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits) 2925 : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) { 2926 bool Generated = Ctor->isImplicit() || Ctor->isDefaulted(); 2927 if (Generated && Ctor->isCopyConstructor()) 2928 IIK = IIK_Copy; 2929 else if (Generated && Ctor->isMoveConstructor()) 2930 IIK = IIK_Move; 2931 else 2932 IIK = IIK_Default; 2933 } 2934 2935 bool isImplicitCopyOrMove() const { 2936 switch (IIK) { 2937 case IIK_Copy: 2938 case IIK_Move: 2939 return true; 2940 2941 case IIK_Default: 2942 return false; 2943 } 2944 2945 llvm_unreachable("Invalid ImplicitInitializerKind!"); 2946 } 2947 2948 bool addFieldInitializer(CXXCtorInitializer *Init) { 2949 AllToInit.push_back(Init); 2950 2951 // Check whether this initializer makes the field "used". 2952 if (Init->getInit() && Init->getInit()->HasSideEffects(S.Context)) 2953 S.UnusedPrivateFields.remove(Init->getAnyMember()); 2954 2955 return false; 2956 } 2957}; 2958} 2959 2960/// \brief Determine whether the given indirect field declaration is somewhere 2961/// within an anonymous union. 2962static bool isWithinAnonymousUnion(IndirectFieldDecl *F) { 2963 for (IndirectFieldDecl::chain_iterator C = F->chain_begin(), 2964 CEnd = F->chain_end(); 2965 C != CEnd; ++C) 2966 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>((*C)->getDeclContext())) 2967 if (Record->isUnion()) 2968 return true; 2969 2970 return false; 2971} 2972 2973/// \brief Determine whether the given type is an incomplete or zero-lenfgth 2974/// array type. 2975static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T) { 2976 if (T->isIncompleteArrayType()) 2977 return true; 2978 2979 while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) { 2980 if (!ArrayT->getSize()) 2981 return true; 2982 2983 T = ArrayT->getElementType(); 2984 } 2985 2986 return false; 2987} 2988 2989static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info, 2990 FieldDecl *Field, 2991 IndirectFieldDecl *Indirect = 0) { 2992 2993 // Overwhelmingly common case: we have a direct initializer for this field. 2994 if (CXXCtorInitializer *Init = Info.AllBaseFields.lookup(Field)) 2995 return Info.addFieldInitializer(Init); 2996 2997 // C++11 [class.base.init]p8: if the entity is a non-static data member that 2998 // has a brace-or-equal-initializer, the entity is initialized as specified 2999 // in [dcl.init]. 3000 if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) { 3001 CXXCtorInitializer *Init; 3002 if (Indirect) 3003 Init = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Indirect, 3004 SourceLocation(), 3005 SourceLocation(), 0, 3006 SourceLocation()); 3007 else 3008 Init = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field, 3009 SourceLocation(), 3010 SourceLocation(), 0, 3011 SourceLocation()); 3012 return Info.addFieldInitializer(Init); 3013 } 3014 3015 // Don't build an implicit initializer for union members if none was 3016 // explicitly specified. 3017 if (Field->getParent()->isUnion() || 3018 (Indirect && isWithinAnonymousUnion(Indirect))) 3019 return false; 3020 3021 // Don't initialize incomplete or zero-length arrays. 3022 if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType())) 3023 return false; 3024 3025 // Don't try to build an implicit initializer if there were semantic 3026 // errors in any of the initializers (and therefore we might be 3027 // missing some that the user actually wrote). 3028 if (Info.AnyErrorsInInits || Field->isInvalidDecl()) 3029 return false; 3030 3031 CXXCtorInitializer *Init = 0; 3032 if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field, 3033 Indirect, Init)) 3034 return true; 3035 3036 if (!Init) 3037 return false; 3038 3039 return Info.addFieldInitializer(Init); 3040} 3041 3042bool 3043Sema::SetDelegatingInitializer(CXXConstructorDecl *Constructor, 3044 CXXCtorInitializer *Initializer) { 3045 assert(Initializer->isDelegatingInitializer()); 3046 Constructor->setNumCtorInitializers(1); 3047 CXXCtorInitializer **initializer = 3048 new (Context) CXXCtorInitializer*[1]; 3049 memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*)); 3050 Constructor->setCtorInitializers(initializer); 3051 3052 if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) { 3053 MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor); 3054 DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation()); 3055 } 3056 3057 DelegatingCtorDecls.push_back(Constructor); 3058 3059 return false; 3060} 3061 3062bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, 3063 CXXCtorInitializer **Initializers, 3064 unsigned NumInitializers, 3065 bool AnyErrors) { 3066 if (Constructor->isDependentContext()) { 3067 // Just store the initializers as written, they will be checked during 3068 // instantiation. 3069 if (NumInitializers > 0) { 3070 Constructor->setNumCtorInitializers(NumInitializers); 3071 CXXCtorInitializer **baseOrMemberInitializers = 3072 new (Context) CXXCtorInitializer*[NumInitializers]; 3073 memcpy(baseOrMemberInitializers, Initializers, 3074 NumInitializers * sizeof(CXXCtorInitializer*)); 3075 Constructor->setCtorInitializers(baseOrMemberInitializers); 3076 } 3077 3078 // Let template instantiation know whether we had errors. 3079 if (AnyErrors) 3080 Constructor->setInvalidDecl(); 3081 3082 return false; 3083 } 3084 3085 BaseAndFieldInfo Info(*this, Constructor, AnyErrors); 3086 3087 // We need to build the initializer AST according to order of construction 3088 // and not what user specified in the Initializers list. 3089 CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition(); 3090 if (!ClassDecl) 3091 return true; 3092 3093 bool HadError = false; 3094 3095 for (unsigned i = 0; i < NumInitializers; i++) { 3096 CXXCtorInitializer *Member = Initializers[i]; 3097 3098 if (Member->isBaseInitializer()) 3099 Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member; 3100 else 3101 Info.AllBaseFields[Member->getAnyMember()] = Member; 3102 } 3103 3104 // Keep track of the direct virtual bases. 3105 llvm::SmallPtrSet<CXXBaseSpecifier *, 16> DirectVBases; 3106 for (CXXRecordDecl::base_class_iterator I = ClassDecl->bases_begin(), 3107 E = ClassDecl->bases_end(); I != E; ++I) { 3108 if (I->isVirtual()) 3109 DirectVBases.insert(I); 3110 } 3111 3112 // Push virtual bases before others. 3113 for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(), 3114 E = ClassDecl->vbases_end(); VBase != E; ++VBase) { 3115 3116 if (CXXCtorInitializer *Value 3117 = Info.AllBaseFields.lookup(VBase->getType()->getAs<RecordType>())) { 3118 Info.AllToInit.push_back(Value); 3119 } else if (!AnyErrors) { 3120 bool IsInheritedVirtualBase = !DirectVBases.count(VBase); 3121 CXXCtorInitializer *CXXBaseInit; 3122 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK, 3123 VBase, IsInheritedVirtualBase, 3124 CXXBaseInit)) { 3125 HadError = true; 3126 continue; 3127 } 3128 3129 Info.AllToInit.push_back(CXXBaseInit); 3130 } 3131 } 3132 3133 // Non-virtual bases. 3134 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), 3135 E = ClassDecl->bases_end(); Base != E; ++Base) { 3136 // Virtuals are in the virtual base list and already constructed. 3137 if (Base->isVirtual()) 3138 continue; 3139 3140 if (CXXCtorInitializer *Value 3141 = Info.AllBaseFields.lookup(Base->getType()->getAs<RecordType>())) { 3142 Info.AllToInit.push_back(Value); 3143 } else if (!AnyErrors) { 3144 CXXCtorInitializer *CXXBaseInit; 3145 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK, 3146 Base, /*IsInheritedVirtualBase=*/false, 3147 CXXBaseInit)) { 3148 HadError = true; 3149 continue; 3150 } 3151 3152 Info.AllToInit.push_back(CXXBaseInit); 3153 } 3154 } 3155 3156 // Fields. 3157 for (DeclContext::decl_iterator Mem = ClassDecl->decls_begin(), 3158 MemEnd = ClassDecl->decls_end(); 3159 Mem != MemEnd; ++Mem) { 3160 if (FieldDecl *F = dyn_cast<FieldDecl>(*Mem)) { 3161 // C++ [class.bit]p2: 3162 // A declaration for a bit-field that omits the identifier declares an 3163 // unnamed bit-field. Unnamed bit-fields are not members and cannot be 3164 // initialized. 3165 if (F->isUnnamedBitfield()) 3166 continue; 3167 3168 // If we're not generating the implicit copy/move constructor, then we'll 3169 // handle anonymous struct/union fields based on their individual 3170 // indirect fields. 3171 if (F->isAnonymousStructOrUnion() && Info.IIK == IIK_Default) 3172 continue; 3173 3174 if (CollectFieldInitializer(*this, Info, F)) 3175 HadError = true; 3176 continue; 3177 } 3178 3179 // Beyond this point, we only consider default initialization. 3180 if (Info.IIK != IIK_Default) 3181 continue; 3182 3183 if (IndirectFieldDecl *F = dyn_cast<IndirectFieldDecl>(*Mem)) { 3184 if (F->getType()->isIncompleteArrayType()) { 3185 assert(ClassDecl->hasFlexibleArrayMember() && 3186 "Incomplete array type is not valid"); 3187 continue; 3188 } 3189 3190 // Initialize each field of an anonymous struct individually. 3191 if (CollectFieldInitializer(*this, Info, F->getAnonField(), F)) 3192 HadError = true; 3193 3194 continue; 3195 } 3196 } 3197 3198 NumInitializers = Info.AllToInit.size(); 3199 if (NumInitializers > 0) { 3200 Constructor->setNumCtorInitializers(NumInitializers); 3201 CXXCtorInitializer **baseOrMemberInitializers = 3202 new (Context) CXXCtorInitializer*[NumInitializers]; 3203 memcpy(baseOrMemberInitializers, Info.AllToInit.data(), 3204 NumInitializers * sizeof(CXXCtorInitializer*)); 3205 Constructor->setCtorInitializers(baseOrMemberInitializers); 3206 3207 // Constructors implicitly reference the base and member 3208 // destructors. 3209 MarkBaseAndMemberDestructorsReferenced(Constructor->getLocation(), 3210 Constructor->getParent()); 3211 } 3212 3213 return HadError; 3214} 3215 3216static void *GetKeyForTopLevelField(FieldDecl *Field) { 3217 // For anonymous unions, use the class declaration as the key. 3218 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) { 3219 if (RT->getDecl()->isAnonymousStructOrUnion()) 3220 return static_cast<void *>(RT->getDecl()); 3221 } 3222 return static_cast<void *>(Field); 3223} 3224 3225static void *GetKeyForBase(ASTContext &Context, QualType BaseType) { 3226 return const_cast<Type*>(Context.getCanonicalType(BaseType).getTypePtr()); 3227} 3228 3229static void *GetKeyForMember(ASTContext &Context, 3230 CXXCtorInitializer *Member) { 3231 if (!Member->isAnyMemberInitializer()) 3232 return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0)); 3233 3234 // For fields injected into the class via declaration of an anonymous union, 3235 // use its anonymous union class declaration as the unique key. 3236 FieldDecl *Field = Member->getAnyMember(); 3237 3238 // If the field is a member of an anonymous struct or union, our key 3239 // is the anonymous record decl that's a direct child of the class. 3240 RecordDecl *RD = Field->getParent(); 3241 if (RD->isAnonymousStructOrUnion()) { 3242 while (true) { 3243 RecordDecl *Parent = cast<RecordDecl>(RD->getDeclContext()); 3244 if (Parent->isAnonymousStructOrUnion()) 3245 RD = Parent; 3246 else 3247 break; 3248 } 3249 3250 return static_cast<void *>(RD); 3251 } 3252 3253 return static_cast<void *>(Field); 3254} 3255 3256static void 3257DiagnoseBaseOrMemInitializerOrder(Sema &SemaRef, 3258 const CXXConstructorDecl *Constructor, 3259 CXXCtorInitializer **Inits, 3260 unsigned NumInits) { 3261 if (Constructor->getDeclContext()->isDependentContext()) 3262 return; 3263 3264 // Don't check initializers order unless the warning is enabled at the 3265 // location of at least one initializer. 3266 bool ShouldCheckOrder = false; 3267 for (unsigned InitIndex = 0; InitIndex != NumInits; ++InitIndex) { 3268 CXXCtorInitializer *Init = Inits[InitIndex]; 3269 if (SemaRef.Diags.getDiagnosticLevel(diag::warn_initializer_out_of_order, 3270 Init->getSourceLocation()) 3271 != DiagnosticsEngine::Ignored) { 3272 ShouldCheckOrder = true; 3273 break; 3274 } 3275 } 3276 if (!ShouldCheckOrder) 3277 return; 3278 3279 // Build the list of bases and members in the order that they'll 3280 // actually be initialized. The explicit initializers should be in 3281 // this same order but may be missing things. 3282 SmallVector<const void*, 32> IdealInitKeys; 3283 3284 const CXXRecordDecl *ClassDecl = Constructor->getParent(); 3285 3286 // 1. Virtual bases. 3287 for (CXXRecordDecl::base_class_const_iterator VBase = 3288 ClassDecl->vbases_begin(), 3289 E = ClassDecl->vbases_end(); VBase != E; ++VBase) 3290 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase->getType())); 3291 3292 // 2. Non-virtual bases. 3293 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(), 3294 E = ClassDecl->bases_end(); Base != E; ++Base) { 3295 if (Base->isVirtual()) 3296 continue; 3297 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base->getType())); 3298 } 3299 3300 // 3. Direct fields. 3301 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 3302 E = ClassDecl->field_end(); Field != E; ++Field) { 3303 if (Field->isUnnamedBitfield()) 3304 continue; 3305 3306 IdealInitKeys.push_back(GetKeyForTopLevelField(*Field)); 3307 } 3308 3309 unsigned NumIdealInits = IdealInitKeys.size(); 3310 unsigned IdealIndex = 0; 3311 3312 CXXCtorInitializer *PrevInit = 0; 3313 for (unsigned InitIndex = 0; InitIndex != NumInits; ++InitIndex) { 3314 CXXCtorInitializer *Init = Inits[InitIndex]; 3315 void *InitKey = GetKeyForMember(SemaRef.Context, Init); 3316 3317 // Scan forward to try to find this initializer in the idealized 3318 // initializers list. 3319 for (; IdealIndex != NumIdealInits; ++IdealIndex) 3320 if (InitKey == IdealInitKeys[IdealIndex]) 3321 break; 3322 3323 // If we didn't find this initializer, it must be because we 3324 // scanned past it on a previous iteration. That can only 3325 // happen if we're out of order; emit a warning. 3326 if (IdealIndex == NumIdealInits && PrevInit) { 3327 Sema::SemaDiagnosticBuilder D = 3328 SemaRef.Diag(PrevInit->getSourceLocation(), 3329 diag::warn_initializer_out_of_order); 3330 3331 if (PrevInit->isAnyMemberInitializer()) 3332 D << 0 << PrevInit->getAnyMember()->getDeclName(); 3333 else 3334 D << 1 << PrevInit->getTypeSourceInfo()->getType(); 3335 3336 if (Init->isAnyMemberInitializer()) 3337 D << 0 << Init->getAnyMember()->getDeclName(); 3338 else 3339 D << 1 << Init->getTypeSourceInfo()->getType(); 3340 3341 // Move back to the initializer's location in the ideal list. 3342 for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex) 3343 if (InitKey == IdealInitKeys[IdealIndex]) 3344 break; 3345 3346 assert(IdealIndex != NumIdealInits && 3347 "initializer not found in initializer list"); 3348 } 3349 3350 PrevInit = Init; 3351 } 3352} 3353 3354namespace { 3355bool CheckRedundantInit(Sema &S, 3356 CXXCtorInitializer *Init, 3357 CXXCtorInitializer *&PrevInit) { 3358 if (!PrevInit) { 3359 PrevInit = Init; 3360 return false; 3361 } 3362 3363 if (FieldDecl *Field = Init->getMember()) 3364 S.Diag(Init->getSourceLocation(), 3365 diag::err_multiple_mem_initialization) 3366 << Field->getDeclName() 3367 << Init->getSourceRange(); 3368 else { 3369 const Type *BaseClass = Init->getBaseClass(); 3370 assert(BaseClass && "neither field nor base"); 3371 S.Diag(Init->getSourceLocation(), 3372 diag::err_multiple_base_initialization) 3373 << QualType(BaseClass, 0) 3374 << Init->getSourceRange(); 3375 } 3376 S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer) 3377 << 0 << PrevInit->getSourceRange(); 3378 3379 return true; 3380} 3381 3382typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry; 3383typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap; 3384 3385bool CheckRedundantUnionInit(Sema &S, 3386 CXXCtorInitializer *Init, 3387 RedundantUnionMap &Unions) { 3388 FieldDecl *Field = Init->getAnyMember(); 3389 RecordDecl *Parent = Field->getParent(); 3390 NamedDecl *Child = Field; 3391 3392 while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) { 3393 if (Parent->isUnion()) { 3394 UnionEntry &En = Unions[Parent]; 3395 if (En.first && En.first != Child) { 3396 S.Diag(Init->getSourceLocation(), 3397 diag::err_multiple_mem_union_initialization) 3398 << Field->getDeclName() 3399 << Init->getSourceRange(); 3400 S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer) 3401 << 0 << En.second->getSourceRange(); 3402 return true; 3403 } 3404 if (!En.first) { 3405 En.first = Child; 3406 En.second = Init; 3407 } 3408 if (!Parent->isAnonymousStructOrUnion()) 3409 return false; 3410 } 3411 3412 Child = Parent; 3413 Parent = cast<RecordDecl>(Parent->getDeclContext()); 3414 } 3415 3416 return false; 3417} 3418} 3419 3420/// ActOnMemInitializers - Handle the member initializers for a constructor. 3421void Sema::ActOnMemInitializers(Decl *ConstructorDecl, 3422 SourceLocation ColonLoc, 3423 CXXCtorInitializer **meminits, 3424 unsigned NumMemInits, 3425 bool AnyErrors) { 3426 if (!ConstructorDecl) 3427 return; 3428 3429 AdjustDeclIfTemplate(ConstructorDecl); 3430 3431 CXXConstructorDecl *Constructor 3432 = dyn_cast<CXXConstructorDecl>(ConstructorDecl); 3433 3434 if (!Constructor) { 3435 Diag(ColonLoc, diag::err_only_constructors_take_base_inits); 3436 return; 3437 } 3438 3439 CXXCtorInitializer **MemInits = 3440 reinterpret_cast<CXXCtorInitializer **>(meminits); 3441 3442 // Mapping for the duplicate initializers check. 3443 // For member initializers, this is keyed with a FieldDecl*. 3444 // For base initializers, this is keyed with a Type*. 3445 llvm::DenseMap<void*, CXXCtorInitializer *> Members; 3446 3447 // Mapping for the inconsistent anonymous-union initializers check. 3448 RedundantUnionMap MemberUnions; 3449 3450 bool HadError = false; 3451 for (unsigned i = 0; i < NumMemInits; i++) { 3452 CXXCtorInitializer *Init = MemInits[i]; 3453 3454 // Set the source order index. 3455 Init->setSourceOrder(i); 3456 3457 if (Init->isAnyMemberInitializer()) { 3458 FieldDecl *Field = Init->getAnyMember(); 3459 if (CheckRedundantInit(*this, Init, Members[Field]) || 3460 CheckRedundantUnionInit(*this, Init, MemberUnions)) 3461 HadError = true; 3462 } else if (Init->isBaseInitializer()) { 3463 void *Key = GetKeyForBase(Context, QualType(Init->getBaseClass(), 0)); 3464 if (CheckRedundantInit(*this, Init, Members[Key])) 3465 HadError = true; 3466 } else { 3467 assert(Init->isDelegatingInitializer()); 3468 // This must be the only initializer 3469 if (NumMemInits != 1) { 3470 Diag(Init->getSourceLocation(), 3471 diag::err_delegating_initializer_alone) 3472 << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange(); 3473 // We will treat this as being the only initializer. 3474 } 3475 SetDelegatingInitializer(Constructor, MemInits[i]); 3476 // Return immediately as the initializer is set. 3477 return; 3478 } 3479 } 3480 3481 if (HadError) 3482 return; 3483 3484 DiagnoseBaseOrMemInitializerOrder(*this, Constructor, MemInits, NumMemInits); 3485 3486 SetCtorInitializers(Constructor, MemInits, NumMemInits, AnyErrors); 3487} 3488 3489void 3490Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location, 3491 CXXRecordDecl *ClassDecl) { 3492 // Ignore dependent contexts. Also ignore unions, since their members never 3493 // have destructors implicitly called. 3494 if (ClassDecl->isDependentContext() || ClassDecl->isUnion()) 3495 return; 3496 3497 // FIXME: all the access-control diagnostics are positioned on the 3498 // field/base declaration. That's probably good; that said, the 3499 // user might reasonably want to know why the destructor is being 3500 // emitted, and we currently don't say. 3501 3502 // Non-static data members. 3503 for (CXXRecordDecl::field_iterator I = ClassDecl->field_begin(), 3504 E = ClassDecl->field_end(); I != E; ++I) { 3505 FieldDecl *Field = *I; 3506 if (Field->isInvalidDecl()) 3507 continue; 3508 3509 // Don't destroy incomplete or zero-length arrays. 3510 if (isIncompleteOrZeroLengthArrayType(Context, Field->getType())) 3511 continue; 3512 3513 QualType FieldType = Context.getBaseElementType(Field->getType()); 3514 3515 const RecordType* RT = FieldType->getAs<RecordType>(); 3516 if (!RT) 3517 continue; 3518 3519 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 3520 if (FieldClassDecl->isInvalidDecl()) 3521 continue; 3522 if (FieldClassDecl->hasIrrelevantDestructor()) 3523 continue; 3524 // The destructor for an implicit anonymous union member is never invoked. 3525 if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion()) 3526 continue; 3527 3528 CXXDestructorDecl *Dtor = LookupDestructor(FieldClassDecl); 3529 assert(Dtor && "No dtor found for FieldClassDecl!"); 3530 CheckDestructorAccess(Field->getLocation(), Dtor, 3531 PDiag(diag::err_access_dtor_field) 3532 << Field->getDeclName() 3533 << FieldType); 3534 3535 MarkFunctionReferenced(Location, const_cast<CXXDestructorDecl*>(Dtor)); 3536 DiagnoseUseOfDecl(Dtor, Location); 3537 } 3538 3539 llvm::SmallPtrSet<const RecordType *, 8> DirectVirtualBases; 3540 3541 // Bases. 3542 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), 3543 E = ClassDecl->bases_end(); Base != E; ++Base) { 3544 // Bases are always records in a well-formed non-dependent class. 3545 const RecordType *RT = Base->getType()->getAs<RecordType>(); 3546 3547 // Remember direct virtual bases. 3548 if (Base->isVirtual()) 3549 DirectVirtualBases.insert(RT); 3550 3551 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 3552 // If our base class is invalid, we probably can't get its dtor anyway. 3553 if (BaseClassDecl->isInvalidDecl()) 3554 continue; 3555 if (BaseClassDecl->hasIrrelevantDestructor()) 3556 continue; 3557 3558 CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl); 3559 assert(Dtor && "No dtor found for BaseClassDecl!"); 3560 3561 // FIXME: caret should be on the start of the class name 3562 CheckDestructorAccess(Base->getLocStart(), Dtor, 3563 PDiag(diag::err_access_dtor_base) 3564 << Base->getType() 3565 << Base->getSourceRange(), 3566 Context.getTypeDeclType(ClassDecl)); 3567 3568 MarkFunctionReferenced(Location, const_cast<CXXDestructorDecl*>(Dtor)); 3569 DiagnoseUseOfDecl(Dtor, Location); 3570 } 3571 3572 // Virtual bases. 3573 for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(), 3574 E = ClassDecl->vbases_end(); VBase != E; ++VBase) { 3575 3576 // Bases are always records in a well-formed non-dependent class. 3577 const RecordType *RT = VBase->getType()->castAs<RecordType>(); 3578 3579 // Ignore direct virtual bases. 3580 if (DirectVirtualBases.count(RT)) 3581 continue; 3582 3583 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 3584 // If our base class is invalid, we probably can't get its dtor anyway. 3585 if (BaseClassDecl->isInvalidDecl()) 3586 continue; 3587 if (BaseClassDecl->hasIrrelevantDestructor()) 3588 continue; 3589 3590 CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl); 3591 assert(Dtor && "No dtor found for BaseClassDecl!"); 3592 CheckDestructorAccess(ClassDecl->getLocation(), Dtor, 3593 PDiag(diag::err_access_dtor_vbase) 3594 << VBase->getType(), 3595 Context.getTypeDeclType(ClassDecl)); 3596 3597 MarkFunctionReferenced(Location, const_cast<CXXDestructorDecl*>(Dtor)); 3598 DiagnoseUseOfDecl(Dtor, Location); 3599 } 3600} 3601 3602void Sema::ActOnDefaultCtorInitializers(Decl *CDtorDecl) { 3603 if (!CDtorDecl) 3604 return; 3605 3606 if (CXXConstructorDecl *Constructor 3607 = dyn_cast<CXXConstructorDecl>(CDtorDecl)) 3608 SetCtorInitializers(Constructor, 0, 0, /*AnyErrors=*/false); 3609} 3610 3611bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T, 3612 unsigned DiagID, AbstractDiagSelID SelID) { 3613 class NonAbstractTypeDiagnoser : public TypeDiagnoser { 3614 unsigned DiagID; 3615 AbstractDiagSelID SelID; 3616 3617 public: 3618 NonAbstractTypeDiagnoser(unsigned DiagID, AbstractDiagSelID SelID) 3619 : TypeDiagnoser(DiagID == 0), DiagID(DiagID), SelID(SelID) { } 3620 3621 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) { 3622 if (Suppressed) return; 3623 if (SelID == -1) 3624 S.Diag(Loc, DiagID) << T; 3625 else 3626 S.Diag(Loc, DiagID) << SelID << T; 3627 } 3628 } Diagnoser(DiagID, SelID); 3629 3630 return RequireNonAbstractType(Loc, T, Diagnoser); 3631} 3632 3633bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T, 3634 TypeDiagnoser &Diagnoser) { 3635 if (!getLangOpts().CPlusPlus) 3636 return false; 3637 3638 if (const ArrayType *AT = Context.getAsArrayType(T)) 3639 return RequireNonAbstractType(Loc, AT->getElementType(), Diagnoser); 3640 3641 if (const PointerType *PT = T->getAs<PointerType>()) { 3642 // Find the innermost pointer type. 3643 while (const PointerType *T = PT->getPointeeType()->getAs<PointerType>()) 3644 PT = T; 3645 3646 if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType())) 3647 return RequireNonAbstractType(Loc, AT->getElementType(), Diagnoser); 3648 } 3649 3650 const RecordType *RT = T->getAs<RecordType>(); 3651 if (!RT) 3652 return false; 3653 3654 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 3655 3656 // We can't answer whether something is abstract until it has a 3657 // definition. If it's currently being defined, we'll walk back 3658 // over all the declarations when we have a full definition. 3659 const CXXRecordDecl *Def = RD->getDefinition(); 3660 if (!Def || Def->isBeingDefined()) 3661 return false; 3662 3663 if (!RD->isAbstract()) 3664 return false; 3665 3666 Diagnoser.diagnose(*this, Loc, T); 3667 DiagnoseAbstractType(RD); 3668 3669 return true; 3670} 3671 3672void Sema::DiagnoseAbstractType(const CXXRecordDecl *RD) { 3673 // Check if we've already emitted the list of pure virtual functions 3674 // for this class. 3675 if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD)) 3676 return; 3677 3678 CXXFinalOverriderMap FinalOverriders; 3679 RD->getFinalOverriders(FinalOverriders); 3680 3681 // Keep a set of seen pure methods so we won't diagnose the same method 3682 // more than once. 3683 llvm::SmallPtrSet<const CXXMethodDecl *, 8> SeenPureMethods; 3684 3685 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(), 3686 MEnd = FinalOverriders.end(); 3687 M != MEnd; 3688 ++M) { 3689 for (OverridingMethods::iterator SO = M->second.begin(), 3690 SOEnd = M->second.end(); 3691 SO != SOEnd; ++SO) { 3692 // C++ [class.abstract]p4: 3693 // A class is abstract if it contains or inherits at least one 3694 // pure virtual function for which the final overrider is pure 3695 // virtual. 3696 3697 // 3698 if (SO->second.size() != 1) 3699 continue; 3700 3701 if (!SO->second.front().Method->isPure()) 3702 continue; 3703 3704 if (!SeenPureMethods.insert(SO->second.front().Method)) 3705 continue; 3706 3707 Diag(SO->second.front().Method->getLocation(), 3708 diag::note_pure_virtual_function) 3709 << SO->second.front().Method->getDeclName() << RD->getDeclName(); 3710 } 3711 } 3712 3713 if (!PureVirtualClassDiagSet) 3714 PureVirtualClassDiagSet.reset(new RecordDeclSetTy); 3715 PureVirtualClassDiagSet->insert(RD); 3716} 3717 3718namespace { 3719struct AbstractUsageInfo { 3720 Sema &S; 3721 CXXRecordDecl *Record; 3722 CanQualType AbstractType; 3723 bool Invalid; 3724 3725 AbstractUsageInfo(Sema &S, CXXRecordDecl *Record) 3726 : S(S), Record(Record), 3727 AbstractType(S.Context.getCanonicalType( 3728 S.Context.getTypeDeclType(Record))), 3729 Invalid(false) {} 3730 3731 void DiagnoseAbstractType() { 3732 if (Invalid) return; 3733 S.DiagnoseAbstractType(Record); 3734 Invalid = true; 3735 } 3736 3737 void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel); 3738}; 3739 3740struct CheckAbstractUsage { 3741 AbstractUsageInfo &Info; 3742 const NamedDecl *Ctx; 3743 3744 CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx) 3745 : Info(Info), Ctx(Ctx) {} 3746 3747 void Visit(TypeLoc TL, Sema::AbstractDiagSelID Sel) { 3748 switch (TL.getTypeLocClass()) { 3749#define ABSTRACT_TYPELOC(CLASS, PARENT) 3750#define TYPELOC(CLASS, PARENT) \ 3751 case TypeLoc::CLASS: Check(cast<CLASS##TypeLoc>(TL), Sel); break; 3752#include "clang/AST/TypeLocNodes.def" 3753 } 3754 } 3755 3756 void Check(FunctionProtoTypeLoc TL, Sema::AbstractDiagSelID Sel) { 3757 Visit(TL.getResultLoc(), Sema::AbstractReturnType); 3758 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) { 3759 if (!TL.getArg(I)) 3760 continue; 3761 3762 TypeSourceInfo *TSI = TL.getArg(I)->getTypeSourceInfo(); 3763 if (TSI) Visit(TSI->getTypeLoc(), Sema::AbstractParamType); 3764 } 3765 } 3766 3767 void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) { 3768 Visit(TL.getElementLoc(), Sema::AbstractArrayType); 3769 } 3770 3771 void Check(TemplateSpecializationTypeLoc TL, Sema::AbstractDiagSelID Sel) { 3772 // Visit the type parameters from a permissive context. 3773 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) { 3774 TemplateArgumentLoc TAL = TL.getArgLoc(I); 3775 if (TAL.getArgument().getKind() == TemplateArgument::Type) 3776 if (TypeSourceInfo *TSI = TAL.getTypeSourceInfo()) 3777 Visit(TSI->getTypeLoc(), Sema::AbstractNone); 3778 // TODO: other template argument types? 3779 } 3780 } 3781 3782 // Visit pointee types from a permissive context. 3783#define CheckPolymorphic(Type) \ 3784 void Check(Type TL, Sema::AbstractDiagSelID Sel) { \ 3785 Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \ 3786 } 3787 CheckPolymorphic(PointerTypeLoc) 3788 CheckPolymorphic(ReferenceTypeLoc) 3789 CheckPolymorphic(MemberPointerTypeLoc) 3790 CheckPolymorphic(BlockPointerTypeLoc) 3791 CheckPolymorphic(AtomicTypeLoc) 3792 3793 /// Handle all the types we haven't given a more specific 3794 /// implementation for above. 3795 void Check(TypeLoc TL, Sema::AbstractDiagSelID Sel) { 3796 // Every other kind of type that we haven't called out already 3797 // that has an inner type is either (1) sugar or (2) contains that 3798 // inner type in some way as a subobject. 3799 if (TypeLoc Next = TL.getNextTypeLoc()) 3800 return Visit(Next, Sel); 3801 3802 // If there's no inner type and we're in a permissive context, 3803 // don't diagnose. 3804 if (Sel == Sema::AbstractNone) return; 3805 3806 // Check whether the type matches the abstract type. 3807 QualType T = TL.getType(); 3808 if (T->isArrayType()) { 3809 Sel = Sema::AbstractArrayType; 3810 T = Info.S.Context.getBaseElementType(T); 3811 } 3812 CanQualType CT = T->getCanonicalTypeUnqualified().getUnqualifiedType(); 3813 if (CT != Info.AbstractType) return; 3814 3815 // It matched; do some magic. 3816 if (Sel == Sema::AbstractArrayType) { 3817 Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type) 3818 << T << TL.getSourceRange(); 3819 } else { 3820 Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl) 3821 << Sel << T << TL.getSourceRange(); 3822 } 3823 Info.DiagnoseAbstractType(); 3824 } 3825}; 3826 3827void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL, 3828 Sema::AbstractDiagSelID Sel) { 3829 CheckAbstractUsage(*this, D).Visit(TL, Sel); 3830} 3831 3832} 3833 3834/// Check for invalid uses of an abstract type in a method declaration. 3835static void CheckAbstractClassUsage(AbstractUsageInfo &Info, 3836 CXXMethodDecl *MD) { 3837 // No need to do the check on definitions, which require that 3838 // the return/param types be complete. 3839 if (MD->doesThisDeclarationHaveABody()) 3840 return; 3841 3842 // For safety's sake, just ignore it if we don't have type source 3843 // information. This should never happen for non-implicit methods, 3844 // but... 3845 if (TypeSourceInfo *TSI = MD->getTypeSourceInfo()) 3846 Info.CheckType(MD, TSI->getTypeLoc(), Sema::AbstractNone); 3847} 3848 3849/// Check for invalid uses of an abstract type within a class definition. 3850static void CheckAbstractClassUsage(AbstractUsageInfo &Info, 3851 CXXRecordDecl *RD) { 3852 for (CXXRecordDecl::decl_iterator 3853 I = RD->decls_begin(), E = RD->decls_end(); I != E; ++I) { 3854 Decl *D = *I; 3855 if (D->isImplicit()) continue; 3856 3857 // Methods and method templates. 3858 if (isa<CXXMethodDecl>(D)) { 3859 CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(D)); 3860 } else if (isa<FunctionTemplateDecl>(D)) { 3861 FunctionDecl *FD = cast<FunctionTemplateDecl>(D)->getTemplatedDecl(); 3862 CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(FD)); 3863 3864 // Fields and static variables. 3865 } else if (isa<FieldDecl>(D)) { 3866 FieldDecl *FD = cast<FieldDecl>(D); 3867 if (TypeSourceInfo *TSI = FD->getTypeSourceInfo()) 3868 Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractFieldType); 3869 } else if (isa<VarDecl>(D)) { 3870 VarDecl *VD = cast<VarDecl>(D); 3871 if (TypeSourceInfo *TSI = VD->getTypeSourceInfo()) 3872 Info.CheckType(VD, TSI->getTypeLoc(), Sema::AbstractVariableType); 3873 3874 // Nested classes and class templates. 3875 } else if (isa<CXXRecordDecl>(D)) { 3876 CheckAbstractClassUsage(Info, cast<CXXRecordDecl>(D)); 3877 } else if (isa<ClassTemplateDecl>(D)) { 3878 CheckAbstractClassUsage(Info, 3879 cast<ClassTemplateDecl>(D)->getTemplatedDecl()); 3880 } 3881 } 3882} 3883 3884/// \brief Perform semantic checks on a class definition that has been 3885/// completing, introducing implicitly-declared members, checking for 3886/// abstract types, etc. 3887void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) { 3888 if (!Record) 3889 return; 3890 3891 if (Record->isAbstract() && !Record->isInvalidDecl()) { 3892 AbstractUsageInfo Info(*this, Record); 3893 CheckAbstractClassUsage(Info, Record); 3894 } 3895 3896 // If this is not an aggregate type and has no user-declared constructor, 3897 // complain about any non-static data members of reference or const scalar 3898 // type, since they will never get initializers. 3899 if (!Record->isInvalidDecl() && !Record->isDependentType() && 3900 !Record->isAggregate() && !Record->hasUserDeclaredConstructor() && 3901 !Record->isLambda()) { 3902 bool Complained = false; 3903 for (RecordDecl::field_iterator F = Record->field_begin(), 3904 FEnd = Record->field_end(); 3905 F != FEnd; ++F) { 3906 if (F->hasInClassInitializer() || F->isUnnamedBitfield()) 3907 continue; 3908 3909 if (F->getType()->isReferenceType() || 3910 (F->getType().isConstQualified() && F->getType()->isScalarType())) { 3911 if (!Complained) { 3912 Diag(Record->getLocation(), diag::warn_no_constructor_for_refconst) 3913 << Record->getTagKind() << Record; 3914 Complained = true; 3915 } 3916 3917 Diag(F->getLocation(), diag::note_refconst_member_not_initialized) 3918 << F->getType()->isReferenceType() 3919 << F->getDeclName(); 3920 } 3921 } 3922 } 3923 3924 if (Record->isDynamicClass() && !Record->isDependentType()) 3925 DynamicClasses.push_back(Record); 3926 3927 if (Record->getIdentifier()) { 3928 // C++ [class.mem]p13: 3929 // If T is the name of a class, then each of the following shall have a 3930 // name different from T: 3931 // - every member of every anonymous union that is a member of class T. 3932 // 3933 // C++ [class.mem]p14: 3934 // In addition, if class T has a user-declared constructor (12.1), every 3935 // non-static data member of class T shall have a name different from T. 3936 for (DeclContext::lookup_result R = Record->lookup(Record->getDeclName()); 3937 R.first != R.second; ++R.first) { 3938 NamedDecl *D = *R.first; 3939 if ((isa<FieldDecl>(D) && Record->hasUserDeclaredConstructor()) || 3940 isa<IndirectFieldDecl>(D)) { 3941 Diag(D->getLocation(), diag::err_member_name_of_class) 3942 << D->getDeclName(); 3943 break; 3944 } 3945 } 3946 } 3947 3948 // Warn if the class has virtual methods but non-virtual public destructor. 3949 if (Record->isPolymorphic() && !Record->isDependentType()) { 3950 CXXDestructorDecl *dtor = Record->getDestructor(); 3951 if (!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public)) 3952 Diag(dtor ? dtor->getLocation() : Record->getLocation(), 3953 diag::warn_non_virtual_dtor) << Context.getRecordType(Record); 3954 } 3955 3956 if (Record->isAbstract() && Record->hasAttr<FinalAttr>()) { 3957 Diag(Record->getLocation(), diag::warn_abstract_final_class); 3958 DiagnoseAbstractType(Record); 3959 } 3960 3961 // See if a method overloads virtual methods in a base 3962 /// class without overriding any. 3963 if (!Record->isDependentType()) { 3964 for (CXXRecordDecl::method_iterator M = Record->method_begin(), 3965 MEnd = Record->method_end(); 3966 M != MEnd; ++M) { 3967 if (!M->isStatic()) 3968 DiagnoseHiddenVirtualMethods(Record, *M); 3969 } 3970 } 3971 3972 // C++0x [dcl.constexpr]p8: A constexpr specifier for a non-static member 3973 // function that is not a constructor declares that member function to be 3974 // const. [...] The class of which that function is a member shall be 3975 // a literal type. 3976 // 3977 // If the class has virtual bases, any constexpr members will already have 3978 // been diagnosed by the checks performed on the member declaration, so 3979 // suppress this (less useful) diagnostic. 3980 if (LangOpts.CPlusPlus0x && !Record->isDependentType() && 3981 !Record->isLiteral() && !Record->getNumVBases()) { 3982 for (CXXRecordDecl::method_iterator M = Record->method_begin(), 3983 MEnd = Record->method_end(); 3984 M != MEnd; ++M) { 3985 if (M->isConstexpr() && M->isInstance() && !isa<CXXConstructorDecl>(*M)) { 3986 switch (Record->getTemplateSpecializationKind()) { 3987 case TSK_ImplicitInstantiation: 3988 case TSK_ExplicitInstantiationDeclaration: 3989 case TSK_ExplicitInstantiationDefinition: 3990 // If a template instantiates to a non-literal type, but its members 3991 // instantiate to constexpr functions, the template is technically 3992 // ill-formed, but we allow it for sanity. 3993 continue; 3994 3995 case TSK_Undeclared: 3996 case TSK_ExplicitSpecialization: 3997 RequireLiteralType(M->getLocation(), Context.getRecordType(Record), 3998 diag::err_constexpr_method_non_literal); 3999 break; 4000 } 4001 4002 // Only produce one error per class. 4003 break; 4004 } 4005 } 4006 } 4007 4008 // Declare inherited constructors. We do this eagerly here because: 4009 // - The standard requires an eager diagnostic for conflicting inherited 4010 // constructors from different classes. 4011 // - The lazy declaration of the other implicit constructors is so as to not 4012 // waste space and performance on classes that are not meant to be 4013 // instantiated (e.g. meta-functions). This doesn't apply to classes that 4014 // have inherited constructors. 4015 DeclareInheritedConstructors(Record); 4016} 4017 4018void Sema::CheckExplicitlyDefaultedMethods(CXXRecordDecl *Record) { 4019 for (CXXRecordDecl::method_iterator MI = Record->method_begin(), 4020 ME = Record->method_end(); 4021 MI != ME; ++MI) 4022 if (!MI->isInvalidDecl() && MI->isExplicitlyDefaulted()) 4023 CheckExplicitlyDefaultedSpecialMember(*MI); 4024} 4025 4026/// Is the special member function which would be selected to perform the 4027/// specified operation on the specified class type a constexpr constructor? 4028static bool specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, 4029 Sema::CXXSpecialMember CSM, 4030 bool ConstArg) { 4031 Sema::SpecialMemberOverloadResult *SMOR = 4032 S.LookupSpecialMember(ClassDecl, CSM, ConstArg, 4033 false, false, false, false); 4034 if (!SMOR || !SMOR->getMethod()) 4035 // A constructor we wouldn't select can't be "involved in initializing" 4036 // anything. 4037 return true; 4038 return SMOR->getMethod()->isConstexpr(); 4039} 4040 4041/// Determine whether the specified special member function would be constexpr 4042/// if it were implicitly defined. 4043static bool defaultedSpecialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, 4044 Sema::CXXSpecialMember CSM, 4045 bool ConstArg) { 4046 if (!S.getLangOpts().CPlusPlus0x) 4047 return false; 4048 4049 // C++11 [dcl.constexpr]p4: 4050 // In the definition of a constexpr constructor [...] 4051 switch (CSM) { 4052 case Sema::CXXDefaultConstructor: 4053 // Since default constructor lookup is essentially trivial (and cannot 4054 // involve, for instance, template instantiation), we compute whether a 4055 // defaulted default constructor is constexpr directly within CXXRecordDecl. 4056 // 4057 // This is important for performance; we need to know whether the default 4058 // constructor is constexpr to determine whether the type is a literal type. 4059 return ClassDecl->defaultedDefaultConstructorIsConstexpr(); 4060 4061 case Sema::CXXCopyConstructor: 4062 case Sema::CXXMoveConstructor: 4063 // For copy or move constructors, we need to perform overload resolution. 4064 break; 4065 4066 case Sema::CXXCopyAssignment: 4067 case Sema::CXXMoveAssignment: 4068 case Sema::CXXDestructor: 4069 case Sema::CXXInvalid: 4070 return false; 4071 } 4072 4073 // -- if the class is a non-empty union, or for each non-empty anonymous 4074 // union member of a non-union class, exactly one non-static data member 4075 // shall be initialized; [DR1359] 4076 // 4077 // If we squint, this is guaranteed, since exactly one non-static data member 4078 // will be initialized (if the constructor isn't deleted), we just don't know 4079 // which one. 4080 if (ClassDecl->isUnion()) 4081 return true; 4082 4083 // -- the class shall not have any virtual base classes; 4084 if (ClassDecl->getNumVBases()) 4085 return false; 4086 4087 // -- every constructor involved in initializing [...] base class 4088 // sub-objects shall be a constexpr constructor; 4089 for (CXXRecordDecl::base_class_iterator B = ClassDecl->bases_begin(), 4090 BEnd = ClassDecl->bases_end(); 4091 B != BEnd; ++B) { 4092 const RecordType *BaseType = B->getType()->getAs<RecordType>(); 4093 if (!BaseType) continue; 4094 4095 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl()); 4096 if (!specialMemberIsConstexpr(S, BaseClassDecl, CSM, ConstArg)) 4097 return false; 4098 } 4099 4100 // -- every constructor involved in initializing non-static data members 4101 // [...] shall be a constexpr constructor; 4102 // -- every non-static data member and base class sub-object shall be 4103 // initialized 4104 for (RecordDecl::field_iterator F = ClassDecl->field_begin(), 4105 FEnd = ClassDecl->field_end(); 4106 F != FEnd; ++F) { 4107 if (F->isInvalidDecl()) 4108 continue; 4109 if (const RecordType *RecordTy = 4110 S.Context.getBaseElementType(F->getType())->getAs<RecordType>()) { 4111 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl()); 4112 if (!specialMemberIsConstexpr(S, FieldRecDecl, CSM, ConstArg)) 4113 return false; 4114 } 4115 } 4116 4117 // All OK, it's constexpr! 4118 return true; 4119} 4120 4121static Sema::ImplicitExceptionSpecification 4122computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, CXXMethodDecl *MD) { 4123 switch (S.getSpecialMember(MD)) { 4124 case Sema::CXXDefaultConstructor: 4125 return S.ComputeDefaultedDefaultCtorExceptionSpec(Loc, MD); 4126 case Sema::CXXCopyConstructor: 4127 return S.ComputeDefaultedCopyCtorExceptionSpec(MD); 4128 case Sema::CXXCopyAssignment: 4129 return S.ComputeDefaultedCopyAssignmentExceptionSpec(MD); 4130 case Sema::CXXMoveConstructor: 4131 return S.ComputeDefaultedMoveCtorExceptionSpec(MD); 4132 case Sema::CXXMoveAssignment: 4133 return S.ComputeDefaultedMoveAssignmentExceptionSpec(MD); 4134 case Sema::CXXDestructor: 4135 return S.ComputeDefaultedDtorExceptionSpec(MD); 4136 case Sema::CXXInvalid: 4137 break; 4138 } 4139 llvm_unreachable("only special members have implicit exception specs"); 4140} 4141 4142static void 4143updateExceptionSpec(Sema &S, FunctionDecl *FD, const FunctionProtoType *FPT, 4144 const Sema::ImplicitExceptionSpecification &ExceptSpec) { 4145 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 4146 ExceptSpec.getEPI(EPI); 4147 const FunctionProtoType *NewFPT = cast<FunctionProtoType>( 4148 S.Context.getFunctionType(FPT->getResultType(), FPT->arg_type_begin(), 4149 FPT->getNumArgs(), EPI)); 4150 FD->setType(QualType(NewFPT, 0)); 4151} 4152 4153void Sema::EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD) { 4154 const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>(); 4155 if (FPT->getExceptionSpecType() != EST_Unevaluated) 4156 return; 4157 4158 // Evaluate the exception specification. 4159 ImplicitExceptionSpecification ExceptSpec = 4160 computeImplicitExceptionSpec(*this, Loc, MD); 4161 4162 // Update the type of the special member to use it. 4163 updateExceptionSpec(*this, MD, FPT, ExceptSpec); 4164 4165 // A user-provided destructor can be defined outside the class. When that 4166 // happens, be sure to update the exception specification on both 4167 // declarations. 4168 const FunctionProtoType *CanonicalFPT = 4169 MD->getCanonicalDecl()->getType()->castAs<FunctionProtoType>(); 4170 if (CanonicalFPT->getExceptionSpecType() == EST_Unevaluated) 4171 updateExceptionSpec(*this, MD->getCanonicalDecl(), 4172 CanonicalFPT, ExceptSpec); 4173} 4174 4175static bool isImplicitCopyCtorArgConst(Sema &S, CXXRecordDecl *ClassDecl); 4176static bool isImplicitCopyAssignmentArgConst(Sema &S, CXXRecordDecl *ClassDecl); 4177 4178void Sema::CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD) { 4179 CXXRecordDecl *RD = MD->getParent(); 4180 CXXSpecialMember CSM = getSpecialMember(MD); 4181 4182 assert(MD->isExplicitlyDefaulted() && CSM != CXXInvalid && 4183 "not an explicitly-defaulted special member"); 4184 4185 // Whether this was the first-declared instance of the constructor. 4186 // This affects whether we implicitly add an exception spec and constexpr. 4187 bool First = MD == MD->getCanonicalDecl(); 4188 4189 bool HadError = false; 4190 4191 // C++11 [dcl.fct.def.default]p1: 4192 // A function that is explicitly defaulted shall 4193 // -- be a special member function (checked elsewhere), 4194 // -- have the same type (except for ref-qualifiers, and except that a 4195 // copy operation can take a non-const reference) as an implicit 4196 // declaration, and 4197 // -- not have default arguments. 4198 unsigned ExpectedParams = 1; 4199 if (CSM == CXXDefaultConstructor || CSM == CXXDestructor) 4200 ExpectedParams = 0; 4201 if (MD->getNumParams() != ExpectedParams) { 4202 // This also checks for default arguments: a copy or move constructor with a 4203 // default argument is classified as a default constructor, and assignment 4204 // operations and destructors can't have default arguments. 4205 Diag(MD->getLocation(), diag::err_defaulted_special_member_params) 4206 << CSM << MD->getSourceRange(); 4207 HadError = true; 4208 } 4209 4210 const FunctionProtoType *Type = MD->getType()->getAs<FunctionProtoType>(); 4211 4212 // Compute argument constness, constexpr, and triviality. 4213 bool CanHaveConstParam = false; 4214 bool Trivial = false; 4215 switch (CSM) { 4216 case CXXDefaultConstructor: 4217 Trivial = RD->hasTrivialDefaultConstructor(); 4218 break; 4219 case CXXCopyConstructor: 4220 CanHaveConstParam = isImplicitCopyCtorArgConst(*this, RD); 4221 Trivial = RD->hasTrivialCopyConstructor(); 4222 break; 4223 case CXXCopyAssignment: 4224 CanHaveConstParam = isImplicitCopyAssignmentArgConst(*this, RD); 4225 Trivial = RD->hasTrivialCopyAssignment(); 4226 break; 4227 case CXXMoveConstructor: 4228 Trivial = RD->hasTrivialMoveConstructor(); 4229 break; 4230 case CXXMoveAssignment: 4231 Trivial = RD->hasTrivialMoveAssignment(); 4232 break; 4233 case CXXDestructor: 4234 Trivial = RD->hasTrivialDestructor(); 4235 break; 4236 case CXXInvalid: 4237 llvm_unreachable("non-special member explicitly defaulted!"); 4238 } 4239 4240 QualType ReturnType = Context.VoidTy; 4241 if (CSM == CXXCopyAssignment || CSM == CXXMoveAssignment) { 4242 // Check for return type matching. 4243 ReturnType = Type->getResultType(); 4244 QualType ExpectedReturnType = 4245 Context.getLValueReferenceType(Context.getTypeDeclType(RD)); 4246 if (!Context.hasSameType(ReturnType, ExpectedReturnType)) { 4247 Diag(MD->getLocation(), diag::err_defaulted_special_member_return_type) 4248 << (CSM == CXXMoveAssignment) << ExpectedReturnType; 4249 HadError = true; 4250 } 4251 4252 // A defaulted special member cannot have cv-qualifiers. 4253 if (Type->getTypeQuals()) { 4254 Diag(MD->getLocation(), diag::err_defaulted_special_member_quals) 4255 << (CSM == CXXMoveAssignment); 4256 HadError = true; 4257 } 4258 } 4259 4260 // Check for parameter type matching. 4261 QualType ArgType = ExpectedParams ? Type->getArgType(0) : QualType(); 4262 bool HasConstParam = false; 4263 if (ExpectedParams && ArgType->isReferenceType()) { 4264 // Argument must be reference to possibly-const T. 4265 QualType ReferentType = ArgType->getPointeeType(); 4266 HasConstParam = ReferentType.isConstQualified(); 4267 4268 if (ReferentType.isVolatileQualified()) { 4269 Diag(MD->getLocation(), 4270 diag::err_defaulted_special_member_volatile_param) << CSM; 4271 HadError = true; 4272 } 4273 4274 if (HasConstParam && !CanHaveConstParam) { 4275 if (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment) { 4276 Diag(MD->getLocation(), 4277 diag::err_defaulted_special_member_copy_const_param) 4278 << (CSM == CXXCopyAssignment); 4279 // FIXME: Explain why this special member can't be const. 4280 } else { 4281 Diag(MD->getLocation(), 4282 diag::err_defaulted_special_member_move_const_param) 4283 << (CSM == CXXMoveAssignment); 4284 } 4285 HadError = true; 4286 } 4287 4288 // If a function is explicitly defaulted on its first declaration, it shall 4289 // have the same parameter type as if it had been implicitly declared. 4290 // (Presumably this is to prevent it from being trivial?) 4291 if (!HasConstParam && CanHaveConstParam && First) 4292 Diag(MD->getLocation(), 4293 diag::err_defaulted_special_member_copy_non_const_param) 4294 << (CSM == CXXCopyAssignment); 4295 } else if (ExpectedParams) { 4296 // A copy assignment operator can take its argument by value, but a 4297 // defaulted one cannot. 4298 assert(CSM == CXXCopyAssignment && "unexpected non-ref argument"); 4299 Diag(MD->getLocation(), diag::err_defaulted_copy_assign_not_ref); 4300 HadError = true; 4301 } 4302 4303 // Rebuild the type with the implicit exception specification added, if we 4304 // are going to need it. 4305 const FunctionProtoType *ImplicitType = 0; 4306 if (First || Type->hasExceptionSpec()) { 4307 FunctionProtoType::ExtProtoInfo EPI = Type->getExtProtoInfo(); 4308 computeImplicitExceptionSpec(*this, MD->getLocation(), MD).getEPI(EPI); 4309 ImplicitType = cast<FunctionProtoType>( 4310 Context.getFunctionType(ReturnType, &ArgType, ExpectedParams, EPI)); 4311 } 4312 4313 // C++11 [dcl.fct.def.default]p2: 4314 // An explicitly-defaulted function may be declared constexpr only if it 4315 // would have been implicitly declared as constexpr, 4316 // Do not apply this rule to members of class templates, since core issue 1358 4317 // makes such functions always instantiate to constexpr functions. For 4318 // non-constructors, this is checked elsewhere. 4319 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM, 4320 HasConstParam); 4321 if (isa<CXXConstructorDecl>(MD) && MD->isConstexpr() && !Constexpr && 4322 MD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) { 4323 Diag(MD->getLocStart(), diag::err_incorrect_defaulted_constexpr) << CSM; 4324 // FIXME: Explain why the constructor can't be constexpr. 4325 HadError = true; 4326 } 4327 // and may have an explicit exception-specification only if it is compatible 4328 // with the exception-specification on the implicit declaration. 4329 if (Type->hasExceptionSpec() && 4330 CheckEquivalentExceptionSpec( 4331 PDiag(diag::err_incorrect_defaulted_exception_spec) << CSM, 4332 PDiag(), ImplicitType, SourceLocation(), Type, MD->getLocation())) 4333 HadError = true; 4334 4335 // If a function is explicitly defaulted on its first declaration, 4336 if (First) { 4337 // -- it is implicitly considered to be constexpr if the implicit 4338 // definition would be, 4339 MD->setConstexpr(Constexpr); 4340 4341 // -- it is implicitly considered to have the same exception-specification 4342 // as if it had been implicitly declared, 4343 MD->setType(QualType(ImplicitType, 0)); 4344 4345 // Such a function is also trivial if the implicitly-declared function 4346 // would have been. 4347 MD->setTrivial(Trivial); 4348 } 4349 4350 if (ShouldDeleteSpecialMember(MD, CSM)) { 4351 if (First) { 4352 MD->setDeletedAsWritten(); 4353 } else { 4354 // C++11 [dcl.fct.def.default]p4: 4355 // [For a] user-provided explicitly-defaulted function [...] if such a 4356 // function is implicitly defined as deleted, the program is ill-formed. 4357 Diag(MD->getLocation(), diag::err_out_of_line_default_deletes) << CSM; 4358 HadError = true; 4359 } 4360 } 4361 4362 if (HadError) 4363 MD->setInvalidDecl(); 4364} 4365 4366namespace { 4367struct SpecialMemberDeletionInfo { 4368 Sema &S; 4369 CXXMethodDecl *MD; 4370 Sema::CXXSpecialMember CSM; 4371 bool Diagnose; 4372 4373 // Properties of the special member, computed for convenience. 4374 bool IsConstructor, IsAssignment, IsMove, ConstArg, VolatileArg; 4375 SourceLocation Loc; 4376 4377 bool AllFieldsAreConst; 4378 4379 SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD, 4380 Sema::CXXSpecialMember CSM, bool Diagnose) 4381 : S(S), MD(MD), CSM(CSM), Diagnose(Diagnose), 4382 IsConstructor(false), IsAssignment(false), IsMove(false), 4383 ConstArg(false), VolatileArg(false), Loc(MD->getLocation()), 4384 AllFieldsAreConst(true) { 4385 switch (CSM) { 4386 case Sema::CXXDefaultConstructor: 4387 case Sema::CXXCopyConstructor: 4388 IsConstructor = true; 4389 break; 4390 case Sema::CXXMoveConstructor: 4391 IsConstructor = true; 4392 IsMove = true; 4393 break; 4394 case Sema::CXXCopyAssignment: 4395 IsAssignment = true; 4396 break; 4397 case Sema::CXXMoveAssignment: 4398 IsAssignment = true; 4399 IsMove = true; 4400 break; 4401 case Sema::CXXDestructor: 4402 break; 4403 case Sema::CXXInvalid: 4404 llvm_unreachable("invalid special member kind"); 4405 } 4406 4407 if (MD->getNumParams()) { 4408 ConstArg = MD->getParamDecl(0)->getType().isConstQualified(); 4409 VolatileArg = MD->getParamDecl(0)->getType().isVolatileQualified(); 4410 } 4411 } 4412 4413 bool inUnion() const { return MD->getParent()->isUnion(); } 4414 4415 /// Look up the corresponding special member in the given class. 4416 Sema::SpecialMemberOverloadResult *lookupIn(CXXRecordDecl *Class, 4417 unsigned Quals) { 4418 unsigned TQ = MD->getTypeQualifiers(); 4419 // cv-qualifiers on class members don't affect default ctor / dtor calls. 4420 if (CSM == Sema::CXXDefaultConstructor || CSM == Sema::CXXDestructor) 4421 Quals = 0; 4422 return S.LookupSpecialMember(Class, CSM, 4423 ConstArg || (Quals & Qualifiers::Const), 4424 VolatileArg || (Quals & Qualifiers::Volatile), 4425 MD->getRefQualifier() == RQ_RValue, 4426 TQ & Qualifiers::Const, 4427 TQ & Qualifiers::Volatile); 4428 } 4429 4430 typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject; 4431 4432 bool shouldDeleteForBase(CXXBaseSpecifier *Base); 4433 bool shouldDeleteForField(FieldDecl *FD); 4434 bool shouldDeleteForAllConstMembers(); 4435 4436 bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj, 4437 unsigned Quals); 4438 bool shouldDeleteForSubobjectCall(Subobject Subobj, 4439 Sema::SpecialMemberOverloadResult *SMOR, 4440 bool IsDtorCallInCtor); 4441 4442 bool isAccessible(Subobject Subobj, CXXMethodDecl *D); 4443}; 4444} 4445 4446/// Is the given special member inaccessible when used on the given 4447/// sub-object. 4448bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj, 4449 CXXMethodDecl *target) { 4450 /// If we're operating on a base class, the object type is the 4451 /// type of this special member. 4452 QualType objectTy; 4453 AccessSpecifier access = target->getAccess(); 4454 if (CXXBaseSpecifier *base = Subobj.dyn_cast<CXXBaseSpecifier*>()) { 4455 objectTy = S.Context.getTypeDeclType(MD->getParent()); 4456 access = CXXRecordDecl::MergeAccess(base->getAccessSpecifier(), access); 4457 4458 // If we're operating on a field, the object type is the type of the field. 4459 } else { 4460 objectTy = S.Context.getTypeDeclType(target->getParent()); 4461 } 4462 4463 return S.isSpecialMemberAccessibleForDeletion(target, access, objectTy); 4464} 4465 4466/// Check whether we should delete a special member due to the implicit 4467/// definition containing a call to a special member of a subobject. 4468bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall( 4469 Subobject Subobj, Sema::SpecialMemberOverloadResult *SMOR, 4470 bool IsDtorCallInCtor) { 4471 CXXMethodDecl *Decl = SMOR->getMethod(); 4472 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>(); 4473 4474 int DiagKind = -1; 4475 4476 if (SMOR->getKind() == Sema::SpecialMemberOverloadResult::NoMemberOrDeleted) 4477 DiagKind = !Decl ? 0 : 1; 4478 else if (SMOR->getKind() == Sema::SpecialMemberOverloadResult::Ambiguous) 4479 DiagKind = 2; 4480 else if (!isAccessible(Subobj, Decl)) 4481 DiagKind = 3; 4482 else if (!IsDtorCallInCtor && Field && Field->getParent()->isUnion() && 4483 !Decl->isTrivial()) { 4484 // A member of a union must have a trivial corresponding special member. 4485 // As a weird special case, a destructor call from a union's constructor 4486 // must be accessible and non-deleted, but need not be trivial. Such a 4487 // destructor is never actually called, but is semantically checked as 4488 // if it were. 4489 DiagKind = 4; 4490 } 4491 4492 if (DiagKind == -1) 4493 return false; 4494 4495 if (Diagnose) { 4496 if (Field) { 4497 S.Diag(Field->getLocation(), 4498 diag::note_deleted_special_member_class_subobject) 4499 << CSM << MD->getParent() << /*IsField*/true 4500 << Field << DiagKind << IsDtorCallInCtor; 4501 } else { 4502 CXXBaseSpecifier *Base = Subobj.get<CXXBaseSpecifier*>(); 4503 S.Diag(Base->getLocStart(), 4504 diag::note_deleted_special_member_class_subobject) 4505 << CSM << MD->getParent() << /*IsField*/false 4506 << Base->getType() << DiagKind << IsDtorCallInCtor; 4507 } 4508 4509 if (DiagKind == 1) 4510 S.NoteDeletedFunction(Decl); 4511 // FIXME: Explain inaccessibility if DiagKind == 3. 4512 } 4513 4514 return true; 4515} 4516 4517/// Check whether we should delete a special member function due to having a 4518/// direct or virtual base class or non-static data member of class type M. 4519bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject( 4520 CXXRecordDecl *Class, Subobject Subobj, unsigned Quals) { 4521 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>(); 4522 4523 // C++11 [class.ctor]p5: 4524 // -- any direct or virtual base class, or non-static data member with no 4525 // brace-or-equal-initializer, has class type M (or array thereof) and 4526 // either M has no default constructor or overload resolution as applied 4527 // to M's default constructor results in an ambiguity or in a function 4528 // that is deleted or inaccessible 4529 // C++11 [class.copy]p11, C++11 [class.copy]p23: 4530 // -- a direct or virtual base class B that cannot be copied/moved because 4531 // overload resolution, as applied to B's corresponding special member, 4532 // results in an ambiguity or a function that is deleted or inaccessible 4533 // from the defaulted special member 4534 // C++11 [class.dtor]p5: 4535 // -- any direct or virtual base class [...] has a type with a destructor 4536 // that is deleted or inaccessible 4537 if (!(CSM == Sema::CXXDefaultConstructor && 4538 Field && Field->hasInClassInitializer()) && 4539 shouldDeleteForSubobjectCall(Subobj, lookupIn(Class, Quals), false)) 4540 return true; 4541 4542 // C++11 [class.ctor]p5, C++11 [class.copy]p11: 4543 // -- any direct or virtual base class or non-static data member has a 4544 // type with a destructor that is deleted or inaccessible 4545 if (IsConstructor) { 4546 Sema::SpecialMemberOverloadResult *SMOR = 4547 S.LookupSpecialMember(Class, Sema::CXXDestructor, 4548 false, false, false, false, false); 4549 if (shouldDeleteForSubobjectCall(Subobj, SMOR, true)) 4550 return true; 4551 } 4552 4553 return false; 4554} 4555 4556/// Check whether we should delete a special member function due to the class 4557/// having a particular direct or virtual base class. 4558bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) { 4559 CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl(); 4560 return shouldDeleteForClassSubobject(BaseClass, Base, 0); 4561} 4562 4563/// Check whether we should delete a special member function due to the class 4564/// having a particular non-static data member. 4565bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) { 4566 QualType FieldType = S.Context.getBaseElementType(FD->getType()); 4567 CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl(); 4568 4569 if (CSM == Sema::CXXDefaultConstructor) { 4570 // For a default constructor, all references must be initialized in-class 4571 // and, if a union, it must have a non-const member. 4572 if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) { 4573 if (Diagnose) 4574 S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field) 4575 << MD->getParent() << FD << FieldType << /*Reference*/0; 4576 return true; 4577 } 4578 // C++11 [class.ctor]p5: any non-variant non-static data member of 4579 // const-qualified type (or array thereof) with no 4580 // brace-or-equal-initializer does not have a user-provided default 4581 // constructor. 4582 if (!inUnion() && FieldType.isConstQualified() && 4583 !FD->hasInClassInitializer() && 4584 (!FieldRecord || !FieldRecord->hasUserProvidedDefaultConstructor())) { 4585 if (Diagnose) 4586 S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field) 4587 << MD->getParent() << FD << FD->getType() << /*Const*/1; 4588 return true; 4589 } 4590 4591 if (inUnion() && !FieldType.isConstQualified()) 4592 AllFieldsAreConst = false; 4593 } else if (CSM == Sema::CXXCopyConstructor) { 4594 // For a copy constructor, data members must not be of rvalue reference 4595 // type. 4596 if (FieldType->isRValueReferenceType()) { 4597 if (Diagnose) 4598 S.Diag(FD->getLocation(), diag::note_deleted_copy_ctor_rvalue_reference) 4599 << MD->getParent() << FD << FieldType; 4600 return true; 4601 } 4602 } else if (IsAssignment) { 4603 // For an assignment operator, data members must not be of reference type. 4604 if (FieldType->isReferenceType()) { 4605 if (Diagnose) 4606 S.Diag(FD->getLocation(), diag::note_deleted_assign_field) 4607 << IsMove << MD->getParent() << FD << FieldType << /*Reference*/0; 4608 return true; 4609 } 4610 if (!FieldRecord && FieldType.isConstQualified()) { 4611 // C++11 [class.copy]p23: 4612 // -- a non-static data member of const non-class type (or array thereof) 4613 if (Diagnose) 4614 S.Diag(FD->getLocation(), diag::note_deleted_assign_field) 4615 << IsMove << MD->getParent() << FD << FD->getType() << /*Const*/1; 4616 return true; 4617 } 4618 } 4619 4620 if (FieldRecord) { 4621 // Some additional restrictions exist on the variant members. 4622 if (!inUnion() && FieldRecord->isUnion() && 4623 FieldRecord->isAnonymousStructOrUnion()) { 4624 bool AllVariantFieldsAreConst = true; 4625 4626 // FIXME: Handle anonymous unions declared within anonymous unions. 4627 for (CXXRecordDecl::field_iterator UI = FieldRecord->field_begin(), 4628 UE = FieldRecord->field_end(); 4629 UI != UE; ++UI) { 4630 QualType UnionFieldType = S.Context.getBaseElementType(UI->getType()); 4631 4632 if (!UnionFieldType.isConstQualified()) 4633 AllVariantFieldsAreConst = false; 4634 4635 CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl(); 4636 if (UnionFieldRecord && 4637 shouldDeleteForClassSubobject(UnionFieldRecord, *UI, 4638 UnionFieldType.getCVRQualifiers())) 4639 return true; 4640 } 4641 4642 // At least one member in each anonymous union must be non-const 4643 if (CSM == Sema::CXXDefaultConstructor && AllVariantFieldsAreConst && 4644 FieldRecord->field_begin() != FieldRecord->field_end()) { 4645 if (Diagnose) 4646 S.Diag(FieldRecord->getLocation(), 4647 diag::note_deleted_default_ctor_all_const) 4648 << MD->getParent() << /*anonymous union*/1; 4649 return true; 4650 } 4651 4652 // Don't check the implicit member of the anonymous union type. 4653 // This is technically non-conformant, but sanity demands it. 4654 return false; 4655 } 4656 4657 if (shouldDeleteForClassSubobject(FieldRecord, FD, 4658 FieldType.getCVRQualifiers())) 4659 return true; 4660 } 4661 4662 return false; 4663} 4664 4665/// C++11 [class.ctor] p5: 4666/// A defaulted default constructor for a class X is defined as deleted if 4667/// X is a union and all of its variant members are of const-qualified type. 4668bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() { 4669 // This is a silly definition, because it gives an empty union a deleted 4670 // default constructor. Don't do that. 4671 if (CSM == Sema::CXXDefaultConstructor && inUnion() && AllFieldsAreConst && 4672 (MD->getParent()->field_begin() != MD->getParent()->field_end())) { 4673 if (Diagnose) 4674 S.Diag(MD->getParent()->getLocation(), 4675 diag::note_deleted_default_ctor_all_const) 4676 << MD->getParent() << /*not anonymous union*/0; 4677 return true; 4678 } 4679 return false; 4680} 4681 4682/// Determine whether a defaulted special member function should be defined as 4683/// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11, 4684/// C++11 [class.copy]p23, and C++11 [class.dtor]p5. 4685bool Sema::ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM, 4686 bool Diagnose) { 4687 if (MD->isInvalidDecl()) 4688 return false; 4689 CXXRecordDecl *RD = MD->getParent(); 4690 assert(!RD->isDependentType() && "do deletion after instantiation"); 4691 if (!LangOpts.CPlusPlus0x || RD->isInvalidDecl()) 4692 return false; 4693 4694 // C++11 [expr.lambda.prim]p19: 4695 // The closure type associated with a lambda-expression has a 4696 // deleted (8.4.3) default constructor and a deleted copy 4697 // assignment operator. 4698 if (RD->isLambda() && 4699 (CSM == CXXDefaultConstructor || CSM == CXXCopyAssignment)) { 4700 if (Diagnose) 4701 Diag(RD->getLocation(), diag::note_lambda_decl); 4702 return true; 4703 } 4704 4705 // For an anonymous struct or union, the copy and assignment special members 4706 // will never be used, so skip the check. For an anonymous union declared at 4707 // namespace scope, the constructor and destructor are used. 4708 if (CSM != CXXDefaultConstructor && CSM != CXXDestructor && 4709 RD->isAnonymousStructOrUnion()) 4710 return false; 4711 4712 // C++11 [class.copy]p7, p18: 4713 // If the class definition declares a move constructor or move assignment 4714 // operator, an implicitly declared copy constructor or copy assignment 4715 // operator is defined as deleted. 4716 if (MD->isImplicit() && 4717 (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment)) { 4718 CXXMethodDecl *UserDeclaredMove = 0; 4719 4720 // In Microsoft mode, a user-declared move only causes the deletion of the 4721 // corresponding copy operation, not both copy operations. 4722 if (RD->hasUserDeclaredMoveConstructor() && 4723 (!getLangOpts().MicrosoftMode || CSM == CXXCopyConstructor)) { 4724 if (!Diagnose) return true; 4725 UserDeclaredMove = RD->getMoveConstructor(); 4726 assert(UserDeclaredMove); 4727 } else if (RD->hasUserDeclaredMoveAssignment() && 4728 (!getLangOpts().MicrosoftMode || CSM == CXXCopyAssignment)) { 4729 if (!Diagnose) return true; 4730 UserDeclaredMove = RD->getMoveAssignmentOperator(); 4731 assert(UserDeclaredMove); 4732 } 4733 4734 if (UserDeclaredMove) { 4735 Diag(UserDeclaredMove->getLocation(), 4736 diag::note_deleted_copy_user_declared_move) 4737 << (CSM == CXXCopyAssignment) << RD 4738 << UserDeclaredMove->isMoveAssignmentOperator(); 4739 return true; 4740 } 4741 } 4742 4743 // Do access control from the special member function 4744 ContextRAII MethodContext(*this, MD); 4745 4746 // C++11 [class.dtor]p5: 4747 // -- for a virtual destructor, lookup of the non-array deallocation function 4748 // results in an ambiguity or in a function that is deleted or inaccessible 4749 if (CSM == CXXDestructor && MD->isVirtual()) { 4750 FunctionDecl *OperatorDelete = 0; 4751 DeclarationName Name = 4752 Context.DeclarationNames.getCXXOperatorName(OO_Delete); 4753 if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name, 4754 OperatorDelete, false)) { 4755 if (Diagnose) 4756 Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete); 4757 return true; 4758 } 4759 } 4760 4761 SpecialMemberDeletionInfo SMI(*this, MD, CSM, Diagnose); 4762 4763 for (CXXRecordDecl::base_class_iterator BI = RD->bases_begin(), 4764 BE = RD->bases_end(); BI != BE; ++BI) 4765 if (!BI->isVirtual() && 4766 SMI.shouldDeleteForBase(BI)) 4767 return true; 4768 4769 for (CXXRecordDecl::base_class_iterator BI = RD->vbases_begin(), 4770 BE = RD->vbases_end(); BI != BE; ++BI) 4771 if (SMI.shouldDeleteForBase(BI)) 4772 return true; 4773 4774 for (CXXRecordDecl::field_iterator FI = RD->field_begin(), 4775 FE = RD->field_end(); FI != FE; ++FI) 4776 if (!FI->isInvalidDecl() && !FI->isUnnamedBitfield() && 4777 SMI.shouldDeleteForField(*FI)) 4778 return true; 4779 4780 if (SMI.shouldDeleteForAllConstMembers()) 4781 return true; 4782 4783 return false; 4784} 4785 4786/// \brief Data used with FindHiddenVirtualMethod 4787namespace { 4788 struct FindHiddenVirtualMethodData { 4789 Sema *S; 4790 CXXMethodDecl *Method; 4791 llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods; 4792 SmallVector<CXXMethodDecl *, 8> OverloadedMethods; 4793 }; 4794} 4795 4796/// \brief Check whether any most overriden method from MD in Methods 4797static bool CheckMostOverridenMethods(const CXXMethodDecl *MD, 4798 const llvm::SmallPtrSet<const CXXMethodDecl *, 8>& Methods) { 4799 if (MD->size_overridden_methods() == 0) 4800 return Methods.count(MD->getCanonicalDecl()); 4801 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(), 4802 E = MD->end_overridden_methods(); 4803 I != E; ++I) 4804 if (CheckMostOverridenMethods(*I, Methods)) 4805 return true; 4806 return false; 4807} 4808 4809/// \brief Member lookup function that determines whether a given C++ 4810/// method overloads virtual methods in a base class without overriding any, 4811/// to be used with CXXRecordDecl::lookupInBases(). 4812static bool FindHiddenVirtualMethod(const CXXBaseSpecifier *Specifier, 4813 CXXBasePath &Path, 4814 void *UserData) { 4815 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl(); 4816 4817 FindHiddenVirtualMethodData &Data 4818 = *static_cast<FindHiddenVirtualMethodData*>(UserData); 4819 4820 DeclarationName Name = Data.Method->getDeclName(); 4821 assert(Name.getNameKind() == DeclarationName::Identifier); 4822 4823 bool foundSameNameMethod = false; 4824 SmallVector<CXXMethodDecl *, 8> overloadedMethods; 4825 for (Path.Decls = BaseRecord->lookup(Name); 4826 Path.Decls.first != Path.Decls.second; 4827 ++Path.Decls.first) { 4828 NamedDecl *D = *Path.Decls.first; 4829 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { 4830 MD = MD->getCanonicalDecl(); 4831 foundSameNameMethod = true; 4832 // Interested only in hidden virtual methods. 4833 if (!MD->isVirtual()) 4834 continue; 4835 // If the method we are checking overrides a method from its base 4836 // don't warn about the other overloaded methods. 4837 if (!Data.S->IsOverload(Data.Method, MD, false)) 4838 return true; 4839 // Collect the overload only if its hidden. 4840 if (!CheckMostOverridenMethods(MD, Data.OverridenAndUsingBaseMethods)) 4841 overloadedMethods.push_back(MD); 4842 } 4843 } 4844 4845 if (foundSameNameMethod) 4846 Data.OverloadedMethods.append(overloadedMethods.begin(), 4847 overloadedMethods.end()); 4848 return foundSameNameMethod; 4849} 4850 4851/// \brief Add the most overriden methods from MD to Methods 4852static void AddMostOverridenMethods(const CXXMethodDecl *MD, 4853 llvm::SmallPtrSet<const CXXMethodDecl *, 8>& Methods) { 4854 if (MD->size_overridden_methods() == 0) 4855 Methods.insert(MD->getCanonicalDecl()); 4856 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(), 4857 E = MD->end_overridden_methods(); 4858 I != E; ++I) 4859 AddMostOverridenMethods(*I, Methods); 4860} 4861 4862/// \brief See if a method overloads virtual methods in a base class without 4863/// overriding any. 4864void Sema::DiagnoseHiddenVirtualMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) { 4865 if (Diags.getDiagnosticLevel(diag::warn_overloaded_virtual, 4866 MD->getLocation()) == DiagnosticsEngine::Ignored) 4867 return; 4868 if (!MD->getDeclName().isIdentifier()) 4869 return; 4870 4871 CXXBasePaths Paths(/*FindAmbiguities=*/true, // true to look in all bases. 4872 /*bool RecordPaths=*/false, 4873 /*bool DetectVirtual=*/false); 4874 FindHiddenVirtualMethodData Data; 4875 Data.Method = MD; 4876 Data.S = this; 4877 4878 // Keep the base methods that were overriden or introduced in the subclass 4879 // by 'using' in a set. A base method not in this set is hidden. 4880 for (DeclContext::lookup_result res = DC->lookup(MD->getDeclName()); 4881 res.first != res.second; ++res.first) { 4882 NamedDecl *ND = *res.first; 4883 if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*res.first)) 4884 ND = shad->getTargetDecl(); 4885 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND)) 4886 AddMostOverridenMethods(MD, Data.OverridenAndUsingBaseMethods); 4887 } 4888 4889 if (DC->lookupInBases(&FindHiddenVirtualMethod, &Data, Paths) && 4890 !Data.OverloadedMethods.empty()) { 4891 Diag(MD->getLocation(), diag::warn_overloaded_virtual) 4892 << MD << (Data.OverloadedMethods.size() > 1); 4893 4894 for (unsigned i = 0, e = Data.OverloadedMethods.size(); i != e; ++i) { 4895 CXXMethodDecl *overloadedMD = Data.OverloadedMethods[i]; 4896 Diag(overloadedMD->getLocation(), 4897 diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD; 4898 } 4899 } 4900} 4901 4902void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc, 4903 Decl *TagDecl, 4904 SourceLocation LBrac, 4905 SourceLocation RBrac, 4906 AttributeList *AttrList) { 4907 if (!TagDecl) 4908 return; 4909 4910 AdjustDeclIfTemplate(TagDecl); 4911 4912 for (const AttributeList* l = AttrList; l; l = l->getNext()) { 4913 if (l->getKind() != AttributeList::AT_Visibility) 4914 continue; 4915 l->setInvalid(); 4916 Diag(l->getLoc(), diag::warn_attribute_after_definition_ignored) << 4917 l->getName(); 4918 } 4919 4920 ActOnFields(S, RLoc, TagDecl, llvm::makeArrayRef( 4921 // strict aliasing violation! 4922 reinterpret_cast<Decl**>(FieldCollector->getCurFields()), 4923 FieldCollector->getCurNumFields()), LBrac, RBrac, AttrList); 4924 4925 CheckCompletedCXXClass( 4926 dyn_cast_or_null<CXXRecordDecl>(TagDecl)); 4927} 4928 4929/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared 4930/// special functions, such as the default constructor, copy 4931/// constructor, or destructor, to the given C++ class (C++ 4932/// [special]p1). This routine can only be executed just before the 4933/// definition of the class is complete. 4934void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) { 4935 if (!ClassDecl->hasUserDeclaredConstructor()) 4936 ++ASTContext::NumImplicitDefaultConstructors; 4937 4938 if (!ClassDecl->hasUserDeclaredCopyConstructor()) 4939 ++ASTContext::NumImplicitCopyConstructors; 4940 4941 if (getLangOpts().CPlusPlus0x && ClassDecl->needsImplicitMoveConstructor()) 4942 ++ASTContext::NumImplicitMoveConstructors; 4943 4944 if (!ClassDecl->hasUserDeclaredCopyAssignment()) { 4945 ++ASTContext::NumImplicitCopyAssignmentOperators; 4946 4947 // If we have a dynamic class, then the copy assignment operator may be 4948 // virtual, so we have to declare it immediately. This ensures that, e.g., 4949 // it shows up in the right place in the vtable and that we diagnose 4950 // problems with the implicit exception specification. 4951 if (ClassDecl->isDynamicClass()) 4952 DeclareImplicitCopyAssignment(ClassDecl); 4953 } 4954 4955 if (getLangOpts().CPlusPlus0x && ClassDecl->needsImplicitMoveAssignment()) { 4956 ++ASTContext::NumImplicitMoveAssignmentOperators; 4957 4958 // Likewise for the move assignment operator. 4959 if (ClassDecl->isDynamicClass()) 4960 DeclareImplicitMoveAssignment(ClassDecl); 4961 } 4962 4963 if (!ClassDecl->hasUserDeclaredDestructor()) { 4964 ++ASTContext::NumImplicitDestructors; 4965 4966 // If we have a dynamic class, then the destructor may be virtual, so we 4967 // have to declare the destructor immediately. This ensures that, e.g., it 4968 // shows up in the right place in the vtable and that we diagnose problems 4969 // with the implicit exception specification. 4970 if (ClassDecl->isDynamicClass()) 4971 DeclareImplicitDestructor(ClassDecl); 4972 } 4973} 4974 4975void Sema::ActOnReenterDeclaratorTemplateScope(Scope *S, DeclaratorDecl *D) { 4976 if (!D) 4977 return; 4978 4979 int NumParamList = D->getNumTemplateParameterLists(); 4980 for (int i = 0; i < NumParamList; i++) { 4981 TemplateParameterList* Params = D->getTemplateParameterList(i); 4982 for (TemplateParameterList::iterator Param = Params->begin(), 4983 ParamEnd = Params->end(); 4984 Param != ParamEnd; ++Param) { 4985 NamedDecl *Named = cast<NamedDecl>(*Param); 4986 if (Named->getDeclName()) { 4987 S->AddDecl(Named); 4988 IdResolver.AddDecl(Named); 4989 } 4990 } 4991 } 4992} 4993 4994void Sema::ActOnReenterTemplateScope(Scope *S, Decl *D) { 4995 if (!D) 4996 return; 4997 4998 TemplateParameterList *Params = 0; 4999 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) 5000 Params = Template->getTemplateParameters(); 5001 else if (ClassTemplatePartialSpecializationDecl *PartialSpec 5002 = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) 5003 Params = PartialSpec->getTemplateParameters(); 5004 else 5005 return; 5006 5007 for (TemplateParameterList::iterator Param = Params->begin(), 5008 ParamEnd = Params->end(); 5009 Param != ParamEnd; ++Param) { 5010 NamedDecl *Named = cast<NamedDecl>(*Param); 5011 if (Named->getDeclName()) { 5012 S->AddDecl(Named); 5013 IdResolver.AddDecl(Named); 5014 } 5015 } 5016} 5017 5018void Sema::ActOnStartDelayedMemberDeclarations(Scope *S, Decl *RecordD) { 5019 if (!RecordD) return; 5020 AdjustDeclIfTemplate(RecordD); 5021 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD); 5022 PushDeclContext(S, Record); 5023} 5024 5025void Sema::ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *RecordD) { 5026 if (!RecordD) return; 5027 PopDeclContext(); 5028} 5029 5030/// ActOnStartDelayedCXXMethodDeclaration - We have completed 5031/// parsing a top-level (non-nested) C++ class, and we are now 5032/// parsing those parts of the given Method declaration that could 5033/// not be parsed earlier (C++ [class.mem]p2), such as default 5034/// arguments. This action should enter the scope of the given 5035/// Method declaration as if we had just parsed the qualified method 5036/// name. However, it should not bring the parameters into scope; 5037/// that will be performed by ActOnDelayedCXXMethodParameter. 5038void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) { 5039} 5040 5041/// ActOnDelayedCXXMethodParameter - We've already started a delayed 5042/// C++ method declaration. We're (re-)introducing the given 5043/// function parameter into scope for use in parsing later parts of 5044/// the method declaration. For example, we could see an 5045/// ActOnParamDefaultArgument event for this parameter. 5046void Sema::ActOnDelayedCXXMethodParameter(Scope *S, Decl *ParamD) { 5047 if (!ParamD) 5048 return; 5049 5050 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD); 5051 5052 // If this parameter has an unparsed default argument, clear it out 5053 // to make way for the parsed default argument. 5054 if (Param->hasUnparsedDefaultArg()) 5055 Param->setDefaultArg(0); 5056 5057 S->AddDecl(Param); 5058 if (Param->getDeclName()) 5059 IdResolver.AddDecl(Param); 5060} 5061 5062/// ActOnFinishDelayedCXXMethodDeclaration - We have finished 5063/// processing the delayed method declaration for Method. The method 5064/// declaration is now considered finished. There may be a separate 5065/// ActOnStartOfFunctionDef action later (not necessarily 5066/// immediately!) for this method, if it was also defined inside the 5067/// class body. 5068void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) { 5069 if (!MethodD) 5070 return; 5071 5072 AdjustDeclIfTemplate(MethodD); 5073 5074 FunctionDecl *Method = cast<FunctionDecl>(MethodD); 5075 5076 // Now that we have our default arguments, check the constructor 5077 // again. It could produce additional diagnostics or affect whether 5078 // the class has implicitly-declared destructors, among other 5079 // things. 5080 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method)) 5081 CheckConstructor(Constructor); 5082 5083 // Check the default arguments, which we may have added. 5084 if (!Method->isInvalidDecl()) 5085 CheckCXXDefaultArguments(Method); 5086} 5087 5088/// CheckConstructorDeclarator - Called by ActOnDeclarator to check 5089/// the well-formedness of the constructor declarator @p D with type @p 5090/// R. If there are any errors in the declarator, this routine will 5091/// emit diagnostics and set the invalid bit to true. In any case, the type 5092/// will be updated to reflect a well-formed type for the constructor and 5093/// returned. 5094QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R, 5095 StorageClass &SC) { 5096 bool isVirtual = D.getDeclSpec().isVirtualSpecified(); 5097 5098 // C++ [class.ctor]p3: 5099 // A constructor shall not be virtual (10.3) or static (9.4). A 5100 // constructor can be invoked for a const, volatile or const 5101 // volatile object. A constructor shall not be declared const, 5102 // volatile, or const volatile (9.3.2). 5103 if (isVirtual) { 5104 if (!D.isInvalidType()) 5105 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be) 5106 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc()) 5107 << SourceRange(D.getIdentifierLoc()); 5108 D.setInvalidType(); 5109 } 5110 if (SC == SC_Static) { 5111 if (!D.isInvalidType()) 5112 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be) 5113 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc()) 5114 << SourceRange(D.getIdentifierLoc()); 5115 D.setInvalidType(); 5116 SC = SC_None; 5117 } 5118 5119 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 5120 if (FTI.TypeQuals != 0) { 5121 if (FTI.TypeQuals & Qualifiers::Const) 5122 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor) 5123 << "const" << SourceRange(D.getIdentifierLoc()); 5124 if (FTI.TypeQuals & Qualifiers::Volatile) 5125 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor) 5126 << "volatile" << SourceRange(D.getIdentifierLoc()); 5127 if (FTI.TypeQuals & Qualifiers::Restrict) 5128 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor) 5129 << "restrict" << SourceRange(D.getIdentifierLoc()); 5130 D.setInvalidType(); 5131 } 5132 5133 // C++0x [class.ctor]p4: 5134 // A constructor shall not be declared with a ref-qualifier. 5135 if (FTI.hasRefQualifier()) { 5136 Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_constructor) 5137 << FTI.RefQualifierIsLValueRef 5138 << FixItHint::CreateRemoval(FTI.getRefQualifierLoc()); 5139 D.setInvalidType(); 5140 } 5141 5142 // Rebuild the function type "R" without any type qualifiers (in 5143 // case any of the errors above fired) and with "void" as the 5144 // return type, since constructors don't have return types. 5145 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>(); 5146 if (Proto->getResultType() == Context.VoidTy && !D.isInvalidType()) 5147 return R; 5148 5149 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo(); 5150 EPI.TypeQuals = 0; 5151 EPI.RefQualifier = RQ_None; 5152 5153 return Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(), 5154 Proto->getNumArgs(), EPI); 5155} 5156 5157/// CheckConstructor - Checks a fully-formed constructor for 5158/// well-formedness, issuing any diagnostics required. Returns true if 5159/// the constructor declarator is invalid. 5160void Sema::CheckConstructor(CXXConstructorDecl *Constructor) { 5161 CXXRecordDecl *ClassDecl 5162 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext()); 5163 if (!ClassDecl) 5164 return Constructor->setInvalidDecl(); 5165 5166 // C++ [class.copy]p3: 5167 // A declaration of a constructor for a class X is ill-formed if 5168 // its first parameter is of type (optionally cv-qualified) X and 5169 // either there are no other parameters or else all other 5170 // parameters have default arguments. 5171 if (!Constructor->isInvalidDecl() && 5172 ((Constructor->getNumParams() == 1) || 5173 (Constructor->getNumParams() > 1 && 5174 Constructor->getParamDecl(1)->hasDefaultArg())) && 5175 Constructor->getTemplateSpecializationKind() 5176 != TSK_ImplicitInstantiation) { 5177 QualType ParamType = Constructor->getParamDecl(0)->getType(); 5178 QualType ClassTy = Context.getTagDeclType(ClassDecl); 5179 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) { 5180 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation(); 5181 const char *ConstRef 5182 = Constructor->getParamDecl(0)->getIdentifier() ? "const &" 5183 : " const &"; 5184 Diag(ParamLoc, diag::err_constructor_byvalue_arg) 5185 << FixItHint::CreateInsertion(ParamLoc, ConstRef); 5186 5187 // FIXME: Rather that making the constructor invalid, we should endeavor 5188 // to fix the type. 5189 Constructor->setInvalidDecl(); 5190 } 5191 } 5192} 5193 5194/// CheckDestructor - Checks a fully-formed destructor definition for 5195/// well-formedness, issuing any diagnostics required. Returns true 5196/// on error. 5197bool Sema::CheckDestructor(CXXDestructorDecl *Destructor) { 5198 CXXRecordDecl *RD = Destructor->getParent(); 5199 5200 if (Destructor->isVirtual()) { 5201 SourceLocation Loc; 5202 5203 if (!Destructor->isImplicit()) 5204 Loc = Destructor->getLocation(); 5205 else 5206 Loc = RD->getLocation(); 5207 5208 // If we have a virtual destructor, look up the deallocation function 5209 FunctionDecl *OperatorDelete = 0; 5210 DeclarationName Name = 5211 Context.DeclarationNames.getCXXOperatorName(OO_Delete); 5212 if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete)) 5213 return true; 5214 5215 MarkFunctionReferenced(Loc, OperatorDelete); 5216 5217 Destructor->setOperatorDelete(OperatorDelete); 5218 } 5219 5220 return false; 5221} 5222 5223static inline bool 5224FTIHasSingleVoidArgument(DeclaratorChunk::FunctionTypeInfo &FTI) { 5225 return (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 && 5226 FTI.ArgInfo[0].Param && 5227 cast<ParmVarDecl>(FTI.ArgInfo[0].Param)->getType()->isVoidType()); 5228} 5229 5230/// CheckDestructorDeclarator - Called by ActOnDeclarator to check 5231/// the well-formednes of the destructor declarator @p D with type @p 5232/// R. If there are any errors in the declarator, this routine will 5233/// emit diagnostics and set the declarator to invalid. Even if this happens, 5234/// will be updated to reflect a well-formed type for the destructor and 5235/// returned. 5236QualType Sema::CheckDestructorDeclarator(Declarator &D, QualType R, 5237 StorageClass& SC) { 5238 // C++ [class.dtor]p1: 5239 // [...] A typedef-name that names a class is a class-name 5240 // (7.1.3); however, a typedef-name that names a class shall not 5241 // be used as the identifier in the declarator for a destructor 5242 // declaration. 5243 QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName); 5244 if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>()) 5245 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name) 5246 << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl()); 5247 else if (const TemplateSpecializationType *TST = 5248 DeclaratorType->getAs<TemplateSpecializationType>()) 5249 if (TST->isTypeAlias()) 5250 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name) 5251 << DeclaratorType << 1; 5252 5253 // C++ [class.dtor]p2: 5254 // A destructor is used to destroy objects of its class type. A 5255 // destructor takes no parameters, and no return type can be 5256 // specified for it (not even void). The address of a destructor 5257 // shall not be taken. A destructor shall not be static. A 5258 // destructor can be invoked for a const, volatile or const 5259 // volatile object. A destructor shall not be declared const, 5260 // volatile or const volatile (9.3.2). 5261 if (SC == SC_Static) { 5262 if (!D.isInvalidType()) 5263 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be) 5264 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc()) 5265 << SourceRange(D.getIdentifierLoc()) 5266 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 5267 5268 SC = SC_None; 5269 } 5270 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) { 5271 // Destructors don't have return types, but the parser will 5272 // happily parse something like: 5273 // 5274 // class X { 5275 // float ~X(); 5276 // }; 5277 // 5278 // The return type will be eliminated later. 5279 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type) 5280 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc()) 5281 << SourceRange(D.getIdentifierLoc()); 5282 } 5283 5284 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 5285 if (FTI.TypeQuals != 0 && !D.isInvalidType()) { 5286 if (FTI.TypeQuals & Qualifiers::Const) 5287 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor) 5288 << "const" << SourceRange(D.getIdentifierLoc()); 5289 if (FTI.TypeQuals & Qualifiers::Volatile) 5290 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor) 5291 << "volatile" << SourceRange(D.getIdentifierLoc()); 5292 if (FTI.TypeQuals & Qualifiers::Restrict) 5293 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor) 5294 << "restrict" << SourceRange(D.getIdentifierLoc()); 5295 D.setInvalidType(); 5296 } 5297 5298 // C++0x [class.dtor]p2: 5299 // A destructor shall not be declared with a ref-qualifier. 5300 if (FTI.hasRefQualifier()) { 5301 Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_destructor) 5302 << FTI.RefQualifierIsLValueRef 5303 << FixItHint::CreateRemoval(FTI.getRefQualifierLoc()); 5304 D.setInvalidType(); 5305 } 5306 5307 // Make sure we don't have any parameters. 5308 if (FTI.NumArgs > 0 && !FTIHasSingleVoidArgument(FTI)) { 5309 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params); 5310 5311 // Delete the parameters. 5312 FTI.freeArgs(); 5313 D.setInvalidType(); 5314 } 5315 5316 // Make sure the destructor isn't variadic. 5317 if (FTI.isVariadic) { 5318 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic); 5319 D.setInvalidType(); 5320 } 5321 5322 // Rebuild the function type "R" without any type qualifiers or 5323 // parameters (in case any of the errors above fired) and with 5324 // "void" as the return type, since destructors don't have return 5325 // types. 5326 if (!D.isInvalidType()) 5327 return R; 5328 5329 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>(); 5330 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo(); 5331 EPI.Variadic = false; 5332 EPI.TypeQuals = 0; 5333 EPI.RefQualifier = RQ_None; 5334 return Context.getFunctionType(Context.VoidTy, 0, 0, EPI); 5335} 5336 5337/// CheckConversionDeclarator - Called by ActOnDeclarator to check the 5338/// well-formednes of the conversion function declarator @p D with 5339/// type @p R. If there are any errors in the declarator, this routine 5340/// will emit diagnostics and return true. Otherwise, it will return 5341/// false. Either way, the type @p R will be updated to reflect a 5342/// well-formed type for the conversion operator. 5343void Sema::CheckConversionDeclarator(Declarator &D, QualType &R, 5344 StorageClass& SC) { 5345 // C++ [class.conv.fct]p1: 5346 // Neither parameter types nor return type can be specified. The 5347 // type of a conversion function (8.3.5) is "function taking no 5348 // parameter returning conversion-type-id." 5349 if (SC == SC_Static) { 5350 if (!D.isInvalidType()) 5351 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member) 5352 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc()) 5353 << SourceRange(D.getIdentifierLoc()); 5354 D.setInvalidType(); 5355 SC = SC_None; 5356 } 5357 5358 QualType ConvType = GetTypeFromParser(D.getName().ConversionFunctionId); 5359 5360 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) { 5361 // Conversion functions don't have return types, but the parser will 5362 // happily parse something like: 5363 // 5364 // class X { 5365 // float operator bool(); 5366 // }; 5367 // 5368 // The return type will be changed later anyway. 5369 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type) 5370 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc()) 5371 << SourceRange(D.getIdentifierLoc()); 5372 D.setInvalidType(); 5373 } 5374 5375 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>(); 5376 5377 // Make sure we don't have any parameters. 5378 if (Proto->getNumArgs() > 0) { 5379 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params); 5380 5381 // Delete the parameters. 5382 D.getFunctionTypeInfo().freeArgs(); 5383 D.setInvalidType(); 5384 } else if (Proto->isVariadic()) { 5385 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic); 5386 D.setInvalidType(); 5387 } 5388 5389 // Diagnose "&operator bool()" and other such nonsense. This 5390 // is actually a gcc extension which we don't support. 5391 if (Proto->getResultType() != ConvType) { 5392 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_complex_decl) 5393 << Proto->getResultType(); 5394 D.setInvalidType(); 5395 ConvType = Proto->getResultType(); 5396 } 5397 5398 // C++ [class.conv.fct]p4: 5399 // The conversion-type-id shall not represent a function type nor 5400 // an array type. 5401 if (ConvType->isArrayType()) { 5402 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array); 5403 ConvType = Context.getPointerType(ConvType); 5404 D.setInvalidType(); 5405 } else if (ConvType->isFunctionType()) { 5406 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function); 5407 ConvType = Context.getPointerType(ConvType); 5408 D.setInvalidType(); 5409 } 5410 5411 // Rebuild the function type "R" without any parameters (in case any 5412 // of the errors above fired) and with the conversion type as the 5413 // return type. 5414 if (D.isInvalidType()) 5415 R = Context.getFunctionType(ConvType, 0, 0, Proto->getExtProtoInfo()); 5416 5417 // C++0x explicit conversion operators. 5418 if (D.getDeclSpec().isExplicitSpecified()) 5419 Diag(D.getDeclSpec().getExplicitSpecLoc(), 5420 getLangOpts().CPlusPlus0x ? 5421 diag::warn_cxx98_compat_explicit_conversion_functions : 5422 diag::ext_explicit_conversion_functions) 5423 << SourceRange(D.getDeclSpec().getExplicitSpecLoc()); 5424} 5425 5426/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete 5427/// the declaration of the given C++ conversion function. This routine 5428/// is responsible for recording the conversion function in the C++ 5429/// class, if possible. 5430Decl *Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) { 5431 assert(Conversion && "Expected to receive a conversion function declaration"); 5432 5433 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext()); 5434 5435 // Make sure we aren't redeclaring the conversion function. 5436 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType()); 5437 5438 // C++ [class.conv.fct]p1: 5439 // [...] A conversion function is never used to convert a 5440 // (possibly cv-qualified) object to the (possibly cv-qualified) 5441 // same object type (or a reference to it), to a (possibly 5442 // cv-qualified) base class of that type (or a reference to it), 5443 // or to (possibly cv-qualified) void. 5444 // FIXME: Suppress this warning if the conversion function ends up being a 5445 // virtual function that overrides a virtual function in a base class. 5446 QualType ClassType 5447 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl)); 5448 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>()) 5449 ConvType = ConvTypeRef->getPointeeType(); 5450 if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared && 5451 Conversion->getTemplateSpecializationKind() != TSK_ExplicitSpecialization) 5452 /* Suppress diagnostics for instantiations. */; 5453 else if (ConvType->isRecordType()) { 5454 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType(); 5455 if (ConvType == ClassType) 5456 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used) 5457 << ClassType; 5458 else if (IsDerivedFrom(ClassType, ConvType)) 5459 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used) 5460 << ClassType << ConvType; 5461 } else if (ConvType->isVoidType()) { 5462 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used) 5463 << ClassType << ConvType; 5464 } 5465 5466 if (FunctionTemplateDecl *ConversionTemplate 5467 = Conversion->getDescribedFunctionTemplate()) 5468 return ConversionTemplate; 5469 5470 return Conversion; 5471} 5472 5473//===----------------------------------------------------------------------===// 5474// Namespace Handling 5475//===----------------------------------------------------------------------===// 5476 5477/// \brief Diagnose a mismatch in 'inline' qualifiers when a namespace is 5478/// reopened. 5479static void DiagnoseNamespaceInlineMismatch(Sema &S, SourceLocation KeywordLoc, 5480 SourceLocation Loc, 5481 IdentifierInfo *II, bool *IsInline, 5482 NamespaceDecl *PrevNS) { 5483 assert(*IsInline != PrevNS->isInline()); 5484 5485 // HACK: Work around a bug in libstdc++4.6's <atomic>, where 5486 // std::__atomic[0,1,2] are defined as non-inline namespaces, then reopened as 5487 // inline namespaces, with the intention of bringing names into namespace std. 5488 // 5489 // We support this just well enough to get that case working; this is not 5490 // sufficient to support reopening namespaces as inline in general. 5491 if (*IsInline && II && II->getName().startswith("__atomic") && 5492 S.getSourceManager().isInSystemHeader(Loc)) { 5493 // Mark all prior declarations of the namespace as inline. 5494 for (NamespaceDecl *NS = PrevNS->getMostRecentDecl(); NS; 5495 NS = NS->getPreviousDecl()) 5496 NS->setInline(*IsInline); 5497 // Patch up the lookup table for the containing namespace. This isn't really 5498 // correct, but it's good enough for this particular case. 5499 for (DeclContext::decl_iterator I = PrevNS->decls_begin(), 5500 E = PrevNS->decls_end(); I != E; ++I) 5501 if (NamedDecl *ND = dyn_cast<NamedDecl>(*I)) 5502 PrevNS->getParent()->makeDeclVisibleInContext(ND); 5503 return; 5504 } 5505 5506 if (PrevNS->isInline()) 5507 // The user probably just forgot the 'inline', so suggest that it 5508 // be added back. 5509 S.Diag(Loc, diag::warn_inline_namespace_reopened_noninline) 5510 << FixItHint::CreateInsertion(KeywordLoc, "inline "); 5511 else 5512 S.Diag(Loc, diag::err_inline_namespace_mismatch) 5513 << IsInline; 5514 5515 S.Diag(PrevNS->getLocation(), diag::note_previous_definition); 5516 *IsInline = PrevNS->isInline(); 5517} 5518 5519/// ActOnStartNamespaceDef - This is called at the start of a namespace 5520/// definition. 5521Decl *Sema::ActOnStartNamespaceDef(Scope *NamespcScope, 5522 SourceLocation InlineLoc, 5523 SourceLocation NamespaceLoc, 5524 SourceLocation IdentLoc, 5525 IdentifierInfo *II, 5526 SourceLocation LBrace, 5527 AttributeList *AttrList) { 5528 SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc; 5529 // For anonymous namespace, take the location of the left brace. 5530 SourceLocation Loc = II ? IdentLoc : LBrace; 5531 bool IsInline = InlineLoc.isValid(); 5532 bool IsInvalid = false; 5533 bool IsStd = false; 5534 bool AddToKnown = false; 5535 Scope *DeclRegionScope = NamespcScope->getParent(); 5536 5537 NamespaceDecl *PrevNS = 0; 5538 if (II) { 5539 // C++ [namespace.def]p2: 5540 // The identifier in an original-namespace-definition shall not 5541 // have been previously defined in the declarative region in 5542 // which the original-namespace-definition appears. The 5543 // identifier in an original-namespace-definition is the name of 5544 // the namespace. Subsequently in that declarative region, it is 5545 // treated as an original-namespace-name. 5546 // 5547 // Since namespace names are unique in their scope, and we don't 5548 // look through using directives, just look for any ordinary names. 5549 5550 const unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Member | 5551 Decl::IDNS_Type | Decl::IDNS_Using | Decl::IDNS_Tag | 5552 Decl::IDNS_Namespace; 5553 NamedDecl *PrevDecl = 0; 5554 for (DeclContext::lookup_result R 5555 = CurContext->getRedeclContext()->lookup(II); 5556 R.first != R.second; ++R.first) { 5557 if ((*R.first)->getIdentifierNamespace() & IDNS) { 5558 PrevDecl = *R.first; 5559 break; 5560 } 5561 } 5562 5563 PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl); 5564 5565 if (PrevNS) { 5566 // This is an extended namespace definition. 5567 if (IsInline != PrevNS->isInline()) 5568 DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, Loc, II, 5569 &IsInline, PrevNS); 5570 } else if (PrevDecl) { 5571 // This is an invalid name redefinition. 5572 Diag(Loc, diag::err_redefinition_different_kind) 5573 << II; 5574 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 5575 IsInvalid = true; 5576 // Continue on to push Namespc as current DeclContext and return it. 5577 } else if (II->isStr("std") && 5578 CurContext->getRedeclContext()->isTranslationUnit()) { 5579 // This is the first "real" definition of the namespace "std", so update 5580 // our cache of the "std" namespace to point at this definition. 5581 PrevNS = getStdNamespace(); 5582 IsStd = true; 5583 AddToKnown = !IsInline; 5584 } else { 5585 // We've seen this namespace for the first time. 5586 AddToKnown = !IsInline; 5587 } 5588 } else { 5589 // Anonymous namespaces. 5590 5591 // Determine whether the parent already has an anonymous namespace. 5592 DeclContext *Parent = CurContext->getRedeclContext(); 5593 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) { 5594 PrevNS = TU->getAnonymousNamespace(); 5595 } else { 5596 NamespaceDecl *ND = cast<NamespaceDecl>(Parent); 5597 PrevNS = ND->getAnonymousNamespace(); 5598 } 5599 5600 if (PrevNS && IsInline != PrevNS->isInline()) 5601 DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, NamespaceLoc, II, 5602 &IsInline, PrevNS); 5603 } 5604 5605 NamespaceDecl *Namespc = NamespaceDecl::Create(Context, CurContext, IsInline, 5606 StartLoc, Loc, II, PrevNS); 5607 if (IsInvalid) 5608 Namespc->setInvalidDecl(); 5609 5610 ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList); 5611 5612 // FIXME: Should we be merging attributes? 5613 if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>()) 5614 PushNamespaceVisibilityAttr(Attr, Loc); 5615 5616 if (IsStd) 5617 StdNamespace = Namespc; 5618 if (AddToKnown) 5619 KnownNamespaces[Namespc] = false; 5620 5621 if (II) { 5622 PushOnScopeChains(Namespc, DeclRegionScope); 5623 } else { 5624 // Link the anonymous namespace into its parent. 5625 DeclContext *Parent = CurContext->getRedeclContext(); 5626 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) { 5627 TU->setAnonymousNamespace(Namespc); 5628 } else { 5629 cast<NamespaceDecl>(Parent)->setAnonymousNamespace(Namespc); 5630 } 5631 5632 CurContext->addDecl(Namespc); 5633 5634 // C++ [namespace.unnamed]p1. An unnamed-namespace-definition 5635 // behaves as if it were replaced by 5636 // namespace unique { /* empty body */ } 5637 // using namespace unique; 5638 // namespace unique { namespace-body } 5639 // where all occurrences of 'unique' in a translation unit are 5640 // replaced by the same identifier and this identifier differs 5641 // from all other identifiers in the entire program. 5642 5643 // We just create the namespace with an empty name and then add an 5644 // implicit using declaration, just like the standard suggests. 5645 // 5646 // CodeGen enforces the "universally unique" aspect by giving all 5647 // declarations semantically contained within an anonymous 5648 // namespace internal linkage. 5649 5650 if (!PrevNS) { 5651 UsingDirectiveDecl* UD 5652 = UsingDirectiveDecl::Create(Context, Parent, 5653 /* 'using' */ LBrace, 5654 /* 'namespace' */ SourceLocation(), 5655 /* qualifier */ NestedNameSpecifierLoc(), 5656 /* identifier */ SourceLocation(), 5657 Namespc, 5658 /* Ancestor */ Parent); 5659 UD->setImplicit(); 5660 Parent->addDecl(UD); 5661 } 5662 } 5663 5664 ActOnDocumentableDecl(Namespc); 5665 5666 // Although we could have an invalid decl (i.e. the namespace name is a 5667 // redefinition), push it as current DeclContext and try to continue parsing. 5668 // FIXME: We should be able to push Namespc here, so that the each DeclContext 5669 // for the namespace has the declarations that showed up in that particular 5670 // namespace definition. 5671 PushDeclContext(NamespcScope, Namespc); 5672 return Namespc; 5673} 5674 5675/// getNamespaceDecl - Returns the namespace a decl represents. If the decl 5676/// is a namespace alias, returns the namespace it points to. 5677static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) { 5678 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D)) 5679 return AD->getNamespace(); 5680 return dyn_cast_or_null<NamespaceDecl>(D); 5681} 5682 5683/// ActOnFinishNamespaceDef - This callback is called after a namespace is 5684/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef. 5685void Sema::ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace) { 5686 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl); 5687 assert(Namespc && "Invalid parameter, expected NamespaceDecl"); 5688 Namespc->setRBraceLoc(RBrace); 5689 PopDeclContext(); 5690 if (Namespc->hasAttr<VisibilityAttr>()) 5691 PopPragmaVisibility(true, RBrace); 5692} 5693 5694CXXRecordDecl *Sema::getStdBadAlloc() const { 5695 return cast_or_null<CXXRecordDecl>( 5696 StdBadAlloc.get(Context.getExternalSource())); 5697} 5698 5699NamespaceDecl *Sema::getStdNamespace() const { 5700 return cast_or_null<NamespaceDecl>( 5701 StdNamespace.get(Context.getExternalSource())); 5702} 5703 5704/// \brief Retrieve the special "std" namespace, which may require us to 5705/// implicitly define the namespace. 5706NamespaceDecl *Sema::getOrCreateStdNamespace() { 5707 if (!StdNamespace) { 5708 // The "std" namespace has not yet been defined, so build one implicitly. 5709 StdNamespace = NamespaceDecl::Create(Context, 5710 Context.getTranslationUnitDecl(), 5711 /*Inline=*/false, 5712 SourceLocation(), SourceLocation(), 5713 &PP.getIdentifierTable().get("std"), 5714 /*PrevDecl=*/0); 5715 getStdNamespace()->setImplicit(true); 5716 } 5717 5718 return getStdNamespace(); 5719} 5720 5721bool Sema::isStdInitializerList(QualType Ty, QualType *Element) { 5722 assert(getLangOpts().CPlusPlus && 5723 "Looking for std::initializer_list outside of C++."); 5724 5725 // We're looking for implicit instantiations of 5726 // template <typename E> class std::initializer_list. 5727 5728 if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it. 5729 return false; 5730 5731 ClassTemplateDecl *Template = 0; 5732 const TemplateArgument *Arguments = 0; 5733 5734 if (const RecordType *RT = Ty->getAs<RecordType>()) { 5735 5736 ClassTemplateSpecializationDecl *Specialization = 5737 dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl()); 5738 if (!Specialization) 5739 return false; 5740 5741 Template = Specialization->getSpecializedTemplate(); 5742 Arguments = Specialization->getTemplateArgs().data(); 5743 } else if (const TemplateSpecializationType *TST = 5744 Ty->getAs<TemplateSpecializationType>()) { 5745 Template = dyn_cast_or_null<ClassTemplateDecl>( 5746 TST->getTemplateName().getAsTemplateDecl()); 5747 Arguments = TST->getArgs(); 5748 } 5749 if (!Template) 5750 return false; 5751 5752 if (!StdInitializerList) { 5753 // Haven't recognized std::initializer_list yet, maybe this is it. 5754 CXXRecordDecl *TemplateClass = Template->getTemplatedDecl(); 5755 if (TemplateClass->getIdentifier() != 5756 &PP.getIdentifierTable().get("initializer_list") || 5757 !getStdNamespace()->InEnclosingNamespaceSetOf( 5758 TemplateClass->getDeclContext())) 5759 return false; 5760 // This is a template called std::initializer_list, but is it the right 5761 // template? 5762 TemplateParameterList *Params = Template->getTemplateParameters(); 5763 if (Params->getMinRequiredArguments() != 1) 5764 return false; 5765 if (!isa<TemplateTypeParmDecl>(Params->getParam(0))) 5766 return false; 5767 5768 // It's the right template. 5769 StdInitializerList = Template; 5770 } 5771 5772 if (Template != StdInitializerList) 5773 return false; 5774 5775 // This is an instance of std::initializer_list. Find the argument type. 5776 if (Element) 5777 *Element = Arguments[0].getAsType(); 5778 return true; 5779} 5780 5781static ClassTemplateDecl *LookupStdInitializerList(Sema &S, SourceLocation Loc){ 5782 NamespaceDecl *Std = S.getStdNamespace(); 5783 if (!Std) { 5784 S.Diag(Loc, diag::err_implied_std_initializer_list_not_found); 5785 return 0; 5786 } 5787 5788 LookupResult Result(S, &S.PP.getIdentifierTable().get("initializer_list"), 5789 Loc, Sema::LookupOrdinaryName); 5790 if (!S.LookupQualifiedName(Result, Std)) { 5791 S.Diag(Loc, diag::err_implied_std_initializer_list_not_found); 5792 return 0; 5793 } 5794 ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>(); 5795 if (!Template) { 5796 Result.suppressDiagnostics(); 5797 // We found something weird. Complain about the first thing we found. 5798 NamedDecl *Found = *Result.begin(); 5799 S.Diag(Found->getLocation(), diag::err_malformed_std_initializer_list); 5800 return 0; 5801 } 5802 5803 // We found some template called std::initializer_list. Now verify that it's 5804 // correct. 5805 TemplateParameterList *Params = Template->getTemplateParameters(); 5806 if (Params->getMinRequiredArguments() != 1 || 5807 !isa<TemplateTypeParmDecl>(Params->getParam(0))) { 5808 S.Diag(Template->getLocation(), diag::err_malformed_std_initializer_list); 5809 return 0; 5810 } 5811 5812 return Template; 5813} 5814 5815QualType Sema::BuildStdInitializerList(QualType Element, SourceLocation Loc) { 5816 if (!StdInitializerList) { 5817 StdInitializerList = LookupStdInitializerList(*this, Loc); 5818 if (!StdInitializerList) 5819 return QualType(); 5820 } 5821 5822 TemplateArgumentListInfo Args(Loc, Loc); 5823 Args.addArgument(TemplateArgumentLoc(TemplateArgument(Element), 5824 Context.getTrivialTypeSourceInfo(Element, 5825 Loc))); 5826 return Context.getCanonicalType( 5827 CheckTemplateIdType(TemplateName(StdInitializerList), Loc, Args)); 5828} 5829 5830bool Sema::isInitListConstructor(const CXXConstructorDecl* Ctor) { 5831 // C++ [dcl.init.list]p2: 5832 // A constructor is an initializer-list constructor if its first parameter 5833 // is of type std::initializer_list<E> or reference to possibly cv-qualified 5834 // std::initializer_list<E> for some type E, and either there are no other 5835 // parameters or else all other parameters have default arguments. 5836 if (Ctor->getNumParams() < 1 || 5837 (Ctor->getNumParams() > 1 && !Ctor->getParamDecl(1)->hasDefaultArg())) 5838 return false; 5839 5840 QualType ArgType = Ctor->getParamDecl(0)->getType(); 5841 if (const ReferenceType *RT = ArgType->getAs<ReferenceType>()) 5842 ArgType = RT->getPointeeType().getUnqualifiedType(); 5843 5844 return isStdInitializerList(ArgType, 0); 5845} 5846 5847/// \brief Determine whether a using statement is in a context where it will be 5848/// apply in all contexts. 5849static bool IsUsingDirectiveInToplevelContext(DeclContext *CurContext) { 5850 switch (CurContext->getDeclKind()) { 5851 case Decl::TranslationUnit: 5852 return true; 5853 case Decl::LinkageSpec: 5854 return IsUsingDirectiveInToplevelContext(CurContext->getParent()); 5855 default: 5856 return false; 5857 } 5858} 5859 5860namespace { 5861 5862// Callback to only accept typo corrections that are namespaces. 5863class NamespaceValidatorCCC : public CorrectionCandidateCallback { 5864 public: 5865 virtual bool ValidateCandidate(const TypoCorrection &candidate) { 5866 if (NamedDecl *ND = candidate.getCorrectionDecl()) { 5867 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND); 5868 } 5869 return false; 5870 } 5871}; 5872 5873} 5874 5875static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc, 5876 CXXScopeSpec &SS, 5877 SourceLocation IdentLoc, 5878 IdentifierInfo *Ident) { 5879 NamespaceValidatorCCC Validator; 5880 R.clear(); 5881 if (TypoCorrection Corrected = S.CorrectTypo(R.getLookupNameInfo(), 5882 R.getLookupKind(), Sc, &SS, 5883 Validator)) { 5884 std::string CorrectedStr(Corrected.getAsString(S.getLangOpts())); 5885 std::string CorrectedQuotedStr(Corrected.getQuoted(S.getLangOpts())); 5886 if (DeclContext *DC = S.computeDeclContext(SS, false)) 5887 S.Diag(IdentLoc, diag::err_using_directive_member_suggest) 5888 << Ident << DC << CorrectedQuotedStr << SS.getRange() 5889 << FixItHint::CreateReplacement(Corrected.getCorrectionRange(), 5890 CorrectedStr); 5891 else 5892 S.Diag(IdentLoc, diag::err_using_directive_suggest) 5893 << Ident << CorrectedQuotedStr 5894 << FixItHint::CreateReplacement(IdentLoc, CorrectedStr); 5895 5896 S.Diag(Corrected.getCorrectionDecl()->getLocation(), 5897 diag::note_namespace_defined_here) << CorrectedQuotedStr; 5898 5899 R.addDecl(Corrected.getCorrectionDecl()); 5900 return true; 5901 } 5902 return false; 5903} 5904 5905Decl *Sema::ActOnUsingDirective(Scope *S, 5906 SourceLocation UsingLoc, 5907 SourceLocation NamespcLoc, 5908 CXXScopeSpec &SS, 5909 SourceLocation IdentLoc, 5910 IdentifierInfo *NamespcName, 5911 AttributeList *AttrList) { 5912 assert(!SS.isInvalid() && "Invalid CXXScopeSpec."); 5913 assert(NamespcName && "Invalid NamespcName."); 5914 assert(IdentLoc.isValid() && "Invalid NamespceName location."); 5915 5916 // This can only happen along a recovery path. 5917 while (S->getFlags() & Scope::TemplateParamScope) 5918 S = S->getParent(); 5919 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope."); 5920 5921 UsingDirectiveDecl *UDir = 0; 5922 NestedNameSpecifier *Qualifier = 0; 5923 if (SS.isSet()) 5924 Qualifier = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 5925 5926 // Lookup namespace name. 5927 LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName); 5928 LookupParsedName(R, S, &SS); 5929 if (R.isAmbiguous()) 5930 return 0; 5931 5932 if (R.empty()) { 5933 R.clear(); 5934 // Allow "using namespace std;" or "using namespace ::std;" even if 5935 // "std" hasn't been defined yet, for GCC compatibility. 5936 if ((!Qualifier || Qualifier->getKind() == NestedNameSpecifier::Global) && 5937 NamespcName->isStr("std")) { 5938 Diag(IdentLoc, diag::ext_using_undefined_std); 5939 R.addDecl(getOrCreateStdNamespace()); 5940 R.resolveKind(); 5941 } 5942 // Otherwise, attempt typo correction. 5943 else TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, NamespcName); 5944 } 5945 5946 if (!R.empty()) { 5947 NamedDecl *Named = R.getFoundDecl(); 5948 assert((isa<NamespaceDecl>(Named) || isa<NamespaceAliasDecl>(Named)) 5949 && "expected namespace decl"); 5950 // C++ [namespace.udir]p1: 5951 // A using-directive specifies that the names in the nominated 5952 // namespace can be used in the scope in which the 5953 // using-directive appears after the using-directive. During 5954 // unqualified name lookup (3.4.1), the names appear as if they 5955 // were declared in the nearest enclosing namespace which 5956 // contains both the using-directive and the nominated 5957 // namespace. [Note: in this context, "contains" means "contains 5958 // directly or indirectly". ] 5959 5960 // Find enclosing context containing both using-directive and 5961 // nominated namespace. 5962 NamespaceDecl *NS = getNamespaceDecl(Named); 5963 DeclContext *CommonAncestor = cast<DeclContext>(NS); 5964 while (CommonAncestor && !CommonAncestor->Encloses(CurContext)) 5965 CommonAncestor = CommonAncestor->getParent(); 5966 5967 UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc, 5968 SS.getWithLocInContext(Context), 5969 IdentLoc, Named, CommonAncestor); 5970 5971 if (IsUsingDirectiveInToplevelContext(CurContext) && 5972 !SourceMgr.isFromMainFile(SourceMgr.getExpansionLoc(IdentLoc))) { 5973 Diag(IdentLoc, diag::warn_using_directive_in_header); 5974 } 5975 5976 PushUsingDirective(S, UDir); 5977 } else { 5978 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange(); 5979 } 5980 5981 // FIXME: We ignore attributes for now. 5982 return UDir; 5983} 5984 5985void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) { 5986 // If the scope has an associated entity and the using directive is at 5987 // namespace or translation unit scope, add the UsingDirectiveDecl into 5988 // its lookup structure so qualified name lookup can find it. 5989 DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity()); 5990 if (Ctx && !Ctx->isFunctionOrMethod()) 5991 Ctx->addDecl(UDir); 5992 else 5993 // Otherwise, it is at block sope. The using-directives will affect lookup 5994 // only to the end of the scope. 5995 S->PushUsingDirective(UDir); 5996} 5997 5998 5999Decl *Sema::ActOnUsingDeclaration(Scope *S, 6000 AccessSpecifier AS, 6001 bool HasUsingKeyword, 6002 SourceLocation UsingLoc, 6003 CXXScopeSpec &SS, 6004 UnqualifiedId &Name, 6005 AttributeList *AttrList, 6006 bool IsTypeName, 6007 SourceLocation TypenameLoc) { 6008 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope."); 6009 6010 switch (Name.getKind()) { 6011 case UnqualifiedId::IK_ImplicitSelfParam: 6012 case UnqualifiedId::IK_Identifier: 6013 case UnqualifiedId::IK_OperatorFunctionId: 6014 case UnqualifiedId::IK_LiteralOperatorId: 6015 case UnqualifiedId::IK_ConversionFunctionId: 6016 break; 6017 6018 case UnqualifiedId::IK_ConstructorName: 6019 case UnqualifiedId::IK_ConstructorTemplateId: 6020 // C++11 inheriting constructors. 6021 Diag(Name.getLocStart(), 6022 getLangOpts().CPlusPlus0x ? 6023 // FIXME: Produce warn_cxx98_compat_using_decl_constructor 6024 // instead once inheriting constructors work. 6025 diag::err_using_decl_constructor_unsupported : 6026 diag::err_using_decl_constructor) 6027 << SS.getRange(); 6028 6029 if (getLangOpts().CPlusPlus0x) break; 6030 6031 return 0; 6032 6033 case UnqualifiedId::IK_DestructorName: 6034 Diag(Name.getLocStart(), diag::err_using_decl_destructor) 6035 << SS.getRange(); 6036 return 0; 6037 6038 case UnqualifiedId::IK_TemplateId: 6039 Diag(Name.getLocStart(), diag::err_using_decl_template_id) 6040 << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc); 6041 return 0; 6042 } 6043 6044 DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name); 6045 DeclarationName TargetName = TargetNameInfo.getName(); 6046 if (!TargetName) 6047 return 0; 6048 6049 // Warn about using declarations. 6050 // TODO: store that the declaration was written without 'using' and 6051 // talk about access decls instead of using decls in the 6052 // diagnostics. 6053 if (!HasUsingKeyword) { 6054 UsingLoc = Name.getLocStart(); 6055 6056 Diag(UsingLoc, diag::warn_access_decl_deprecated) 6057 << FixItHint::CreateInsertion(SS.getRange().getBegin(), "using "); 6058 } 6059 6060 if (DiagnoseUnexpandedParameterPack(SS, UPPC_UsingDeclaration) || 6061 DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC_UsingDeclaration)) 6062 return 0; 6063 6064 NamedDecl *UD = BuildUsingDeclaration(S, AS, UsingLoc, SS, 6065 TargetNameInfo, AttrList, 6066 /* IsInstantiation */ false, 6067 IsTypeName, TypenameLoc); 6068 if (UD) 6069 PushOnScopeChains(UD, S, /*AddToContext*/ false); 6070 6071 return UD; 6072} 6073 6074/// \brief Determine whether a using declaration considers the given 6075/// declarations as "equivalent", e.g., if they are redeclarations of 6076/// the same entity or are both typedefs of the same type. 6077static bool 6078IsEquivalentForUsingDecl(ASTContext &Context, NamedDecl *D1, NamedDecl *D2, 6079 bool &SuppressRedeclaration) { 6080 if (D1->getCanonicalDecl() == D2->getCanonicalDecl()) { 6081 SuppressRedeclaration = false; 6082 return true; 6083 } 6084 6085 if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(D1)) 6086 if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2)) { 6087 SuppressRedeclaration = true; 6088 return Context.hasSameType(TD1->getUnderlyingType(), 6089 TD2->getUnderlyingType()); 6090 } 6091 6092 return false; 6093} 6094 6095 6096/// Determines whether to create a using shadow decl for a particular 6097/// decl, given the set of decls existing prior to this using lookup. 6098bool Sema::CheckUsingShadowDecl(UsingDecl *Using, NamedDecl *Orig, 6099 const LookupResult &Previous) { 6100 // Diagnose finding a decl which is not from a base class of the 6101 // current class. We do this now because there are cases where this 6102 // function will silently decide not to build a shadow decl, which 6103 // will pre-empt further diagnostics. 6104 // 6105 // We don't need to do this in C++0x because we do the check once on 6106 // the qualifier. 6107 // 6108 // FIXME: diagnose the following if we care enough: 6109 // struct A { int foo; }; 6110 // struct B : A { using A::foo; }; 6111 // template <class T> struct C : A {}; 6112 // template <class T> struct D : C<T> { using B::foo; } // <--- 6113 // This is invalid (during instantiation) in C++03 because B::foo 6114 // resolves to the using decl in B, which is not a base class of D<T>. 6115 // We can't diagnose it immediately because C<T> is an unknown 6116 // specialization. The UsingShadowDecl in D<T> then points directly 6117 // to A::foo, which will look well-formed when we instantiate. 6118 // The right solution is to not collapse the shadow-decl chain. 6119 if (!getLangOpts().CPlusPlus0x && CurContext->isRecord()) { 6120 DeclContext *OrigDC = Orig->getDeclContext(); 6121 6122 // Handle enums and anonymous structs. 6123 if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent(); 6124 CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC); 6125 while (OrigRec->isAnonymousStructOrUnion()) 6126 OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext()); 6127 6128 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) { 6129 if (OrigDC == CurContext) { 6130 Diag(Using->getLocation(), 6131 diag::err_using_decl_nested_name_specifier_is_current_class) 6132 << Using->getQualifierLoc().getSourceRange(); 6133 Diag(Orig->getLocation(), diag::note_using_decl_target); 6134 return true; 6135 } 6136 6137 Diag(Using->getQualifierLoc().getBeginLoc(), 6138 diag::err_using_decl_nested_name_specifier_is_not_base_class) 6139 << Using->getQualifier() 6140 << cast<CXXRecordDecl>(CurContext) 6141 << Using->getQualifierLoc().getSourceRange(); 6142 Diag(Orig->getLocation(), diag::note_using_decl_target); 6143 return true; 6144 } 6145 } 6146 6147 if (Previous.empty()) return false; 6148 6149 NamedDecl *Target = Orig; 6150 if (isa<UsingShadowDecl>(Target)) 6151 Target = cast<UsingShadowDecl>(Target)->getTargetDecl(); 6152 6153 // If the target happens to be one of the previous declarations, we 6154 // don't have a conflict. 6155 // 6156 // FIXME: but we might be increasing its access, in which case we 6157 // should redeclare it. 6158 NamedDecl *NonTag = 0, *Tag = 0; 6159 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 6160 I != E; ++I) { 6161 NamedDecl *D = (*I)->getUnderlyingDecl(); 6162 bool Result; 6163 if (IsEquivalentForUsingDecl(Context, D, Target, Result)) 6164 return Result; 6165 6166 (isa<TagDecl>(D) ? Tag : NonTag) = D; 6167 } 6168 6169 if (Target->isFunctionOrFunctionTemplate()) { 6170 FunctionDecl *FD; 6171 if (isa<FunctionTemplateDecl>(Target)) 6172 FD = cast<FunctionTemplateDecl>(Target)->getTemplatedDecl(); 6173 else 6174 FD = cast<FunctionDecl>(Target); 6175 6176 NamedDecl *OldDecl = 0; 6177 switch (CheckOverload(0, FD, Previous, OldDecl, /*IsForUsingDecl*/ true)) { 6178 case Ovl_Overload: 6179 return false; 6180 6181 case Ovl_NonFunction: 6182 Diag(Using->getLocation(), diag::err_using_decl_conflict); 6183 break; 6184 6185 // We found a decl with the exact signature. 6186 case Ovl_Match: 6187 // If we're in a record, we want to hide the target, so we 6188 // return true (without a diagnostic) to tell the caller not to 6189 // build a shadow decl. 6190 if (CurContext->isRecord()) 6191 return true; 6192 6193 // If we're not in a record, this is an error. 6194 Diag(Using->getLocation(), diag::err_using_decl_conflict); 6195 break; 6196 } 6197 6198 Diag(Target->getLocation(), diag::note_using_decl_target); 6199 Diag(OldDecl->getLocation(), diag::note_using_decl_conflict); 6200 return true; 6201 } 6202 6203 // Target is not a function. 6204 6205 if (isa<TagDecl>(Target)) { 6206 // No conflict between a tag and a non-tag. 6207 if (!Tag) return false; 6208 6209 Diag(Using->getLocation(), diag::err_using_decl_conflict); 6210 Diag(Target->getLocation(), diag::note_using_decl_target); 6211 Diag(Tag->getLocation(), diag::note_using_decl_conflict); 6212 return true; 6213 } 6214 6215 // No conflict between a tag and a non-tag. 6216 if (!NonTag) return false; 6217 6218 Diag(Using->getLocation(), diag::err_using_decl_conflict); 6219 Diag(Target->getLocation(), diag::note_using_decl_target); 6220 Diag(NonTag->getLocation(), diag::note_using_decl_conflict); 6221 return true; 6222} 6223 6224/// Builds a shadow declaration corresponding to a 'using' declaration. 6225UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S, 6226 UsingDecl *UD, 6227 NamedDecl *Orig) { 6228 6229 // If we resolved to another shadow declaration, just coalesce them. 6230 NamedDecl *Target = Orig; 6231 if (isa<UsingShadowDecl>(Target)) { 6232 Target = cast<UsingShadowDecl>(Target)->getTargetDecl(); 6233 assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration"); 6234 } 6235 6236 UsingShadowDecl *Shadow 6237 = UsingShadowDecl::Create(Context, CurContext, 6238 UD->getLocation(), UD, Target); 6239 UD->addShadowDecl(Shadow); 6240 6241 Shadow->setAccess(UD->getAccess()); 6242 if (Orig->isInvalidDecl() || UD->isInvalidDecl()) 6243 Shadow->setInvalidDecl(); 6244 6245 if (S) 6246 PushOnScopeChains(Shadow, S); 6247 else 6248 CurContext->addDecl(Shadow); 6249 6250 6251 return Shadow; 6252} 6253 6254/// Hides a using shadow declaration. This is required by the current 6255/// using-decl implementation when a resolvable using declaration in a 6256/// class is followed by a declaration which would hide or override 6257/// one or more of the using decl's targets; for example: 6258/// 6259/// struct Base { void foo(int); }; 6260/// struct Derived : Base { 6261/// using Base::foo; 6262/// void foo(int); 6263/// }; 6264/// 6265/// The governing language is C++03 [namespace.udecl]p12: 6266/// 6267/// When a using-declaration brings names from a base class into a 6268/// derived class scope, member functions in the derived class 6269/// override and/or hide member functions with the same name and 6270/// parameter types in a base class (rather than conflicting). 6271/// 6272/// There are two ways to implement this: 6273/// (1) optimistically create shadow decls when they're not hidden 6274/// by existing declarations, or 6275/// (2) don't create any shadow decls (or at least don't make them 6276/// visible) until we've fully parsed/instantiated the class. 6277/// The problem with (1) is that we might have to retroactively remove 6278/// a shadow decl, which requires several O(n) operations because the 6279/// decl structures are (very reasonably) not designed for removal. 6280/// (2) avoids this but is very fiddly and phase-dependent. 6281void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) { 6282 if (Shadow->getDeclName().getNameKind() == 6283 DeclarationName::CXXConversionFunctionName) 6284 cast<CXXRecordDecl>(Shadow->getDeclContext())->removeConversion(Shadow); 6285 6286 // Remove it from the DeclContext... 6287 Shadow->getDeclContext()->removeDecl(Shadow); 6288 6289 // ...and the scope, if applicable... 6290 if (S) { 6291 S->RemoveDecl(Shadow); 6292 IdResolver.RemoveDecl(Shadow); 6293 } 6294 6295 // ...and the using decl. 6296 Shadow->getUsingDecl()->removeShadowDecl(Shadow); 6297 6298 // TODO: complain somehow if Shadow was used. It shouldn't 6299 // be possible for this to happen, because...? 6300} 6301 6302/// Builds a using declaration. 6303/// 6304/// \param IsInstantiation - Whether this call arises from an 6305/// instantiation of an unresolved using declaration. We treat 6306/// the lookup differently for these declarations. 6307NamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS, 6308 SourceLocation UsingLoc, 6309 CXXScopeSpec &SS, 6310 const DeclarationNameInfo &NameInfo, 6311 AttributeList *AttrList, 6312 bool IsInstantiation, 6313 bool IsTypeName, 6314 SourceLocation TypenameLoc) { 6315 assert(!SS.isInvalid() && "Invalid CXXScopeSpec."); 6316 SourceLocation IdentLoc = NameInfo.getLoc(); 6317 assert(IdentLoc.isValid() && "Invalid TargetName location."); 6318 6319 // FIXME: We ignore attributes for now. 6320 6321 if (SS.isEmpty()) { 6322 Diag(IdentLoc, diag::err_using_requires_qualname); 6323 return 0; 6324 } 6325 6326 // Do the redeclaration lookup in the current scope. 6327 LookupResult Previous(*this, NameInfo, LookupUsingDeclName, 6328 ForRedeclaration); 6329 Previous.setHideTags(false); 6330 if (S) { 6331 LookupName(Previous, S); 6332 6333 // It is really dumb that we have to do this. 6334 LookupResult::Filter F = Previous.makeFilter(); 6335 while (F.hasNext()) { 6336 NamedDecl *D = F.next(); 6337 if (!isDeclInScope(D, CurContext, S)) 6338 F.erase(); 6339 } 6340 F.done(); 6341 } else { 6342 assert(IsInstantiation && "no scope in non-instantiation"); 6343 assert(CurContext->isRecord() && "scope not record in instantiation"); 6344 LookupQualifiedName(Previous, CurContext); 6345 } 6346 6347 // Check for invalid redeclarations. 6348 if (CheckUsingDeclRedeclaration(UsingLoc, IsTypeName, SS, IdentLoc, Previous)) 6349 return 0; 6350 6351 // Check for bad qualifiers. 6352 if (CheckUsingDeclQualifier(UsingLoc, SS, IdentLoc)) 6353 return 0; 6354 6355 DeclContext *LookupContext = computeDeclContext(SS); 6356 NamedDecl *D; 6357 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context); 6358 if (!LookupContext) { 6359 if (IsTypeName) { 6360 // FIXME: not all declaration name kinds are legal here 6361 D = UnresolvedUsingTypenameDecl::Create(Context, CurContext, 6362 UsingLoc, TypenameLoc, 6363 QualifierLoc, 6364 IdentLoc, NameInfo.getName()); 6365 } else { 6366 D = UnresolvedUsingValueDecl::Create(Context, CurContext, UsingLoc, 6367 QualifierLoc, NameInfo); 6368 } 6369 } else { 6370 D = UsingDecl::Create(Context, CurContext, UsingLoc, QualifierLoc, 6371 NameInfo, IsTypeName); 6372 } 6373 D->setAccess(AS); 6374 CurContext->addDecl(D); 6375 6376 if (!LookupContext) return D; 6377 UsingDecl *UD = cast<UsingDecl>(D); 6378 6379 if (RequireCompleteDeclContext(SS, LookupContext)) { 6380 UD->setInvalidDecl(); 6381 return UD; 6382 } 6383 6384 // The normal rules do not apply to inheriting constructor declarations. 6385 if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName) { 6386 if (CheckInheritingConstructorUsingDecl(UD)) 6387 UD->setInvalidDecl(); 6388 return UD; 6389 } 6390 6391 // Otherwise, look up the target name. 6392 6393 LookupResult R(*this, NameInfo, LookupOrdinaryName); 6394 6395 // Unlike most lookups, we don't always want to hide tag 6396 // declarations: tag names are visible through the using declaration 6397 // even if hidden by ordinary names, *except* in a dependent context 6398 // where it's important for the sanity of two-phase lookup. 6399 if (!IsInstantiation) 6400 R.setHideTags(false); 6401 6402 // For the purposes of this lookup, we have a base object type 6403 // equal to that of the current context. 6404 if (CurContext->isRecord()) { 6405 R.setBaseObjectType( 6406 Context.getTypeDeclType(cast<CXXRecordDecl>(CurContext))); 6407 } 6408 6409 LookupQualifiedName(R, LookupContext); 6410 6411 if (R.empty()) { 6412 Diag(IdentLoc, diag::err_no_member) 6413 << NameInfo.getName() << LookupContext << SS.getRange(); 6414 UD->setInvalidDecl(); 6415 return UD; 6416 } 6417 6418 if (R.isAmbiguous()) { 6419 UD->setInvalidDecl(); 6420 return UD; 6421 } 6422 6423 if (IsTypeName) { 6424 // If we asked for a typename and got a non-type decl, error out. 6425 if (!R.getAsSingle<TypeDecl>()) { 6426 Diag(IdentLoc, diag::err_using_typename_non_type); 6427 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) 6428 Diag((*I)->getUnderlyingDecl()->getLocation(), 6429 diag::note_using_decl_target); 6430 UD->setInvalidDecl(); 6431 return UD; 6432 } 6433 } else { 6434 // If we asked for a non-typename and we got a type, error out, 6435 // but only if this is an instantiation of an unresolved using 6436 // decl. Otherwise just silently find the type name. 6437 if (IsInstantiation && R.getAsSingle<TypeDecl>()) { 6438 Diag(IdentLoc, diag::err_using_dependent_value_is_type); 6439 Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target); 6440 UD->setInvalidDecl(); 6441 return UD; 6442 } 6443 } 6444 6445 // C++0x N2914 [namespace.udecl]p6: 6446 // A using-declaration shall not name a namespace. 6447 if (R.getAsSingle<NamespaceDecl>()) { 6448 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace) 6449 << SS.getRange(); 6450 UD->setInvalidDecl(); 6451 return UD; 6452 } 6453 6454 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { 6455 if (!CheckUsingShadowDecl(UD, *I, Previous)) 6456 BuildUsingShadowDecl(S, UD, *I); 6457 } 6458 6459 return UD; 6460} 6461 6462/// Additional checks for a using declaration referring to a constructor name. 6463bool Sema::CheckInheritingConstructorUsingDecl(UsingDecl *UD) { 6464 assert(!UD->isTypeName() && "expecting a constructor name"); 6465 6466 const Type *SourceType = UD->getQualifier()->getAsType(); 6467 assert(SourceType && 6468 "Using decl naming constructor doesn't have type in scope spec."); 6469 CXXRecordDecl *TargetClass = cast<CXXRecordDecl>(CurContext); 6470 6471 // Check whether the named type is a direct base class. 6472 CanQualType CanonicalSourceType = SourceType->getCanonicalTypeUnqualified(); 6473 CXXRecordDecl::base_class_iterator BaseIt, BaseE; 6474 for (BaseIt = TargetClass->bases_begin(), BaseE = TargetClass->bases_end(); 6475 BaseIt != BaseE; ++BaseIt) { 6476 CanQualType BaseType = BaseIt->getType()->getCanonicalTypeUnqualified(); 6477 if (CanonicalSourceType == BaseType) 6478 break; 6479 if (BaseIt->getType()->isDependentType()) 6480 break; 6481 } 6482 6483 if (BaseIt == BaseE) { 6484 // Did not find SourceType in the bases. 6485 Diag(UD->getUsingLocation(), 6486 diag::err_using_decl_constructor_not_in_direct_base) 6487 << UD->getNameInfo().getSourceRange() 6488 << QualType(SourceType, 0) << TargetClass; 6489 return true; 6490 } 6491 6492 if (!CurContext->isDependentContext()) 6493 BaseIt->setInheritConstructors(); 6494 6495 return false; 6496} 6497 6498/// Checks that the given using declaration is not an invalid 6499/// redeclaration. Note that this is checking only for the using decl 6500/// itself, not for any ill-formedness among the UsingShadowDecls. 6501bool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc, 6502 bool isTypeName, 6503 const CXXScopeSpec &SS, 6504 SourceLocation NameLoc, 6505 const LookupResult &Prev) { 6506 // C++03 [namespace.udecl]p8: 6507 // C++0x [namespace.udecl]p10: 6508 // A using-declaration is a declaration and can therefore be used 6509 // repeatedly where (and only where) multiple declarations are 6510 // allowed. 6511 // 6512 // That's in non-member contexts. 6513 if (!CurContext->getRedeclContext()->isRecord()) 6514 return false; 6515 6516 NestedNameSpecifier *Qual 6517 = static_cast<NestedNameSpecifier*>(SS.getScopeRep()); 6518 6519 for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) { 6520 NamedDecl *D = *I; 6521 6522 bool DTypename; 6523 NestedNameSpecifier *DQual; 6524 if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) { 6525 DTypename = UD->isTypeName(); 6526 DQual = UD->getQualifier(); 6527 } else if (UnresolvedUsingValueDecl *UD 6528 = dyn_cast<UnresolvedUsingValueDecl>(D)) { 6529 DTypename = false; 6530 DQual = UD->getQualifier(); 6531 } else if (UnresolvedUsingTypenameDecl *UD 6532 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) { 6533 DTypename = true; 6534 DQual = UD->getQualifier(); 6535 } else continue; 6536 6537 // using decls differ if one says 'typename' and the other doesn't. 6538 // FIXME: non-dependent using decls? 6539 if (isTypeName != DTypename) continue; 6540 6541 // using decls differ if they name different scopes (but note that 6542 // template instantiation can cause this check to trigger when it 6543 // didn't before instantiation). 6544 if (Context.getCanonicalNestedNameSpecifier(Qual) != 6545 Context.getCanonicalNestedNameSpecifier(DQual)) 6546 continue; 6547 6548 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange(); 6549 Diag(D->getLocation(), diag::note_using_decl) << 1; 6550 return true; 6551 } 6552 6553 return false; 6554} 6555 6556 6557/// Checks that the given nested-name qualifier used in a using decl 6558/// in the current context is appropriately related to the current 6559/// scope. If an error is found, diagnoses it and returns true. 6560bool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, 6561 const CXXScopeSpec &SS, 6562 SourceLocation NameLoc) { 6563 DeclContext *NamedContext = computeDeclContext(SS); 6564 6565 if (!CurContext->isRecord()) { 6566 // C++03 [namespace.udecl]p3: 6567 // C++0x [namespace.udecl]p8: 6568 // A using-declaration for a class member shall be a member-declaration. 6569 6570 // If we weren't able to compute a valid scope, it must be a 6571 // dependent class scope. 6572 if (!NamedContext || NamedContext->isRecord()) { 6573 Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member) 6574 << SS.getRange(); 6575 return true; 6576 } 6577 6578 // Otherwise, everything is known to be fine. 6579 return false; 6580 } 6581 6582 // The current scope is a record. 6583 6584 // If the named context is dependent, we can't decide much. 6585 if (!NamedContext) { 6586 // FIXME: in C++0x, we can diagnose if we can prove that the 6587 // nested-name-specifier does not refer to a base class, which is 6588 // still possible in some cases. 6589 6590 // Otherwise we have to conservatively report that things might be 6591 // okay. 6592 return false; 6593 } 6594 6595 if (!NamedContext->isRecord()) { 6596 // Ideally this would point at the last name in the specifier, 6597 // but we don't have that level of source info. 6598 Diag(SS.getRange().getBegin(), 6599 diag::err_using_decl_nested_name_specifier_is_not_class) 6600 << (NestedNameSpecifier*) SS.getScopeRep() << SS.getRange(); 6601 return true; 6602 } 6603 6604 if (!NamedContext->isDependentContext() && 6605 RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), NamedContext)) 6606 return true; 6607 6608 if (getLangOpts().CPlusPlus0x) { 6609 // C++0x [namespace.udecl]p3: 6610 // In a using-declaration used as a member-declaration, the 6611 // nested-name-specifier shall name a base class of the class 6612 // being defined. 6613 6614 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom( 6615 cast<CXXRecordDecl>(NamedContext))) { 6616 if (CurContext == NamedContext) { 6617 Diag(NameLoc, 6618 diag::err_using_decl_nested_name_specifier_is_current_class) 6619 << SS.getRange(); 6620 return true; 6621 } 6622 6623 Diag(SS.getRange().getBegin(), 6624 diag::err_using_decl_nested_name_specifier_is_not_base_class) 6625 << (NestedNameSpecifier*) SS.getScopeRep() 6626 << cast<CXXRecordDecl>(CurContext) 6627 << SS.getRange(); 6628 return true; 6629 } 6630 6631 return false; 6632 } 6633 6634 // C++03 [namespace.udecl]p4: 6635 // A using-declaration used as a member-declaration shall refer 6636 // to a member of a base class of the class being defined [etc.]. 6637 6638 // Salient point: SS doesn't have to name a base class as long as 6639 // lookup only finds members from base classes. Therefore we can 6640 // diagnose here only if we can prove that that can't happen, 6641 // i.e. if the class hierarchies provably don't intersect. 6642 6643 // TODO: it would be nice if "definitely valid" results were cached 6644 // in the UsingDecl and UsingShadowDecl so that these checks didn't 6645 // need to be repeated. 6646 6647 struct UserData { 6648 llvm::SmallPtrSet<const CXXRecordDecl*, 4> Bases; 6649 6650 static bool collect(const CXXRecordDecl *Base, void *OpaqueData) { 6651 UserData *Data = reinterpret_cast<UserData*>(OpaqueData); 6652 Data->Bases.insert(Base); 6653 return true; 6654 } 6655 6656 bool hasDependentBases(const CXXRecordDecl *Class) { 6657 return !Class->forallBases(collect, this); 6658 } 6659 6660 /// Returns true if the base is dependent or is one of the 6661 /// accumulated base classes. 6662 static bool doesNotContain(const CXXRecordDecl *Base, void *OpaqueData) { 6663 UserData *Data = reinterpret_cast<UserData*>(OpaqueData); 6664 return !Data->Bases.count(Base); 6665 } 6666 6667 bool mightShareBases(const CXXRecordDecl *Class) { 6668 return Bases.count(Class) || !Class->forallBases(doesNotContain, this); 6669 } 6670 }; 6671 6672 UserData Data; 6673 6674 // Returns false if we find a dependent base. 6675 if (Data.hasDependentBases(cast<CXXRecordDecl>(CurContext))) 6676 return false; 6677 6678 // Returns false if the class has a dependent base or if it or one 6679 // of its bases is present in the base set of the current context. 6680 if (Data.mightShareBases(cast<CXXRecordDecl>(NamedContext))) 6681 return false; 6682 6683 Diag(SS.getRange().getBegin(), 6684 diag::err_using_decl_nested_name_specifier_is_not_base_class) 6685 << (NestedNameSpecifier*) SS.getScopeRep() 6686 << cast<CXXRecordDecl>(CurContext) 6687 << SS.getRange(); 6688 6689 return true; 6690} 6691 6692Decl *Sema::ActOnAliasDeclaration(Scope *S, 6693 AccessSpecifier AS, 6694 MultiTemplateParamsArg TemplateParamLists, 6695 SourceLocation UsingLoc, 6696 UnqualifiedId &Name, 6697 TypeResult Type) { 6698 // Skip up to the relevant declaration scope. 6699 while (S->getFlags() & Scope::TemplateParamScope) 6700 S = S->getParent(); 6701 assert((S->getFlags() & Scope::DeclScope) && 6702 "got alias-declaration outside of declaration scope"); 6703 6704 if (Type.isInvalid()) 6705 return 0; 6706 6707 bool Invalid = false; 6708 DeclarationNameInfo NameInfo = GetNameFromUnqualifiedId(Name); 6709 TypeSourceInfo *TInfo = 0; 6710 GetTypeFromParser(Type.get(), &TInfo); 6711 6712 if (DiagnoseClassNameShadow(CurContext, NameInfo)) 6713 return 0; 6714 6715 if (DiagnoseUnexpandedParameterPack(Name.StartLocation, TInfo, 6716 UPPC_DeclarationType)) { 6717 Invalid = true; 6718 TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy, 6719 TInfo->getTypeLoc().getBeginLoc()); 6720 } 6721 6722 LookupResult Previous(*this, NameInfo, LookupOrdinaryName, ForRedeclaration); 6723 LookupName(Previous, S); 6724 6725 // Warn about shadowing the name of a template parameter. 6726 if (Previous.isSingleResult() && 6727 Previous.getFoundDecl()->isTemplateParameter()) { 6728 DiagnoseTemplateParameterShadow(Name.StartLocation,Previous.getFoundDecl()); 6729 Previous.clear(); 6730 } 6731 6732 assert(Name.Kind == UnqualifiedId::IK_Identifier && 6733 "name in alias declaration must be an identifier"); 6734 TypeAliasDecl *NewTD = TypeAliasDecl::Create(Context, CurContext, UsingLoc, 6735 Name.StartLocation, 6736 Name.Identifier, TInfo); 6737 6738 NewTD->setAccess(AS); 6739 6740 if (Invalid) 6741 NewTD->setInvalidDecl(); 6742 6743 CheckTypedefForVariablyModifiedType(S, NewTD); 6744 Invalid |= NewTD->isInvalidDecl(); 6745 6746 bool Redeclaration = false; 6747 6748 NamedDecl *NewND; 6749 if (TemplateParamLists.size()) { 6750 TypeAliasTemplateDecl *OldDecl = 0; 6751 TemplateParameterList *OldTemplateParams = 0; 6752 6753 if (TemplateParamLists.size() != 1) { 6754 Diag(UsingLoc, diag::err_alias_template_extra_headers) 6755 << SourceRange(TemplateParamLists[1]->getTemplateLoc(), 6756 TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc()); 6757 } 6758 TemplateParameterList *TemplateParams = TemplateParamLists[0]; 6759 6760 // Only consider previous declarations in the same scope. 6761 FilterLookupForScope(Previous, CurContext, S, /*ConsiderLinkage*/false, 6762 /*ExplicitInstantiationOrSpecialization*/false); 6763 if (!Previous.empty()) { 6764 Redeclaration = true; 6765 6766 OldDecl = Previous.getAsSingle<TypeAliasTemplateDecl>(); 6767 if (!OldDecl && !Invalid) { 6768 Diag(UsingLoc, diag::err_redefinition_different_kind) 6769 << Name.Identifier; 6770 6771 NamedDecl *OldD = Previous.getRepresentativeDecl(); 6772 if (OldD->getLocation().isValid()) 6773 Diag(OldD->getLocation(), diag::note_previous_definition); 6774 6775 Invalid = true; 6776 } 6777 6778 if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) { 6779 if (TemplateParameterListsAreEqual(TemplateParams, 6780 OldDecl->getTemplateParameters(), 6781 /*Complain=*/true, 6782 TPL_TemplateMatch)) 6783 OldTemplateParams = OldDecl->getTemplateParameters(); 6784 else 6785 Invalid = true; 6786 6787 TypeAliasDecl *OldTD = OldDecl->getTemplatedDecl(); 6788 if (!Invalid && 6789 !Context.hasSameType(OldTD->getUnderlyingType(), 6790 NewTD->getUnderlyingType())) { 6791 // FIXME: The C++0x standard does not clearly say this is ill-formed, 6792 // but we can't reasonably accept it. 6793 Diag(NewTD->getLocation(), diag::err_redefinition_different_typedef) 6794 << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType(); 6795 if (OldTD->getLocation().isValid()) 6796 Diag(OldTD->getLocation(), diag::note_previous_definition); 6797 Invalid = true; 6798 } 6799 } 6800 } 6801 6802 // Merge any previous default template arguments into our parameters, 6803 // and check the parameter list. 6804 if (CheckTemplateParameterList(TemplateParams, OldTemplateParams, 6805 TPC_TypeAliasTemplate)) 6806 return 0; 6807 6808 TypeAliasTemplateDecl *NewDecl = 6809 TypeAliasTemplateDecl::Create(Context, CurContext, UsingLoc, 6810 Name.Identifier, TemplateParams, 6811 NewTD); 6812 6813 NewDecl->setAccess(AS); 6814 6815 if (Invalid) 6816 NewDecl->setInvalidDecl(); 6817 else if (OldDecl) 6818 NewDecl->setPreviousDeclaration(OldDecl); 6819 6820 NewND = NewDecl; 6821 } else { 6822 ActOnTypedefNameDecl(S, CurContext, NewTD, Previous, Redeclaration); 6823 NewND = NewTD; 6824 } 6825 6826 if (!Redeclaration) 6827 PushOnScopeChains(NewND, S); 6828 6829 ActOnDocumentableDecl(NewND); 6830 return NewND; 6831} 6832 6833Decl *Sema::ActOnNamespaceAliasDef(Scope *S, 6834 SourceLocation NamespaceLoc, 6835 SourceLocation AliasLoc, 6836 IdentifierInfo *Alias, 6837 CXXScopeSpec &SS, 6838 SourceLocation IdentLoc, 6839 IdentifierInfo *Ident) { 6840 6841 // Lookup the namespace name. 6842 LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName); 6843 LookupParsedName(R, S, &SS); 6844 6845 // Check if we have a previous declaration with the same name. 6846 NamedDecl *PrevDecl 6847 = LookupSingleName(S, Alias, AliasLoc, LookupOrdinaryName, 6848 ForRedeclaration); 6849 if (PrevDecl && !isDeclInScope(PrevDecl, CurContext, S)) 6850 PrevDecl = 0; 6851 6852 if (PrevDecl) { 6853 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) { 6854 // We already have an alias with the same name that points to the same 6855 // namespace, so don't create a new one. 6856 // FIXME: At some point, we'll want to create the (redundant) 6857 // declaration to maintain better source information. 6858 if (!R.isAmbiguous() && !R.empty() && 6859 AD->getNamespace()->Equals(getNamespaceDecl(R.getFoundDecl()))) 6860 return 0; 6861 } 6862 6863 unsigned DiagID = isa<NamespaceDecl>(PrevDecl) ? diag::err_redefinition : 6864 diag::err_redefinition_different_kind; 6865 Diag(AliasLoc, DiagID) << Alias; 6866 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 6867 return 0; 6868 } 6869 6870 if (R.isAmbiguous()) 6871 return 0; 6872 6873 if (R.empty()) { 6874 if (!TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, Ident)) { 6875 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange(); 6876 return 0; 6877 } 6878 } 6879 6880 NamespaceAliasDecl *AliasDecl = 6881 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc, 6882 Alias, SS.getWithLocInContext(Context), 6883 IdentLoc, R.getFoundDecl()); 6884 6885 PushOnScopeChains(AliasDecl, S); 6886 return AliasDecl; 6887} 6888 6889Sema::ImplicitExceptionSpecification 6890Sema::ComputeDefaultedDefaultCtorExceptionSpec(SourceLocation Loc, 6891 CXXMethodDecl *MD) { 6892 CXXRecordDecl *ClassDecl = MD->getParent(); 6893 6894 // C++ [except.spec]p14: 6895 // An implicitly declared special member function (Clause 12) shall have an 6896 // exception-specification. [...] 6897 ImplicitExceptionSpecification ExceptSpec(*this); 6898 if (ClassDecl->isInvalidDecl()) 6899 return ExceptSpec; 6900 6901 // Direct base-class constructors. 6902 for (CXXRecordDecl::base_class_iterator B = ClassDecl->bases_begin(), 6903 BEnd = ClassDecl->bases_end(); 6904 B != BEnd; ++B) { 6905 if (B->isVirtual()) // Handled below. 6906 continue; 6907 6908 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) { 6909 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl()); 6910 CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl); 6911 // If this is a deleted function, add it anyway. This might be conformant 6912 // with the standard. This might not. I'm not sure. It might not matter. 6913 if (Constructor) 6914 ExceptSpec.CalledDecl(B->getLocStart(), Constructor); 6915 } 6916 } 6917 6918 // Virtual base-class constructors. 6919 for (CXXRecordDecl::base_class_iterator B = ClassDecl->vbases_begin(), 6920 BEnd = ClassDecl->vbases_end(); 6921 B != BEnd; ++B) { 6922 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) { 6923 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl()); 6924 CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl); 6925 // If this is a deleted function, add it anyway. This might be conformant 6926 // with the standard. This might not. I'm not sure. It might not matter. 6927 if (Constructor) 6928 ExceptSpec.CalledDecl(B->getLocStart(), Constructor); 6929 } 6930 } 6931 6932 // Field constructors. 6933 for (RecordDecl::field_iterator F = ClassDecl->field_begin(), 6934 FEnd = ClassDecl->field_end(); 6935 F != FEnd; ++F) { 6936 if (F->hasInClassInitializer()) { 6937 if (Expr *E = F->getInClassInitializer()) 6938 ExceptSpec.CalledExpr(E); 6939 else if (!F->isInvalidDecl()) 6940 // DR1351: 6941 // If the brace-or-equal-initializer of a non-static data member 6942 // invokes a defaulted default constructor of its class or of an 6943 // enclosing class in a potentially evaluated subexpression, the 6944 // program is ill-formed. 6945 // 6946 // This resolution is unworkable: the exception specification of the 6947 // default constructor can be needed in an unevaluated context, in 6948 // particular, in the operand of a noexcept-expression, and we can be 6949 // unable to compute an exception specification for an enclosed class. 6950 // 6951 // We do not allow an in-class initializer to require the evaluation 6952 // of the exception specification for any in-class initializer whose 6953 // definition is not lexically complete. 6954 Diag(Loc, diag::err_in_class_initializer_references_def_ctor) << MD; 6955 } else if (const RecordType *RecordTy 6956 = Context.getBaseElementType(F->getType())->getAs<RecordType>()) { 6957 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl()); 6958 CXXConstructorDecl *Constructor = LookupDefaultConstructor(FieldRecDecl); 6959 // If this is a deleted function, add it anyway. This might be conformant 6960 // with the standard. This might not. I'm not sure. It might not matter. 6961 // In particular, the problem is that this function never gets called. It 6962 // might just be ill-formed because this function attempts to refer to 6963 // a deleted function here. 6964 if (Constructor) 6965 ExceptSpec.CalledDecl(F->getLocation(), Constructor); 6966 } 6967 } 6968 6969 return ExceptSpec; 6970} 6971 6972CXXConstructorDecl *Sema::DeclareImplicitDefaultConstructor( 6973 CXXRecordDecl *ClassDecl) { 6974 // C++ [class.ctor]p5: 6975 // A default constructor for a class X is a constructor of class X 6976 // that can be called without an argument. If there is no 6977 // user-declared constructor for class X, a default constructor is 6978 // implicitly declared. An implicitly-declared default constructor 6979 // is an inline public member of its class. 6980 assert(!ClassDecl->hasUserDeclaredConstructor() && 6981 "Should not build implicit default constructor!"); 6982 6983 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl, 6984 CXXDefaultConstructor, 6985 false); 6986 6987 // Create the actual constructor declaration. 6988 CanQualType ClassType 6989 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl)); 6990 SourceLocation ClassLoc = ClassDecl->getLocation(); 6991 DeclarationName Name 6992 = Context.DeclarationNames.getCXXConstructorName(ClassType); 6993 DeclarationNameInfo NameInfo(Name, ClassLoc); 6994 CXXConstructorDecl *DefaultCon = CXXConstructorDecl::Create( 6995 Context, ClassDecl, ClassLoc, NameInfo, /*Type*/QualType(), /*TInfo=*/0, 6996 /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true, 6997 Constexpr); 6998 DefaultCon->setAccess(AS_public); 6999 DefaultCon->setDefaulted(); 7000 DefaultCon->setImplicit(); 7001 DefaultCon->setTrivial(ClassDecl->hasTrivialDefaultConstructor()); 7002 7003 // Build an exception specification pointing back at this constructor. 7004 FunctionProtoType::ExtProtoInfo EPI; 7005 EPI.ExceptionSpecType = EST_Unevaluated; 7006 EPI.ExceptionSpecDecl = DefaultCon; 7007 DefaultCon->setType(Context.getFunctionType(Context.VoidTy, 0, 0, EPI)); 7008 7009 // Note that we have declared this constructor. 7010 ++ASTContext::NumImplicitDefaultConstructorsDeclared; 7011 7012 if (Scope *S = getScopeForContext(ClassDecl)) 7013 PushOnScopeChains(DefaultCon, S, false); 7014 ClassDecl->addDecl(DefaultCon); 7015 7016 if (ShouldDeleteSpecialMember(DefaultCon, CXXDefaultConstructor)) 7017 DefaultCon->setDeletedAsWritten(); 7018 7019 return DefaultCon; 7020} 7021 7022void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, 7023 CXXConstructorDecl *Constructor) { 7024 assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() && 7025 !Constructor->doesThisDeclarationHaveABody() && 7026 !Constructor->isDeleted()) && 7027 "DefineImplicitDefaultConstructor - call it for implicit default ctor"); 7028 7029 CXXRecordDecl *ClassDecl = Constructor->getParent(); 7030 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor"); 7031 7032 SynthesizedFunctionScope Scope(*this, Constructor); 7033 DiagnosticErrorTrap Trap(Diags); 7034 if (SetCtorInitializers(Constructor, 0, 0, /*AnyErrors=*/false) || 7035 Trap.hasErrorOccurred()) { 7036 Diag(CurrentLocation, diag::note_member_synthesized_at) 7037 << CXXDefaultConstructor << Context.getTagDeclType(ClassDecl); 7038 Constructor->setInvalidDecl(); 7039 return; 7040 } 7041 7042 SourceLocation Loc = Constructor->getLocation(); 7043 Constructor->setBody(new (Context) CompoundStmt(Loc)); 7044 7045 Constructor->setUsed(); 7046 MarkVTableUsed(CurrentLocation, ClassDecl); 7047 7048 if (ASTMutationListener *L = getASTMutationListener()) { 7049 L->CompletedImplicitDefinition(Constructor); 7050 } 7051} 7052 7053void Sema::ActOnFinishDelayedMemberInitializers(Decl *D) { 7054 if (!D) return; 7055 AdjustDeclIfTemplate(D); 7056 7057 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(D); 7058 7059 if (!ClassDecl->isDependentType()) 7060 CheckExplicitlyDefaultedMethods(ClassDecl); 7061} 7062 7063void Sema::DeclareInheritedConstructors(CXXRecordDecl *ClassDecl) { 7064 // We start with an initial pass over the base classes to collect those that 7065 // inherit constructors from. If there are none, we can forgo all further 7066 // processing. 7067 typedef SmallVector<const RecordType *, 4> BasesVector; 7068 BasesVector BasesToInheritFrom; 7069 for (CXXRecordDecl::base_class_iterator BaseIt = ClassDecl->bases_begin(), 7070 BaseE = ClassDecl->bases_end(); 7071 BaseIt != BaseE; ++BaseIt) { 7072 if (BaseIt->getInheritConstructors()) { 7073 QualType Base = BaseIt->getType(); 7074 if (Base->isDependentType()) { 7075 // If we inherit constructors from anything that is dependent, just 7076 // abort processing altogether. We'll get another chance for the 7077 // instantiations. 7078 return; 7079 } 7080 BasesToInheritFrom.push_back(Base->castAs<RecordType>()); 7081 } 7082 } 7083 if (BasesToInheritFrom.empty()) 7084 return; 7085 7086 // Now collect the constructors that we already have in the current class. 7087 // Those take precedence over inherited constructors. 7088 // C++0x [class.inhctor]p3: [...] a constructor is implicitly declared [...] 7089 // unless there is a user-declared constructor with the same signature in 7090 // the class where the using-declaration appears. 7091 llvm::SmallSet<const Type *, 8> ExistingConstructors; 7092 for (CXXRecordDecl::ctor_iterator CtorIt = ClassDecl->ctor_begin(), 7093 CtorE = ClassDecl->ctor_end(); 7094 CtorIt != CtorE; ++CtorIt) { 7095 ExistingConstructors.insert( 7096 Context.getCanonicalType(CtorIt->getType()).getTypePtr()); 7097 } 7098 7099 DeclarationName CreatedCtorName = 7100 Context.DeclarationNames.getCXXConstructorName( 7101 ClassDecl->getTypeForDecl()->getCanonicalTypeUnqualified()); 7102 7103 // Now comes the true work. 7104 // First, we keep a map from constructor types to the base that introduced 7105 // them. Needed for finding conflicting constructors. We also keep the 7106 // actually inserted declarations in there, for pretty diagnostics. 7107 typedef std::pair<CanQualType, CXXConstructorDecl *> ConstructorInfo; 7108 typedef llvm::DenseMap<const Type *, ConstructorInfo> ConstructorToSourceMap; 7109 ConstructorToSourceMap InheritedConstructors; 7110 for (BasesVector::iterator BaseIt = BasesToInheritFrom.begin(), 7111 BaseE = BasesToInheritFrom.end(); 7112 BaseIt != BaseE; ++BaseIt) { 7113 const RecordType *Base = *BaseIt; 7114 CanQualType CanonicalBase = Base->getCanonicalTypeUnqualified(); 7115 CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(Base->getDecl()); 7116 for (CXXRecordDecl::ctor_iterator CtorIt = BaseDecl->ctor_begin(), 7117 CtorE = BaseDecl->ctor_end(); 7118 CtorIt != CtorE; ++CtorIt) { 7119 // Find the using declaration for inheriting this base's constructors. 7120 // FIXME: Don't perform name lookup just to obtain a source location! 7121 DeclarationName Name = 7122 Context.DeclarationNames.getCXXConstructorName(CanonicalBase); 7123 LookupResult Result(*this, Name, SourceLocation(), LookupUsingDeclName); 7124 LookupQualifiedName(Result, CurContext); 7125 UsingDecl *UD = Result.getAsSingle<UsingDecl>(); 7126 SourceLocation UsingLoc = UD ? UD->getLocation() : 7127 ClassDecl->getLocation(); 7128 7129 // C++0x [class.inhctor]p1: The candidate set of inherited constructors 7130 // from the class X named in the using-declaration consists of actual 7131 // constructors and notional constructors that result from the 7132 // transformation of defaulted parameters as follows: 7133 // - all non-template default constructors of X, and 7134 // - for each non-template constructor of X that has at least one 7135 // parameter with a default argument, the set of constructors that 7136 // results from omitting any ellipsis parameter specification and 7137 // successively omitting parameters with a default argument from the 7138 // end of the parameter-type-list. 7139 CXXConstructorDecl *BaseCtor = *CtorIt; 7140 bool CanBeCopyOrMove = BaseCtor->isCopyOrMoveConstructor(); 7141 const FunctionProtoType *BaseCtorType = 7142 BaseCtor->getType()->getAs<FunctionProtoType>(); 7143 7144 for (unsigned params = BaseCtor->getMinRequiredArguments(), 7145 maxParams = BaseCtor->getNumParams(); 7146 params <= maxParams; ++params) { 7147 // Skip default constructors. They're never inherited. 7148 if (params == 0) 7149 continue; 7150 // Skip copy and move constructors for the same reason. 7151 if (CanBeCopyOrMove && params == 1) 7152 continue; 7153 7154 // Build up a function type for this particular constructor. 7155 // FIXME: The working paper does not consider that the exception spec 7156 // for the inheriting constructor might be larger than that of the 7157 // source. This code doesn't yet, either. When it does, this code will 7158 // need to be delayed until after exception specifications and in-class 7159 // member initializers are attached. 7160 const Type *NewCtorType; 7161 if (params == maxParams) 7162 NewCtorType = BaseCtorType; 7163 else { 7164 SmallVector<QualType, 16> Args; 7165 for (unsigned i = 0; i < params; ++i) { 7166 Args.push_back(BaseCtorType->getArgType(i)); 7167 } 7168 FunctionProtoType::ExtProtoInfo ExtInfo = 7169 BaseCtorType->getExtProtoInfo(); 7170 ExtInfo.Variadic = false; 7171 NewCtorType = Context.getFunctionType(BaseCtorType->getResultType(), 7172 Args.data(), params, ExtInfo) 7173 .getTypePtr(); 7174 } 7175 const Type *CanonicalNewCtorType = 7176 Context.getCanonicalType(NewCtorType); 7177 7178 // Now that we have the type, first check if the class already has a 7179 // constructor with this signature. 7180 if (ExistingConstructors.count(CanonicalNewCtorType)) 7181 continue; 7182 7183 // Then we check if we have already declared an inherited constructor 7184 // with this signature. 7185 std::pair<ConstructorToSourceMap::iterator, bool> result = 7186 InheritedConstructors.insert(std::make_pair( 7187 CanonicalNewCtorType, 7188 std::make_pair(CanonicalBase, (CXXConstructorDecl*)0))); 7189 if (!result.second) { 7190 // Already in the map. If it came from a different class, that's an 7191 // error. Not if it's from the same. 7192 CanQualType PreviousBase = result.first->second.first; 7193 if (CanonicalBase != PreviousBase) { 7194 const CXXConstructorDecl *PrevCtor = result.first->second.second; 7195 const CXXConstructorDecl *PrevBaseCtor = 7196 PrevCtor->getInheritedConstructor(); 7197 assert(PrevBaseCtor && "Conflicting constructor was not inherited"); 7198 7199 Diag(UsingLoc, diag::err_using_decl_constructor_conflict); 7200 Diag(BaseCtor->getLocation(), 7201 diag::note_using_decl_constructor_conflict_current_ctor); 7202 Diag(PrevBaseCtor->getLocation(), 7203 diag::note_using_decl_constructor_conflict_previous_ctor); 7204 Diag(PrevCtor->getLocation(), 7205 diag::note_using_decl_constructor_conflict_previous_using); 7206 } 7207 continue; 7208 } 7209 7210 // OK, we're there, now add the constructor. 7211 // C++0x [class.inhctor]p8: [...] that would be performed by a 7212 // user-written inline constructor [...] 7213 DeclarationNameInfo DNI(CreatedCtorName, UsingLoc); 7214 CXXConstructorDecl *NewCtor = CXXConstructorDecl::Create( 7215 Context, ClassDecl, UsingLoc, DNI, QualType(NewCtorType, 0), 7216 /*TInfo=*/0, BaseCtor->isExplicit(), /*Inline=*/true, 7217 /*ImplicitlyDeclared=*/true, 7218 // FIXME: Due to a defect in the standard, we treat inherited 7219 // constructors as constexpr even if that makes them ill-formed. 7220 /*Constexpr=*/BaseCtor->isConstexpr()); 7221 NewCtor->setAccess(BaseCtor->getAccess()); 7222 7223 // Build up the parameter decls and add them. 7224 SmallVector<ParmVarDecl *, 16> ParamDecls; 7225 for (unsigned i = 0; i < params; ++i) { 7226 ParamDecls.push_back(ParmVarDecl::Create(Context, NewCtor, 7227 UsingLoc, UsingLoc, 7228 /*IdentifierInfo=*/0, 7229 BaseCtorType->getArgType(i), 7230 /*TInfo=*/0, SC_None, 7231 SC_None, /*DefaultArg=*/0)); 7232 } 7233 NewCtor->setParams(ParamDecls); 7234 NewCtor->setInheritedConstructor(BaseCtor); 7235 7236 ClassDecl->addDecl(NewCtor); 7237 result.first->second.second = NewCtor; 7238 } 7239 } 7240 } 7241} 7242 7243Sema::ImplicitExceptionSpecification 7244Sema::ComputeDefaultedDtorExceptionSpec(CXXMethodDecl *MD) { 7245 CXXRecordDecl *ClassDecl = MD->getParent(); 7246 7247 // C++ [except.spec]p14: 7248 // An implicitly declared special member function (Clause 12) shall have 7249 // an exception-specification. 7250 ImplicitExceptionSpecification ExceptSpec(*this); 7251 if (ClassDecl->isInvalidDecl()) 7252 return ExceptSpec; 7253 7254 // Direct base-class destructors. 7255 for (CXXRecordDecl::base_class_iterator B = ClassDecl->bases_begin(), 7256 BEnd = ClassDecl->bases_end(); 7257 B != BEnd; ++B) { 7258 if (B->isVirtual()) // Handled below. 7259 continue; 7260 7261 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) 7262 ExceptSpec.CalledDecl(B->getLocStart(), 7263 LookupDestructor(cast<CXXRecordDecl>(BaseType->getDecl()))); 7264 } 7265 7266 // Virtual base-class destructors. 7267 for (CXXRecordDecl::base_class_iterator B = ClassDecl->vbases_begin(), 7268 BEnd = ClassDecl->vbases_end(); 7269 B != BEnd; ++B) { 7270 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) 7271 ExceptSpec.CalledDecl(B->getLocStart(), 7272 LookupDestructor(cast<CXXRecordDecl>(BaseType->getDecl()))); 7273 } 7274 7275 // Field destructors. 7276 for (RecordDecl::field_iterator F = ClassDecl->field_begin(), 7277 FEnd = ClassDecl->field_end(); 7278 F != FEnd; ++F) { 7279 if (const RecordType *RecordTy 7280 = Context.getBaseElementType(F->getType())->getAs<RecordType>()) 7281 ExceptSpec.CalledDecl(F->getLocation(), 7282 LookupDestructor(cast<CXXRecordDecl>(RecordTy->getDecl()))); 7283 } 7284 7285 return ExceptSpec; 7286} 7287 7288CXXDestructorDecl *Sema::DeclareImplicitDestructor(CXXRecordDecl *ClassDecl) { 7289 // C++ [class.dtor]p2: 7290 // If a class has no user-declared destructor, a destructor is 7291 // declared implicitly. An implicitly-declared destructor is an 7292 // inline public member of its class. 7293 7294 // Create the actual destructor declaration. 7295 CanQualType ClassType 7296 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl)); 7297 SourceLocation ClassLoc = ClassDecl->getLocation(); 7298 DeclarationName Name 7299 = Context.DeclarationNames.getCXXDestructorName(ClassType); 7300 DeclarationNameInfo NameInfo(Name, ClassLoc); 7301 CXXDestructorDecl *Destructor 7302 = CXXDestructorDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, 7303 QualType(), 0, /*isInline=*/true, 7304 /*isImplicitlyDeclared=*/true); 7305 Destructor->setAccess(AS_public); 7306 Destructor->setDefaulted(); 7307 Destructor->setImplicit(); 7308 Destructor->setTrivial(ClassDecl->hasTrivialDestructor()); 7309 7310 // Build an exception specification pointing back at this destructor. 7311 FunctionProtoType::ExtProtoInfo EPI; 7312 EPI.ExceptionSpecType = EST_Unevaluated; 7313 EPI.ExceptionSpecDecl = Destructor; 7314 Destructor->setType(Context.getFunctionType(Context.VoidTy, 0, 0, EPI)); 7315 7316 // Note that we have declared this destructor. 7317 ++ASTContext::NumImplicitDestructorsDeclared; 7318 7319 // Introduce this destructor into its scope. 7320 if (Scope *S = getScopeForContext(ClassDecl)) 7321 PushOnScopeChains(Destructor, S, false); 7322 ClassDecl->addDecl(Destructor); 7323 7324 AddOverriddenMethods(ClassDecl, Destructor); 7325 7326 if (ShouldDeleteSpecialMember(Destructor, CXXDestructor)) 7327 Destructor->setDeletedAsWritten(); 7328 7329 return Destructor; 7330} 7331 7332void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation, 7333 CXXDestructorDecl *Destructor) { 7334 assert((Destructor->isDefaulted() && 7335 !Destructor->doesThisDeclarationHaveABody() && 7336 !Destructor->isDeleted()) && 7337 "DefineImplicitDestructor - call it for implicit default dtor"); 7338 CXXRecordDecl *ClassDecl = Destructor->getParent(); 7339 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor"); 7340 7341 if (Destructor->isInvalidDecl()) 7342 return; 7343 7344 SynthesizedFunctionScope Scope(*this, Destructor); 7345 7346 DiagnosticErrorTrap Trap(Diags); 7347 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(), 7348 Destructor->getParent()); 7349 7350 if (CheckDestructor(Destructor) || Trap.hasErrorOccurred()) { 7351 Diag(CurrentLocation, diag::note_member_synthesized_at) 7352 << CXXDestructor << Context.getTagDeclType(ClassDecl); 7353 7354 Destructor->setInvalidDecl(); 7355 return; 7356 } 7357 7358 SourceLocation Loc = Destructor->getLocation(); 7359 Destructor->setBody(new (Context) CompoundStmt(Loc)); 7360 Destructor->setImplicitlyDefined(true); 7361 Destructor->setUsed(); 7362 MarkVTableUsed(CurrentLocation, ClassDecl); 7363 7364 if (ASTMutationListener *L = getASTMutationListener()) { 7365 L->CompletedImplicitDefinition(Destructor); 7366 } 7367} 7368 7369/// \brief Perform any semantic analysis which needs to be delayed until all 7370/// pending class member declarations have been parsed. 7371void Sema::ActOnFinishCXXMemberDecls() { 7372 // Perform any deferred checking of exception specifications for virtual 7373 // destructors. 7374 for (unsigned i = 0, e = DelayedDestructorExceptionSpecChecks.size(); 7375 i != e; ++i) { 7376 const CXXDestructorDecl *Dtor = 7377 DelayedDestructorExceptionSpecChecks[i].first; 7378 assert(!Dtor->getParent()->isDependentType() && 7379 "Should not ever add destructors of templates into the list."); 7380 CheckOverridingFunctionExceptionSpec(Dtor, 7381 DelayedDestructorExceptionSpecChecks[i].second); 7382 } 7383 DelayedDestructorExceptionSpecChecks.clear(); 7384} 7385 7386void Sema::AdjustDestructorExceptionSpec(CXXRecordDecl *ClassDecl, 7387 CXXDestructorDecl *Destructor) { 7388 assert(getLangOpts().CPlusPlus0x && 7389 "adjusting dtor exception specs was introduced in c++11"); 7390 7391 // C++11 [class.dtor]p3: 7392 // A declaration of a destructor that does not have an exception- 7393 // specification is implicitly considered to have the same exception- 7394 // specification as an implicit declaration. 7395 const FunctionProtoType *DtorType = Destructor->getType()-> 7396 getAs<FunctionProtoType>(); 7397 if (DtorType->hasExceptionSpec()) 7398 return; 7399 7400 // Replace the destructor's type, building off the existing one. Fortunately, 7401 // the only thing of interest in the destructor type is its extended info. 7402 // The return and arguments are fixed. 7403 FunctionProtoType::ExtProtoInfo EPI = DtorType->getExtProtoInfo(); 7404 EPI.ExceptionSpecType = EST_Unevaluated; 7405 EPI.ExceptionSpecDecl = Destructor; 7406 Destructor->setType(Context.getFunctionType(Context.VoidTy, 0, 0, EPI)); 7407 7408 // FIXME: If the destructor has a body that could throw, and the newly created 7409 // spec doesn't allow exceptions, we should emit a warning, because this 7410 // change in behavior can break conforming C++03 programs at runtime. 7411 // However, we don't have a body or an exception specification yet, so it 7412 // needs to be done somewhere else. 7413} 7414 7415/// \brief Builds a statement that copies/moves the given entity from \p From to 7416/// \c To. 7417/// 7418/// This routine is used to copy/move the members of a class with an 7419/// implicitly-declared copy/move assignment operator. When the entities being 7420/// copied are arrays, this routine builds for loops to copy them. 7421/// 7422/// \param S The Sema object used for type-checking. 7423/// 7424/// \param Loc The location where the implicit copy/move is being generated. 7425/// 7426/// \param T The type of the expressions being copied/moved. Both expressions 7427/// must have this type. 7428/// 7429/// \param To The expression we are copying/moving to. 7430/// 7431/// \param From The expression we are copying/moving from. 7432/// 7433/// \param CopyingBaseSubobject Whether we're copying/moving a base subobject. 7434/// Otherwise, it's a non-static member subobject. 7435/// 7436/// \param Copying Whether we're copying or moving. 7437/// 7438/// \param Depth Internal parameter recording the depth of the recursion. 7439/// 7440/// \returns A statement or a loop that copies the expressions. 7441static StmtResult 7442BuildSingleCopyAssign(Sema &S, SourceLocation Loc, QualType T, 7443 Expr *To, Expr *From, 7444 bool CopyingBaseSubobject, bool Copying, 7445 unsigned Depth = 0) { 7446 // C++0x [class.copy]p28: 7447 // Each subobject is assigned in the manner appropriate to its type: 7448 // 7449 // - if the subobject is of class type, as if by a call to operator= with 7450 // the subobject as the object expression and the corresponding 7451 // subobject of x as a single function argument (as if by explicit 7452 // qualification; that is, ignoring any possible virtual overriding 7453 // functions in more derived classes); 7454 if (const RecordType *RecordTy = T->getAs<RecordType>()) { 7455 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl()); 7456 7457 // Look for operator=. 7458 DeclarationName Name 7459 = S.Context.DeclarationNames.getCXXOperatorName(OO_Equal); 7460 LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName); 7461 S.LookupQualifiedName(OpLookup, ClassDecl, false); 7462 7463 // Filter out any result that isn't a copy/move-assignment operator. 7464 LookupResult::Filter F = OpLookup.makeFilter(); 7465 while (F.hasNext()) { 7466 NamedDecl *D = F.next(); 7467 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) 7468 if (Method->isCopyAssignmentOperator() || 7469 (!Copying && Method->isMoveAssignmentOperator())) 7470 continue; 7471 7472 F.erase(); 7473 } 7474 F.done(); 7475 7476 // Suppress the protected check (C++ [class.protected]) for each of the 7477 // assignment operators we found. This strange dance is required when 7478 // we're assigning via a base classes's copy-assignment operator. To 7479 // ensure that we're getting the right base class subobject (without 7480 // ambiguities), we need to cast "this" to that subobject type; to 7481 // ensure that we don't go through the virtual call mechanism, we need 7482 // to qualify the operator= name with the base class (see below). However, 7483 // this means that if the base class has a protected copy assignment 7484 // operator, the protected member access check will fail. So, we 7485 // rewrite "protected" access to "public" access in this case, since we 7486 // know by construction that we're calling from a derived class. 7487 if (CopyingBaseSubobject) { 7488 for (LookupResult::iterator L = OpLookup.begin(), LEnd = OpLookup.end(); 7489 L != LEnd; ++L) { 7490 if (L.getAccess() == AS_protected) 7491 L.setAccess(AS_public); 7492 } 7493 } 7494 7495 // Create the nested-name-specifier that will be used to qualify the 7496 // reference to operator=; this is required to suppress the virtual 7497 // call mechanism. 7498 CXXScopeSpec SS; 7499 const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr()); 7500 SS.MakeTrivial(S.Context, 7501 NestedNameSpecifier::Create(S.Context, 0, false, 7502 CanonicalT), 7503 Loc); 7504 7505 // Create the reference to operator=. 7506 ExprResult OpEqualRef 7507 = S.BuildMemberReferenceExpr(To, T, Loc, /*isArrow=*/false, SS, 7508 /*TemplateKWLoc=*/SourceLocation(), 7509 /*FirstQualifierInScope=*/0, 7510 OpLookup, 7511 /*TemplateArgs=*/0, 7512 /*SuppressQualifierCheck=*/true); 7513 if (OpEqualRef.isInvalid()) 7514 return StmtError(); 7515 7516 // Build the call to the assignment operator. 7517 7518 ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/0, 7519 OpEqualRef.takeAs<Expr>(), 7520 Loc, &From, 1, Loc); 7521 if (Call.isInvalid()) 7522 return StmtError(); 7523 7524 return S.Owned(Call.takeAs<Stmt>()); 7525 } 7526 7527 // - if the subobject is of scalar type, the built-in assignment 7528 // operator is used. 7529 const ConstantArrayType *ArrayTy = S.Context.getAsConstantArrayType(T); 7530 if (!ArrayTy) { 7531 ExprResult Assignment = S.CreateBuiltinBinOp(Loc, BO_Assign, To, From); 7532 if (Assignment.isInvalid()) 7533 return StmtError(); 7534 7535 return S.Owned(Assignment.takeAs<Stmt>()); 7536 } 7537 7538 // - if the subobject is an array, each element is assigned, in the 7539 // manner appropriate to the element type; 7540 7541 // Construct a loop over the array bounds, e.g., 7542 // 7543 // for (__SIZE_TYPE__ i0 = 0; i0 != array-size; ++i0) 7544 // 7545 // that will copy each of the array elements. 7546 QualType SizeType = S.Context.getSizeType(); 7547 7548 // Create the iteration variable. 7549 IdentifierInfo *IterationVarName = 0; 7550 { 7551 SmallString<8> Str; 7552 llvm::raw_svector_ostream OS(Str); 7553 OS << "__i" << Depth; 7554 IterationVarName = &S.Context.Idents.get(OS.str()); 7555 } 7556 VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc, 7557 IterationVarName, SizeType, 7558 S.Context.getTrivialTypeSourceInfo(SizeType, Loc), 7559 SC_None, SC_None); 7560 7561 // Initialize the iteration variable to zero. 7562 llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0); 7563 IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc)); 7564 7565 // Create a reference to the iteration variable; we'll use this several 7566 // times throughout. 7567 Expr *IterationVarRef 7568 = S.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc).take(); 7569 assert(IterationVarRef && "Reference to invented variable cannot fail!"); 7570 Expr *IterationVarRefRVal = S.DefaultLvalueConversion(IterationVarRef).take(); 7571 assert(IterationVarRefRVal && "Conversion of invented variable cannot fail!"); 7572 7573 // Create the DeclStmt that holds the iteration variable. 7574 Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc); 7575 7576 // Create the comparison against the array bound. 7577 llvm::APInt Upper 7578 = ArrayTy->getSize().zextOrTrunc(S.Context.getTypeSize(SizeType)); 7579 Expr *Comparison 7580 = new (S.Context) BinaryOperator(IterationVarRefRVal, 7581 IntegerLiteral::Create(S.Context, Upper, SizeType, Loc), 7582 BO_NE, S.Context.BoolTy, 7583 VK_RValue, OK_Ordinary, Loc, false); 7584 7585 // Create the pre-increment of the iteration variable. 7586 Expr *Increment 7587 = new (S.Context) UnaryOperator(IterationVarRef, UO_PreInc, SizeType, 7588 VK_LValue, OK_Ordinary, Loc); 7589 7590 // Subscript the "from" and "to" expressions with the iteration variable. 7591 From = AssertSuccess(S.CreateBuiltinArraySubscriptExpr(From, Loc, 7592 IterationVarRefRVal, 7593 Loc)); 7594 To = AssertSuccess(S.CreateBuiltinArraySubscriptExpr(To, Loc, 7595 IterationVarRefRVal, 7596 Loc)); 7597 if (!Copying) // Cast to rvalue 7598 From = CastForMoving(S, From); 7599 7600 // Build the copy/move for an individual element of the array. 7601 StmtResult Copy = BuildSingleCopyAssign(S, Loc, ArrayTy->getElementType(), 7602 To, From, CopyingBaseSubobject, 7603 Copying, Depth + 1); 7604 if (Copy.isInvalid()) 7605 return StmtError(); 7606 7607 // Construct the loop that copies all elements of this array. 7608 return S.ActOnForStmt(Loc, Loc, InitStmt, 7609 S.MakeFullExpr(Comparison), 7610 0, S.MakeFullExpr(Increment), 7611 Loc, Copy.take()); 7612} 7613 7614/// Determine whether an implicit copy assignment operator for ClassDecl has a 7615/// const argument. 7616/// FIXME: It ought to be possible to store this on the record. 7617static bool isImplicitCopyAssignmentArgConst(Sema &S, 7618 CXXRecordDecl *ClassDecl) { 7619 if (ClassDecl->isInvalidDecl()) 7620 return true; 7621 7622 // C++ [class.copy]p10: 7623 // If the class definition does not explicitly declare a copy 7624 // assignment operator, one is declared implicitly. 7625 // The implicitly-defined copy assignment operator for a class X 7626 // will have the form 7627 // 7628 // X& X::operator=(const X&) 7629 // 7630 // if 7631 // -- each direct base class B of X has a copy assignment operator 7632 // whose parameter is of type const B&, const volatile B& or B, 7633 // and 7634 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), 7635 BaseEnd = ClassDecl->bases_end(); 7636 Base != BaseEnd; ++Base) { 7637 // We'll handle this below 7638 if (S.getLangOpts().CPlusPlus0x && Base->isVirtual()) 7639 continue; 7640 7641 assert(!Base->getType()->isDependentType() && 7642 "Cannot generate implicit members for class with dependent bases."); 7643 CXXRecordDecl *BaseClassDecl = Base->getType()->getAsCXXRecordDecl(); 7644 if (!S.LookupCopyingAssignment(BaseClassDecl, Qualifiers::Const, false, 0)) 7645 return false; 7646 } 7647 7648 // In C++11, the above citation has "or virtual" added 7649 if (S.getLangOpts().CPlusPlus0x) { 7650 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(), 7651 BaseEnd = ClassDecl->vbases_end(); 7652 Base != BaseEnd; ++Base) { 7653 assert(!Base->getType()->isDependentType() && 7654 "Cannot generate implicit members for class with dependent bases."); 7655 CXXRecordDecl *BaseClassDecl = Base->getType()->getAsCXXRecordDecl(); 7656 if (!S.LookupCopyingAssignment(BaseClassDecl, Qualifiers::Const, 7657 false, 0)) 7658 return false; 7659 } 7660 } 7661 7662 // -- for all the nonstatic data members of X that are of a class 7663 // type M (or array thereof), each such class type has a copy 7664 // assignment operator whose parameter is of type const M&, 7665 // const volatile M& or M. 7666 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 7667 FieldEnd = ClassDecl->field_end(); 7668 Field != FieldEnd; ++Field) { 7669 QualType FieldType = S.Context.getBaseElementType(Field->getType()); 7670 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) 7671 if (!S.LookupCopyingAssignment(FieldClassDecl, Qualifiers::Const, 7672 false, 0)) 7673 return false; 7674 } 7675 7676 // Otherwise, the implicitly declared copy assignment operator will 7677 // have the form 7678 // 7679 // X& X::operator=(X&) 7680 7681 return true; 7682} 7683 7684Sema::ImplicitExceptionSpecification 7685Sema::ComputeDefaultedCopyAssignmentExceptionSpec(CXXMethodDecl *MD) { 7686 CXXRecordDecl *ClassDecl = MD->getParent(); 7687 7688 ImplicitExceptionSpecification ExceptSpec(*this); 7689 if (ClassDecl->isInvalidDecl()) 7690 return ExceptSpec; 7691 7692 const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>(); 7693 assert(T->getNumArgs() == 1 && "not a copy assignment op"); 7694 unsigned ArgQuals = T->getArgType(0).getNonReferenceType().getCVRQualifiers(); 7695 7696 // C++ [except.spec]p14: 7697 // An implicitly declared special member function (Clause 12) shall have an 7698 // exception-specification. [...] 7699 7700 // It is unspecified whether or not an implicit copy assignment operator 7701 // attempts to deduplicate calls to assignment operators of virtual bases are 7702 // made. As such, this exception specification is effectively unspecified. 7703 // Based on a similar decision made for constness in C++0x, we're erring on 7704 // the side of assuming such calls to be made regardless of whether they 7705 // actually happen. 7706 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), 7707 BaseEnd = ClassDecl->bases_end(); 7708 Base != BaseEnd; ++Base) { 7709 if (Base->isVirtual()) 7710 continue; 7711 7712 CXXRecordDecl *BaseClassDecl 7713 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 7714 if (CXXMethodDecl *CopyAssign = LookupCopyingAssignment(BaseClassDecl, 7715 ArgQuals, false, 0)) 7716 ExceptSpec.CalledDecl(Base->getLocStart(), CopyAssign); 7717 } 7718 7719 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(), 7720 BaseEnd = ClassDecl->vbases_end(); 7721 Base != BaseEnd; ++Base) { 7722 CXXRecordDecl *BaseClassDecl 7723 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 7724 if (CXXMethodDecl *CopyAssign = LookupCopyingAssignment(BaseClassDecl, 7725 ArgQuals, false, 0)) 7726 ExceptSpec.CalledDecl(Base->getLocStart(), CopyAssign); 7727 } 7728 7729 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 7730 FieldEnd = ClassDecl->field_end(); 7731 Field != FieldEnd; 7732 ++Field) { 7733 QualType FieldType = Context.getBaseElementType(Field->getType()); 7734 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) { 7735 if (CXXMethodDecl *CopyAssign = 7736 LookupCopyingAssignment(FieldClassDecl, 7737 ArgQuals | FieldType.getCVRQualifiers(), 7738 false, 0)) 7739 ExceptSpec.CalledDecl(Field->getLocation(), CopyAssign); 7740 } 7741 } 7742 7743 return ExceptSpec; 7744} 7745 7746CXXMethodDecl *Sema::DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl) { 7747 // Note: The following rules are largely analoguous to the copy 7748 // constructor rules. Note that virtual bases are not taken into account 7749 // for determining the argument type of the operator. Note also that 7750 // operators taking an object instead of a reference are allowed. 7751 7752 QualType ArgType = Context.getTypeDeclType(ClassDecl); 7753 QualType RetType = Context.getLValueReferenceType(ArgType); 7754 if (isImplicitCopyAssignmentArgConst(*this, ClassDecl)) 7755 ArgType = ArgType.withConst(); 7756 ArgType = Context.getLValueReferenceType(ArgType); 7757 7758 // An implicitly-declared copy assignment operator is an inline public 7759 // member of its class. 7760 DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal); 7761 SourceLocation ClassLoc = ClassDecl->getLocation(); 7762 DeclarationNameInfo NameInfo(Name, ClassLoc); 7763 CXXMethodDecl *CopyAssignment 7764 = CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(), 7765 /*TInfo=*/0, /*isStatic=*/false, 7766 /*StorageClassAsWritten=*/SC_None, 7767 /*isInline=*/true, /*isConstexpr=*/false, 7768 SourceLocation()); 7769 CopyAssignment->setAccess(AS_public); 7770 CopyAssignment->setDefaulted(); 7771 CopyAssignment->setImplicit(); 7772 CopyAssignment->setTrivial(ClassDecl->hasTrivialCopyAssignment()); 7773 7774 // Build an exception specification pointing back at this member. 7775 FunctionProtoType::ExtProtoInfo EPI; 7776 EPI.ExceptionSpecType = EST_Unevaluated; 7777 EPI.ExceptionSpecDecl = CopyAssignment; 7778 CopyAssignment->setType(Context.getFunctionType(RetType, &ArgType, 1, EPI)); 7779 7780 // Add the parameter to the operator. 7781 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment, 7782 ClassLoc, ClassLoc, /*Id=*/0, 7783 ArgType, /*TInfo=*/0, 7784 SC_None, 7785 SC_None, 0); 7786 CopyAssignment->setParams(FromParam); 7787 7788 // Note that we have added this copy-assignment operator. 7789 ++ASTContext::NumImplicitCopyAssignmentOperatorsDeclared; 7790 7791 if (Scope *S = getScopeForContext(ClassDecl)) 7792 PushOnScopeChains(CopyAssignment, S, false); 7793 ClassDecl->addDecl(CopyAssignment); 7794 7795 // C++0x [class.copy]p19: 7796 // .... If the class definition does not explicitly declare a copy 7797 // assignment operator, there is no user-declared move constructor, and 7798 // there is no user-declared move assignment operator, a copy assignment 7799 // operator is implicitly declared as defaulted. 7800 if (ShouldDeleteSpecialMember(CopyAssignment, CXXCopyAssignment)) 7801 CopyAssignment->setDeletedAsWritten(); 7802 7803 AddOverriddenMethods(ClassDecl, CopyAssignment); 7804 return CopyAssignment; 7805} 7806 7807void Sema::DefineImplicitCopyAssignment(SourceLocation CurrentLocation, 7808 CXXMethodDecl *CopyAssignOperator) { 7809 assert((CopyAssignOperator->isDefaulted() && 7810 CopyAssignOperator->isOverloadedOperator() && 7811 CopyAssignOperator->getOverloadedOperator() == OO_Equal && 7812 !CopyAssignOperator->doesThisDeclarationHaveABody() && 7813 !CopyAssignOperator->isDeleted()) && 7814 "DefineImplicitCopyAssignment called for wrong function"); 7815 7816 CXXRecordDecl *ClassDecl = CopyAssignOperator->getParent(); 7817 7818 if (ClassDecl->isInvalidDecl() || CopyAssignOperator->isInvalidDecl()) { 7819 CopyAssignOperator->setInvalidDecl(); 7820 return; 7821 } 7822 7823 CopyAssignOperator->setUsed(); 7824 7825 SynthesizedFunctionScope Scope(*this, CopyAssignOperator); 7826 DiagnosticErrorTrap Trap(Diags); 7827 7828 // C++0x [class.copy]p30: 7829 // The implicitly-defined or explicitly-defaulted copy assignment operator 7830 // for a non-union class X performs memberwise copy assignment of its 7831 // subobjects. The direct base classes of X are assigned first, in the 7832 // order of their declaration in the base-specifier-list, and then the 7833 // immediate non-static data members of X are assigned, in the order in 7834 // which they were declared in the class definition. 7835 7836 // The statements that form the synthesized function body. 7837 SmallVector<Stmt*, 8> Statements; 7838 7839 // The parameter for the "other" object, which we are copying from. 7840 ParmVarDecl *Other = CopyAssignOperator->getParamDecl(0); 7841 Qualifiers OtherQuals = Other->getType().getQualifiers(); 7842 QualType OtherRefType = Other->getType(); 7843 if (const LValueReferenceType *OtherRef 7844 = OtherRefType->getAs<LValueReferenceType>()) { 7845 OtherRefType = OtherRef->getPointeeType(); 7846 OtherQuals = OtherRefType.getQualifiers(); 7847 } 7848 7849 // Our location for everything implicitly-generated. 7850 SourceLocation Loc = CopyAssignOperator->getLocation(); 7851 7852 // Construct a reference to the "other" object. We'll be using this 7853 // throughout the generated ASTs. 7854 Expr *OtherRef = BuildDeclRefExpr(Other, OtherRefType, VK_LValue, Loc).take(); 7855 assert(OtherRef && "Reference to parameter cannot fail!"); 7856 7857 // Construct the "this" pointer. We'll be using this throughout the generated 7858 // ASTs. 7859 Expr *This = ActOnCXXThis(Loc).takeAs<Expr>(); 7860 assert(This && "Reference to this cannot fail!"); 7861 7862 // Assign base classes. 7863 bool Invalid = false; 7864 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), 7865 E = ClassDecl->bases_end(); Base != E; ++Base) { 7866 // Form the assignment: 7867 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other)); 7868 QualType BaseType = Base->getType().getUnqualifiedType(); 7869 if (!BaseType->isRecordType()) { 7870 Invalid = true; 7871 continue; 7872 } 7873 7874 CXXCastPath BasePath; 7875 BasePath.push_back(Base); 7876 7877 // Construct the "from" expression, which is an implicit cast to the 7878 // appropriately-qualified base type. 7879 Expr *From = OtherRef; 7880 From = ImpCastExprToType(From, Context.getQualifiedType(BaseType, OtherQuals), 7881 CK_UncheckedDerivedToBase, 7882 VK_LValue, &BasePath).take(); 7883 7884 // Dereference "this". 7885 ExprResult To = CreateBuiltinUnaryOp(Loc, UO_Deref, This); 7886 7887 // Implicitly cast "this" to the appropriately-qualified base type. 7888 To = ImpCastExprToType(To.take(), 7889 Context.getCVRQualifiedType(BaseType, 7890 CopyAssignOperator->getTypeQualifiers()), 7891 CK_UncheckedDerivedToBase, 7892 VK_LValue, &BasePath); 7893 7894 // Build the copy. 7895 StmtResult Copy = BuildSingleCopyAssign(*this, Loc, BaseType, 7896 To.get(), From, 7897 /*CopyingBaseSubobject=*/true, 7898 /*Copying=*/true); 7899 if (Copy.isInvalid()) { 7900 Diag(CurrentLocation, diag::note_member_synthesized_at) 7901 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl); 7902 CopyAssignOperator->setInvalidDecl(); 7903 return; 7904 } 7905 7906 // Success! Record the copy. 7907 Statements.push_back(Copy.takeAs<Expr>()); 7908 } 7909 7910 // \brief Reference to the __builtin_memcpy function. 7911 Expr *BuiltinMemCpyRef = 0; 7912 // \brief Reference to the __builtin_objc_memmove_collectable function. 7913 Expr *CollectableMemCpyRef = 0; 7914 7915 // Assign non-static members. 7916 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 7917 FieldEnd = ClassDecl->field_end(); 7918 Field != FieldEnd; ++Field) { 7919 if (Field->isUnnamedBitfield()) 7920 continue; 7921 7922 // Check for members of reference type; we can't copy those. 7923 if (Field->getType()->isReferenceType()) { 7924 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign) 7925 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName(); 7926 Diag(Field->getLocation(), diag::note_declared_at); 7927 Diag(CurrentLocation, diag::note_member_synthesized_at) 7928 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl); 7929 Invalid = true; 7930 continue; 7931 } 7932 7933 // Check for members of const-qualified, non-class type. 7934 QualType BaseType = Context.getBaseElementType(Field->getType()); 7935 if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) { 7936 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign) 7937 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName(); 7938 Diag(Field->getLocation(), diag::note_declared_at); 7939 Diag(CurrentLocation, diag::note_member_synthesized_at) 7940 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl); 7941 Invalid = true; 7942 continue; 7943 } 7944 7945 // Suppress assigning zero-width bitfields. 7946 if (Field->isBitField() && Field->getBitWidthValue(Context) == 0) 7947 continue; 7948 7949 QualType FieldType = Field->getType().getNonReferenceType(); 7950 if (FieldType->isIncompleteArrayType()) { 7951 assert(ClassDecl->hasFlexibleArrayMember() && 7952 "Incomplete array type is not valid"); 7953 continue; 7954 } 7955 7956 // Build references to the field in the object we're copying from and to. 7957 CXXScopeSpec SS; // Intentionally empty 7958 LookupResult MemberLookup(*this, Field->getDeclName(), Loc, 7959 LookupMemberName); 7960 MemberLookup.addDecl(*Field); 7961 MemberLookup.resolveKind(); 7962 ExprResult From = BuildMemberReferenceExpr(OtherRef, OtherRefType, 7963 Loc, /*IsArrow=*/false, 7964 SS, SourceLocation(), 0, 7965 MemberLookup, 0); 7966 ExprResult To = BuildMemberReferenceExpr(This, This->getType(), 7967 Loc, /*IsArrow=*/true, 7968 SS, SourceLocation(), 0, 7969 MemberLookup, 0); 7970 assert(!From.isInvalid() && "Implicit field reference cannot fail"); 7971 assert(!To.isInvalid() && "Implicit field reference cannot fail"); 7972 7973 // If the field should be copied with __builtin_memcpy rather than via 7974 // explicit assignments, do so. This optimization only applies for arrays 7975 // of scalars and arrays of class type with trivial copy-assignment 7976 // operators. 7977 if (FieldType->isArrayType() && !FieldType.isVolatileQualified() 7978 && BaseType.hasTrivialAssignment(Context, /*Copying=*/true)) { 7979 // Compute the size of the memory buffer to be copied. 7980 QualType SizeType = Context.getSizeType(); 7981 llvm::APInt Size(Context.getTypeSize(SizeType), 7982 Context.getTypeSizeInChars(BaseType).getQuantity()); 7983 for (const ConstantArrayType *Array 7984 = Context.getAsConstantArrayType(FieldType); 7985 Array; 7986 Array = Context.getAsConstantArrayType(Array->getElementType())) { 7987 llvm::APInt ArraySize 7988 = Array->getSize().zextOrTrunc(Size.getBitWidth()); 7989 Size *= ArraySize; 7990 } 7991 7992 // Take the address of the field references for "from" and "to". 7993 From = CreateBuiltinUnaryOp(Loc, UO_AddrOf, From.get()); 7994 To = CreateBuiltinUnaryOp(Loc, UO_AddrOf, To.get()); 7995 7996 bool NeedsCollectableMemCpy = 7997 (BaseType->isRecordType() && 7998 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember()); 7999 8000 if (NeedsCollectableMemCpy) { 8001 if (!CollectableMemCpyRef) { 8002 // Create a reference to the __builtin_objc_memmove_collectable function. 8003 LookupResult R(*this, 8004 &Context.Idents.get("__builtin_objc_memmove_collectable"), 8005 Loc, LookupOrdinaryName); 8006 LookupName(R, TUScope, true); 8007 8008 FunctionDecl *CollectableMemCpy = R.getAsSingle<FunctionDecl>(); 8009 if (!CollectableMemCpy) { 8010 // Something went horribly wrong earlier, and we will have 8011 // complained about it. 8012 Invalid = true; 8013 continue; 8014 } 8015 8016 CollectableMemCpyRef = BuildDeclRefExpr(CollectableMemCpy, 8017 Context.BuiltinFnTy, 8018 VK_RValue, Loc, 0).take(); 8019 assert(CollectableMemCpyRef && "Builtin reference cannot fail"); 8020 } 8021 } 8022 // Create a reference to the __builtin_memcpy builtin function. 8023 else if (!BuiltinMemCpyRef) { 8024 LookupResult R(*this, &Context.Idents.get("__builtin_memcpy"), Loc, 8025 LookupOrdinaryName); 8026 LookupName(R, TUScope, true); 8027 8028 FunctionDecl *BuiltinMemCpy = R.getAsSingle<FunctionDecl>(); 8029 if (!BuiltinMemCpy) { 8030 // Something went horribly wrong earlier, and we will have complained 8031 // about it. 8032 Invalid = true; 8033 continue; 8034 } 8035 8036 BuiltinMemCpyRef = BuildDeclRefExpr(BuiltinMemCpy, 8037 Context.BuiltinFnTy, 8038 VK_RValue, Loc, 0).take(); 8039 assert(BuiltinMemCpyRef && "Builtin reference cannot fail"); 8040 } 8041 8042 SmallVector<Expr*, 8> CallArgs; 8043 CallArgs.push_back(To.takeAs<Expr>()); 8044 CallArgs.push_back(From.takeAs<Expr>()); 8045 CallArgs.push_back(IntegerLiteral::Create(Context, Size, SizeType, Loc)); 8046 ExprResult Call = ExprError(); 8047 if (NeedsCollectableMemCpy) 8048 Call = ActOnCallExpr(/*Scope=*/0, 8049 CollectableMemCpyRef, 8050 Loc, CallArgs, 8051 Loc); 8052 else 8053 Call = ActOnCallExpr(/*Scope=*/0, 8054 BuiltinMemCpyRef, 8055 Loc, CallArgs, 8056 Loc); 8057 8058 assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!"); 8059 Statements.push_back(Call.takeAs<Expr>()); 8060 continue; 8061 } 8062 8063 // Build the copy of this field. 8064 StmtResult Copy = BuildSingleCopyAssign(*this, Loc, FieldType, 8065 To.get(), From.get(), 8066 /*CopyingBaseSubobject=*/false, 8067 /*Copying=*/true); 8068 if (Copy.isInvalid()) { 8069 Diag(CurrentLocation, diag::note_member_synthesized_at) 8070 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl); 8071 CopyAssignOperator->setInvalidDecl(); 8072 return; 8073 } 8074 8075 // Success! Record the copy. 8076 Statements.push_back(Copy.takeAs<Stmt>()); 8077 } 8078 8079 if (!Invalid) { 8080 // Add a "return *this;" 8081 ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This); 8082 8083 StmtResult Return = ActOnReturnStmt(Loc, ThisObj.get()); 8084 if (Return.isInvalid()) 8085 Invalid = true; 8086 else { 8087 Statements.push_back(Return.takeAs<Stmt>()); 8088 8089 if (Trap.hasErrorOccurred()) { 8090 Diag(CurrentLocation, diag::note_member_synthesized_at) 8091 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl); 8092 Invalid = true; 8093 } 8094 } 8095 } 8096 8097 if (Invalid) { 8098 CopyAssignOperator->setInvalidDecl(); 8099 return; 8100 } 8101 8102 StmtResult Body; 8103 { 8104 CompoundScopeRAII CompoundScope(*this); 8105 Body = ActOnCompoundStmt(Loc, Loc, Statements, 8106 /*isStmtExpr=*/false); 8107 assert(!Body.isInvalid() && "Compound statement creation cannot fail"); 8108 } 8109 CopyAssignOperator->setBody(Body.takeAs<Stmt>()); 8110 8111 if (ASTMutationListener *L = getASTMutationListener()) { 8112 L->CompletedImplicitDefinition(CopyAssignOperator); 8113 } 8114} 8115 8116Sema::ImplicitExceptionSpecification 8117Sema::ComputeDefaultedMoveAssignmentExceptionSpec(CXXMethodDecl *MD) { 8118 CXXRecordDecl *ClassDecl = MD->getParent(); 8119 8120 ImplicitExceptionSpecification ExceptSpec(*this); 8121 if (ClassDecl->isInvalidDecl()) 8122 return ExceptSpec; 8123 8124 // C++0x [except.spec]p14: 8125 // An implicitly declared special member function (Clause 12) shall have an 8126 // exception-specification. [...] 8127 8128 // It is unspecified whether or not an implicit move assignment operator 8129 // attempts to deduplicate calls to assignment operators of virtual bases are 8130 // made. As such, this exception specification is effectively unspecified. 8131 // Based on a similar decision made for constness in C++0x, we're erring on 8132 // the side of assuming such calls to be made regardless of whether they 8133 // actually happen. 8134 // Note that a move constructor is not implicitly declared when there are 8135 // virtual bases, but it can still be user-declared and explicitly defaulted. 8136 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), 8137 BaseEnd = ClassDecl->bases_end(); 8138 Base != BaseEnd; ++Base) { 8139 if (Base->isVirtual()) 8140 continue; 8141 8142 CXXRecordDecl *BaseClassDecl 8143 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 8144 if (CXXMethodDecl *MoveAssign = LookupMovingAssignment(BaseClassDecl, 8145 0, false, 0)) 8146 ExceptSpec.CalledDecl(Base->getLocStart(), MoveAssign); 8147 } 8148 8149 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(), 8150 BaseEnd = ClassDecl->vbases_end(); 8151 Base != BaseEnd; ++Base) { 8152 CXXRecordDecl *BaseClassDecl 8153 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 8154 if (CXXMethodDecl *MoveAssign = LookupMovingAssignment(BaseClassDecl, 8155 0, false, 0)) 8156 ExceptSpec.CalledDecl(Base->getLocStart(), MoveAssign); 8157 } 8158 8159 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 8160 FieldEnd = ClassDecl->field_end(); 8161 Field != FieldEnd; 8162 ++Field) { 8163 QualType FieldType = Context.getBaseElementType(Field->getType()); 8164 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) { 8165 if (CXXMethodDecl *MoveAssign = 8166 LookupMovingAssignment(FieldClassDecl, 8167 FieldType.getCVRQualifiers(), 8168 false, 0)) 8169 ExceptSpec.CalledDecl(Field->getLocation(), MoveAssign); 8170 } 8171 } 8172 8173 return ExceptSpec; 8174} 8175 8176/// Determine whether the class type has any direct or indirect virtual base 8177/// classes which have a non-trivial move assignment operator. 8178static bool 8179hasVirtualBaseWithNonTrivialMoveAssignment(Sema &S, CXXRecordDecl *ClassDecl) { 8180 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(), 8181 BaseEnd = ClassDecl->vbases_end(); 8182 Base != BaseEnd; ++Base) { 8183 CXXRecordDecl *BaseClass = 8184 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 8185 8186 // Try to declare the move assignment. If it would be deleted, then the 8187 // class does not have a non-trivial move assignment. 8188 if (BaseClass->needsImplicitMoveAssignment()) 8189 S.DeclareImplicitMoveAssignment(BaseClass); 8190 8191 // If the class has both a trivial move assignment and a non-trivial move 8192 // assignment, hasTrivialMoveAssignment() is false. 8193 if (BaseClass->hasDeclaredMoveAssignment() && 8194 !BaseClass->hasTrivialMoveAssignment()) 8195 return true; 8196 } 8197 8198 return false; 8199} 8200 8201/// Determine whether the given type either has a move constructor or is 8202/// trivially copyable. 8203static bool 8204hasMoveOrIsTriviallyCopyable(Sema &S, QualType Type, bool IsConstructor) { 8205 Type = S.Context.getBaseElementType(Type); 8206 8207 // FIXME: Technically, non-trivially-copyable non-class types, such as 8208 // reference types, are supposed to return false here, but that appears 8209 // to be a standard defect. 8210 CXXRecordDecl *ClassDecl = Type->getAsCXXRecordDecl(); 8211 if (!ClassDecl || !ClassDecl->getDefinition() || ClassDecl->isInvalidDecl()) 8212 return true; 8213 8214 if (Type.isTriviallyCopyableType(S.Context)) 8215 return true; 8216 8217 if (IsConstructor) { 8218 if (ClassDecl->needsImplicitMoveConstructor()) 8219 S.DeclareImplicitMoveConstructor(ClassDecl); 8220 return ClassDecl->hasDeclaredMoveConstructor(); 8221 } 8222 8223 if (ClassDecl->needsImplicitMoveAssignment()) 8224 S.DeclareImplicitMoveAssignment(ClassDecl); 8225 return ClassDecl->hasDeclaredMoveAssignment(); 8226} 8227 8228/// Determine whether all non-static data members and direct or virtual bases 8229/// of class \p ClassDecl have either a move operation, or are trivially 8230/// copyable. 8231static bool subobjectsHaveMoveOrTrivialCopy(Sema &S, CXXRecordDecl *ClassDecl, 8232 bool IsConstructor) { 8233 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), 8234 BaseEnd = ClassDecl->bases_end(); 8235 Base != BaseEnd; ++Base) { 8236 if (Base->isVirtual()) 8237 continue; 8238 8239 if (!hasMoveOrIsTriviallyCopyable(S, Base->getType(), IsConstructor)) 8240 return false; 8241 } 8242 8243 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(), 8244 BaseEnd = ClassDecl->vbases_end(); 8245 Base != BaseEnd; ++Base) { 8246 if (!hasMoveOrIsTriviallyCopyable(S, Base->getType(), IsConstructor)) 8247 return false; 8248 } 8249 8250 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 8251 FieldEnd = ClassDecl->field_end(); 8252 Field != FieldEnd; ++Field) { 8253 if (!hasMoveOrIsTriviallyCopyable(S, Field->getType(), IsConstructor)) 8254 return false; 8255 } 8256 8257 return true; 8258} 8259 8260CXXMethodDecl *Sema::DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl) { 8261 // C++11 [class.copy]p20: 8262 // If the definition of a class X does not explicitly declare a move 8263 // assignment operator, one will be implicitly declared as defaulted 8264 // if and only if: 8265 // 8266 // - [first 4 bullets] 8267 assert(ClassDecl->needsImplicitMoveAssignment()); 8268 8269 // [Checked after we build the declaration] 8270 // - the move assignment operator would not be implicitly defined as 8271 // deleted, 8272 8273 // [DR1402]: 8274 // - X has no direct or indirect virtual base class with a non-trivial 8275 // move assignment operator, and 8276 // - each of X's non-static data members and direct or virtual base classes 8277 // has a type that either has a move assignment operator or is trivially 8278 // copyable. 8279 if (hasVirtualBaseWithNonTrivialMoveAssignment(*this, ClassDecl) || 8280 !subobjectsHaveMoveOrTrivialCopy(*this, ClassDecl,/*Constructor*/false)) { 8281 ClassDecl->setFailedImplicitMoveAssignment(); 8282 return 0; 8283 } 8284 8285 // Note: The following rules are largely analoguous to the move 8286 // constructor rules. 8287 8288 QualType ArgType = Context.getTypeDeclType(ClassDecl); 8289 QualType RetType = Context.getLValueReferenceType(ArgType); 8290 ArgType = Context.getRValueReferenceType(ArgType); 8291 8292 // An implicitly-declared move assignment operator is an inline public 8293 // member of its class. 8294 DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal); 8295 SourceLocation ClassLoc = ClassDecl->getLocation(); 8296 DeclarationNameInfo NameInfo(Name, ClassLoc); 8297 CXXMethodDecl *MoveAssignment 8298 = CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(), 8299 /*TInfo=*/0, /*isStatic=*/false, 8300 /*StorageClassAsWritten=*/SC_None, 8301 /*isInline=*/true, 8302 /*isConstexpr=*/false, 8303 SourceLocation()); 8304 MoveAssignment->setAccess(AS_public); 8305 MoveAssignment->setDefaulted(); 8306 MoveAssignment->setImplicit(); 8307 MoveAssignment->setTrivial(ClassDecl->hasTrivialMoveAssignment()); 8308 8309 // Build an exception specification pointing back at this member. 8310 FunctionProtoType::ExtProtoInfo EPI; 8311 EPI.ExceptionSpecType = EST_Unevaluated; 8312 EPI.ExceptionSpecDecl = MoveAssignment; 8313 MoveAssignment->setType(Context.getFunctionType(RetType, &ArgType, 1, EPI)); 8314 8315 // Add the parameter to the operator. 8316 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveAssignment, 8317 ClassLoc, ClassLoc, /*Id=*/0, 8318 ArgType, /*TInfo=*/0, 8319 SC_None, 8320 SC_None, 0); 8321 MoveAssignment->setParams(FromParam); 8322 8323 // Note that we have added this copy-assignment operator. 8324 ++ASTContext::NumImplicitMoveAssignmentOperatorsDeclared; 8325 8326 // C++0x [class.copy]p9: 8327 // If the definition of a class X does not explicitly declare a move 8328 // assignment operator, one will be implicitly declared as defaulted if and 8329 // only if: 8330 // [...] 8331 // - the move assignment operator would not be implicitly defined as 8332 // deleted. 8333 if (ShouldDeleteSpecialMember(MoveAssignment, CXXMoveAssignment)) { 8334 // Cache this result so that we don't try to generate this over and over 8335 // on every lookup, leaking memory and wasting time. 8336 ClassDecl->setFailedImplicitMoveAssignment(); 8337 return 0; 8338 } 8339 8340 if (Scope *S = getScopeForContext(ClassDecl)) 8341 PushOnScopeChains(MoveAssignment, S, false); 8342 ClassDecl->addDecl(MoveAssignment); 8343 8344 AddOverriddenMethods(ClassDecl, MoveAssignment); 8345 return MoveAssignment; 8346} 8347 8348void Sema::DefineImplicitMoveAssignment(SourceLocation CurrentLocation, 8349 CXXMethodDecl *MoveAssignOperator) { 8350 assert((MoveAssignOperator->isDefaulted() && 8351 MoveAssignOperator->isOverloadedOperator() && 8352 MoveAssignOperator->getOverloadedOperator() == OO_Equal && 8353 !MoveAssignOperator->doesThisDeclarationHaveABody() && 8354 !MoveAssignOperator->isDeleted()) && 8355 "DefineImplicitMoveAssignment called for wrong function"); 8356 8357 CXXRecordDecl *ClassDecl = MoveAssignOperator->getParent(); 8358 8359 if (ClassDecl->isInvalidDecl() || MoveAssignOperator->isInvalidDecl()) { 8360 MoveAssignOperator->setInvalidDecl(); 8361 return; 8362 } 8363 8364 MoveAssignOperator->setUsed(); 8365 8366 SynthesizedFunctionScope Scope(*this, MoveAssignOperator); 8367 DiagnosticErrorTrap Trap(Diags); 8368 8369 // C++0x [class.copy]p28: 8370 // The implicitly-defined or move assignment operator for a non-union class 8371 // X performs memberwise move assignment of its subobjects. The direct base 8372 // classes of X are assigned first, in the order of their declaration in the 8373 // base-specifier-list, and then the immediate non-static data members of X 8374 // are assigned, in the order in which they were declared in the class 8375 // definition. 8376 8377 // The statements that form the synthesized function body. 8378 SmallVector<Stmt*, 8> Statements; 8379 8380 // The parameter for the "other" object, which we are move from. 8381 ParmVarDecl *Other = MoveAssignOperator->getParamDecl(0); 8382 QualType OtherRefType = Other->getType()-> 8383 getAs<RValueReferenceType>()->getPointeeType(); 8384 assert(OtherRefType.getQualifiers() == 0 && 8385 "Bad argument type of defaulted move assignment"); 8386 8387 // Our location for everything implicitly-generated. 8388 SourceLocation Loc = MoveAssignOperator->getLocation(); 8389 8390 // Construct a reference to the "other" object. We'll be using this 8391 // throughout the generated ASTs. 8392 Expr *OtherRef = BuildDeclRefExpr(Other, OtherRefType, VK_LValue, Loc).take(); 8393 assert(OtherRef && "Reference to parameter cannot fail!"); 8394 // Cast to rvalue. 8395 OtherRef = CastForMoving(*this, OtherRef); 8396 8397 // Construct the "this" pointer. We'll be using this throughout the generated 8398 // ASTs. 8399 Expr *This = ActOnCXXThis(Loc).takeAs<Expr>(); 8400 assert(This && "Reference to this cannot fail!"); 8401 8402 // Assign base classes. 8403 bool Invalid = false; 8404 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), 8405 E = ClassDecl->bases_end(); Base != E; ++Base) { 8406 // Form the assignment: 8407 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other)); 8408 QualType BaseType = Base->getType().getUnqualifiedType(); 8409 if (!BaseType->isRecordType()) { 8410 Invalid = true; 8411 continue; 8412 } 8413 8414 CXXCastPath BasePath; 8415 BasePath.push_back(Base); 8416 8417 // Construct the "from" expression, which is an implicit cast to the 8418 // appropriately-qualified base type. 8419 Expr *From = OtherRef; 8420 From = ImpCastExprToType(From, BaseType, CK_UncheckedDerivedToBase, 8421 VK_XValue, &BasePath).take(); 8422 8423 // Dereference "this". 8424 ExprResult To = CreateBuiltinUnaryOp(Loc, UO_Deref, This); 8425 8426 // Implicitly cast "this" to the appropriately-qualified base type. 8427 To = ImpCastExprToType(To.take(), 8428 Context.getCVRQualifiedType(BaseType, 8429 MoveAssignOperator->getTypeQualifiers()), 8430 CK_UncheckedDerivedToBase, 8431 VK_LValue, &BasePath); 8432 8433 // Build the move. 8434 StmtResult Move = BuildSingleCopyAssign(*this, Loc, BaseType, 8435 To.get(), From, 8436 /*CopyingBaseSubobject=*/true, 8437 /*Copying=*/false); 8438 if (Move.isInvalid()) { 8439 Diag(CurrentLocation, diag::note_member_synthesized_at) 8440 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl); 8441 MoveAssignOperator->setInvalidDecl(); 8442 return; 8443 } 8444 8445 // Success! Record the move. 8446 Statements.push_back(Move.takeAs<Expr>()); 8447 } 8448 8449 // \brief Reference to the __builtin_memcpy function. 8450 Expr *BuiltinMemCpyRef = 0; 8451 // \brief Reference to the __builtin_objc_memmove_collectable function. 8452 Expr *CollectableMemCpyRef = 0; 8453 8454 // Assign non-static members. 8455 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 8456 FieldEnd = ClassDecl->field_end(); 8457 Field != FieldEnd; ++Field) { 8458 if (Field->isUnnamedBitfield()) 8459 continue; 8460 8461 // Check for members of reference type; we can't move those. 8462 if (Field->getType()->isReferenceType()) { 8463 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign) 8464 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName(); 8465 Diag(Field->getLocation(), diag::note_declared_at); 8466 Diag(CurrentLocation, diag::note_member_synthesized_at) 8467 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl); 8468 Invalid = true; 8469 continue; 8470 } 8471 8472 // Check for members of const-qualified, non-class type. 8473 QualType BaseType = Context.getBaseElementType(Field->getType()); 8474 if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) { 8475 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign) 8476 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName(); 8477 Diag(Field->getLocation(), diag::note_declared_at); 8478 Diag(CurrentLocation, diag::note_member_synthesized_at) 8479 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl); 8480 Invalid = true; 8481 continue; 8482 } 8483 8484 // Suppress assigning zero-width bitfields. 8485 if (Field->isBitField() && Field->getBitWidthValue(Context) == 0) 8486 continue; 8487 8488 QualType FieldType = Field->getType().getNonReferenceType(); 8489 if (FieldType->isIncompleteArrayType()) { 8490 assert(ClassDecl->hasFlexibleArrayMember() && 8491 "Incomplete array type is not valid"); 8492 continue; 8493 } 8494 8495 // Build references to the field in the object we're copying from and to. 8496 CXXScopeSpec SS; // Intentionally empty 8497 LookupResult MemberLookup(*this, Field->getDeclName(), Loc, 8498 LookupMemberName); 8499 MemberLookup.addDecl(*Field); 8500 MemberLookup.resolveKind(); 8501 ExprResult From = BuildMemberReferenceExpr(OtherRef, OtherRefType, 8502 Loc, /*IsArrow=*/false, 8503 SS, SourceLocation(), 0, 8504 MemberLookup, 0); 8505 ExprResult To = BuildMemberReferenceExpr(This, This->getType(), 8506 Loc, /*IsArrow=*/true, 8507 SS, SourceLocation(), 0, 8508 MemberLookup, 0); 8509 assert(!From.isInvalid() && "Implicit field reference cannot fail"); 8510 assert(!To.isInvalid() && "Implicit field reference cannot fail"); 8511 8512 assert(!From.get()->isLValue() && // could be xvalue or prvalue 8513 "Member reference with rvalue base must be rvalue except for reference " 8514 "members, which aren't allowed for move assignment."); 8515 8516 // If the field should be copied with __builtin_memcpy rather than via 8517 // explicit assignments, do so. This optimization only applies for arrays 8518 // of scalars and arrays of class type with trivial move-assignment 8519 // operators. 8520 if (FieldType->isArrayType() && !FieldType.isVolatileQualified() 8521 && BaseType.hasTrivialAssignment(Context, /*Copying=*/false)) { 8522 // Compute the size of the memory buffer to be copied. 8523 QualType SizeType = Context.getSizeType(); 8524 llvm::APInt Size(Context.getTypeSize(SizeType), 8525 Context.getTypeSizeInChars(BaseType).getQuantity()); 8526 for (const ConstantArrayType *Array 8527 = Context.getAsConstantArrayType(FieldType); 8528 Array; 8529 Array = Context.getAsConstantArrayType(Array->getElementType())) { 8530 llvm::APInt ArraySize 8531 = Array->getSize().zextOrTrunc(Size.getBitWidth()); 8532 Size *= ArraySize; 8533 } 8534 8535 // Take the address of the field references for "from" and "to". We 8536 // directly construct UnaryOperators here because semantic analysis 8537 // does not permit us to take the address of an xvalue. 8538 From = new (Context) UnaryOperator(From.get(), UO_AddrOf, 8539 Context.getPointerType(From.get()->getType()), 8540 VK_RValue, OK_Ordinary, Loc); 8541 To = new (Context) UnaryOperator(To.get(), UO_AddrOf, 8542 Context.getPointerType(To.get()->getType()), 8543 VK_RValue, OK_Ordinary, Loc); 8544 8545 bool NeedsCollectableMemCpy = 8546 (BaseType->isRecordType() && 8547 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember()); 8548 8549 if (NeedsCollectableMemCpy) { 8550 if (!CollectableMemCpyRef) { 8551 // Create a reference to the __builtin_objc_memmove_collectable function. 8552 LookupResult R(*this, 8553 &Context.Idents.get("__builtin_objc_memmove_collectable"), 8554 Loc, LookupOrdinaryName); 8555 LookupName(R, TUScope, true); 8556 8557 FunctionDecl *CollectableMemCpy = R.getAsSingle<FunctionDecl>(); 8558 if (!CollectableMemCpy) { 8559 // Something went horribly wrong earlier, and we will have 8560 // complained about it. 8561 Invalid = true; 8562 continue; 8563 } 8564 8565 CollectableMemCpyRef = BuildDeclRefExpr(CollectableMemCpy, 8566 Context.BuiltinFnTy, 8567 VK_RValue, Loc, 0).take(); 8568 assert(CollectableMemCpyRef && "Builtin reference cannot fail"); 8569 } 8570 } 8571 // Create a reference to the __builtin_memcpy builtin function. 8572 else if (!BuiltinMemCpyRef) { 8573 LookupResult R(*this, &Context.Idents.get("__builtin_memcpy"), Loc, 8574 LookupOrdinaryName); 8575 LookupName(R, TUScope, true); 8576 8577 FunctionDecl *BuiltinMemCpy = R.getAsSingle<FunctionDecl>(); 8578 if (!BuiltinMemCpy) { 8579 // Something went horribly wrong earlier, and we will have complained 8580 // about it. 8581 Invalid = true; 8582 continue; 8583 } 8584 8585 BuiltinMemCpyRef = BuildDeclRefExpr(BuiltinMemCpy, 8586 Context.BuiltinFnTy, 8587 VK_RValue, Loc, 0).take(); 8588 assert(BuiltinMemCpyRef && "Builtin reference cannot fail"); 8589 } 8590 8591 SmallVector<Expr*, 8> CallArgs; 8592 CallArgs.push_back(To.takeAs<Expr>()); 8593 CallArgs.push_back(From.takeAs<Expr>()); 8594 CallArgs.push_back(IntegerLiteral::Create(Context, Size, SizeType, Loc)); 8595 ExprResult Call = ExprError(); 8596 if (NeedsCollectableMemCpy) 8597 Call = ActOnCallExpr(/*Scope=*/0, 8598 CollectableMemCpyRef, 8599 Loc, CallArgs, 8600 Loc); 8601 else 8602 Call = ActOnCallExpr(/*Scope=*/0, 8603 BuiltinMemCpyRef, 8604 Loc, CallArgs, 8605 Loc); 8606 8607 assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!"); 8608 Statements.push_back(Call.takeAs<Expr>()); 8609 continue; 8610 } 8611 8612 // Build the move of this field. 8613 StmtResult Move = BuildSingleCopyAssign(*this, Loc, FieldType, 8614 To.get(), From.get(), 8615 /*CopyingBaseSubobject=*/false, 8616 /*Copying=*/false); 8617 if (Move.isInvalid()) { 8618 Diag(CurrentLocation, diag::note_member_synthesized_at) 8619 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl); 8620 MoveAssignOperator->setInvalidDecl(); 8621 return; 8622 } 8623 8624 // Success! Record the copy. 8625 Statements.push_back(Move.takeAs<Stmt>()); 8626 } 8627 8628 if (!Invalid) { 8629 // Add a "return *this;" 8630 ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This); 8631 8632 StmtResult Return = ActOnReturnStmt(Loc, ThisObj.get()); 8633 if (Return.isInvalid()) 8634 Invalid = true; 8635 else { 8636 Statements.push_back(Return.takeAs<Stmt>()); 8637 8638 if (Trap.hasErrorOccurred()) { 8639 Diag(CurrentLocation, diag::note_member_synthesized_at) 8640 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl); 8641 Invalid = true; 8642 } 8643 } 8644 } 8645 8646 if (Invalid) { 8647 MoveAssignOperator->setInvalidDecl(); 8648 return; 8649 } 8650 8651 StmtResult Body; 8652 { 8653 CompoundScopeRAII CompoundScope(*this); 8654 Body = ActOnCompoundStmt(Loc, Loc, Statements, 8655 /*isStmtExpr=*/false); 8656 assert(!Body.isInvalid() && "Compound statement creation cannot fail"); 8657 } 8658 MoveAssignOperator->setBody(Body.takeAs<Stmt>()); 8659 8660 if (ASTMutationListener *L = getASTMutationListener()) { 8661 L->CompletedImplicitDefinition(MoveAssignOperator); 8662 } 8663} 8664 8665/// Determine whether an implicit copy constructor for ClassDecl has a const 8666/// argument. 8667/// FIXME: It ought to be possible to store this on the record. 8668static bool isImplicitCopyCtorArgConst(Sema &S, CXXRecordDecl *ClassDecl) { 8669 if (ClassDecl->isInvalidDecl()) 8670 return true; 8671 8672 // C++ [class.copy]p5: 8673 // The implicitly-declared copy constructor for a class X will 8674 // have the form 8675 // 8676 // X::X(const X&) 8677 // 8678 // if 8679 // -- each direct or virtual base class B of X has a copy 8680 // constructor whose first parameter is of type const B& or 8681 // const volatile B&, and 8682 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), 8683 BaseEnd = ClassDecl->bases_end(); 8684 Base != BaseEnd; ++Base) { 8685 // Virtual bases are handled below. 8686 if (Base->isVirtual()) 8687 continue; 8688 8689 CXXRecordDecl *BaseClassDecl 8690 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 8691 // FIXME: This lookup is wrong. If the copy ctor for a member or base is 8692 // ambiguous, we should still produce a constructor with a const-qualified 8693 // parameter. 8694 if (!S.LookupCopyingConstructor(BaseClassDecl, Qualifiers::Const)) 8695 return false; 8696 } 8697 8698 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(), 8699 BaseEnd = ClassDecl->vbases_end(); 8700 Base != BaseEnd; ++Base) { 8701 CXXRecordDecl *BaseClassDecl 8702 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 8703 if (!S.LookupCopyingConstructor(BaseClassDecl, Qualifiers::Const)) 8704 return false; 8705 } 8706 8707 // -- for all the nonstatic data members of X that are of a 8708 // class type M (or array thereof), each such class type 8709 // has a copy constructor whose first parameter is of type 8710 // const M& or const volatile M&. 8711 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 8712 FieldEnd = ClassDecl->field_end(); 8713 Field != FieldEnd; ++Field) { 8714 QualType FieldType = S.Context.getBaseElementType(Field->getType()); 8715 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) { 8716 if (!S.LookupCopyingConstructor(FieldClassDecl, Qualifiers::Const)) 8717 return false; 8718 } 8719 } 8720 8721 // Otherwise, the implicitly declared copy constructor will have 8722 // the form 8723 // 8724 // X::X(X&) 8725 8726 return true; 8727} 8728 8729Sema::ImplicitExceptionSpecification 8730Sema::ComputeDefaultedCopyCtorExceptionSpec(CXXMethodDecl *MD) { 8731 CXXRecordDecl *ClassDecl = MD->getParent(); 8732 8733 ImplicitExceptionSpecification ExceptSpec(*this); 8734 if (ClassDecl->isInvalidDecl()) 8735 return ExceptSpec; 8736 8737 const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>(); 8738 assert(T->getNumArgs() >= 1 && "not a copy ctor"); 8739 unsigned Quals = T->getArgType(0).getNonReferenceType().getCVRQualifiers(); 8740 8741 // C++ [except.spec]p14: 8742 // An implicitly declared special member function (Clause 12) shall have an 8743 // exception-specification. [...] 8744 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), 8745 BaseEnd = ClassDecl->bases_end(); 8746 Base != BaseEnd; 8747 ++Base) { 8748 // Virtual bases are handled below. 8749 if (Base->isVirtual()) 8750 continue; 8751 8752 CXXRecordDecl *BaseClassDecl 8753 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 8754 if (CXXConstructorDecl *CopyConstructor = 8755 LookupCopyingConstructor(BaseClassDecl, Quals)) 8756 ExceptSpec.CalledDecl(Base->getLocStart(), CopyConstructor); 8757 } 8758 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(), 8759 BaseEnd = ClassDecl->vbases_end(); 8760 Base != BaseEnd; 8761 ++Base) { 8762 CXXRecordDecl *BaseClassDecl 8763 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 8764 if (CXXConstructorDecl *CopyConstructor = 8765 LookupCopyingConstructor(BaseClassDecl, Quals)) 8766 ExceptSpec.CalledDecl(Base->getLocStart(), CopyConstructor); 8767 } 8768 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 8769 FieldEnd = ClassDecl->field_end(); 8770 Field != FieldEnd; 8771 ++Field) { 8772 QualType FieldType = Context.getBaseElementType(Field->getType()); 8773 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) { 8774 if (CXXConstructorDecl *CopyConstructor = 8775 LookupCopyingConstructor(FieldClassDecl, 8776 Quals | FieldType.getCVRQualifiers())) 8777 ExceptSpec.CalledDecl(Field->getLocation(), CopyConstructor); 8778 } 8779 } 8780 8781 return ExceptSpec; 8782} 8783 8784CXXConstructorDecl *Sema::DeclareImplicitCopyConstructor( 8785 CXXRecordDecl *ClassDecl) { 8786 // C++ [class.copy]p4: 8787 // If the class definition does not explicitly declare a copy 8788 // constructor, one is declared implicitly. 8789 8790 QualType ClassType = Context.getTypeDeclType(ClassDecl); 8791 QualType ArgType = ClassType; 8792 bool Const = isImplicitCopyCtorArgConst(*this, ClassDecl); 8793 if (Const) 8794 ArgType = ArgType.withConst(); 8795 ArgType = Context.getLValueReferenceType(ArgType); 8796 8797 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl, 8798 CXXCopyConstructor, 8799 Const); 8800 8801 DeclarationName Name 8802 = Context.DeclarationNames.getCXXConstructorName( 8803 Context.getCanonicalType(ClassType)); 8804 SourceLocation ClassLoc = ClassDecl->getLocation(); 8805 DeclarationNameInfo NameInfo(Name, ClassLoc); 8806 8807 // An implicitly-declared copy constructor is an inline public 8808 // member of its class. 8809 CXXConstructorDecl *CopyConstructor = CXXConstructorDecl::Create( 8810 Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/0, 8811 /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true, 8812 Constexpr); 8813 CopyConstructor->setAccess(AS_public); 8814 CopyConstructor->setDefaulted(); 8815 CopyConstructor->setTrivial(ClassDecl->hasTrivialCopyConstructor()); 8816 8817 // Build an exception specification pointing back at this member. 8818 FunctionProtoType::ExtProtoInfo EPI; 8819 EPI.ExceptionSpecType = EST_Unevaluated; 8820 EPI.ExceptionSpecDecl = CopyConstructor; 8821 CopyConstructor->setType( 8822 Context.getFunctionType(Context.VoidTy, &ArgType, 1, EPI)); 8823 8824 // Note that we have declared this constructor. 8825 ++ASTContext::NumImplicitCopyConstructorsDeclared; 8826 8827 // Add the parameter to the constructor. 8828 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor, 8829 ClassLoc, ClassLoc, 8830 /*IdentifierInfo=*/0, 8831 ArgType, /*TInfo=*/0, 8832 SC_None, 8833 SC_None, 0); 8834 CopyConstructor->setParams(FromParam); 8835 8836 if (Scope *S = getScopeForContext(ClassDecl)) 8837 PushOnScopeChains(CopyConstructor, S, false); 8838 ClassDecl->addDecl(CopyConstructor); 8839 8840 // C++11 [class.copy]p8: 8841 // ... If the class definition does not explicitly declare a copy 8842 // constructor, there is no user-declared move constructor, and there is no 8843 // user-declared move assignment operator, a copy constructor is implicitly 8844 // declared as defaulted. 8845 if (ShouldDeleteSpecialMember(CopyConstructor, CXXCopyConstructor)) 8846 CopyConstructor->setDeletedAsWritten(); 8847 8848 return CopyConstructor; 8849} 8850 8851void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation, 8852 CXXConstructorDecl *CopyConstructor) { 8853 assert((CopyConstructor->isDefaulted() && 8854 CopyConstructor->isCopyConstructor() && 8855 !CopyConstructor->doesThisDeclarationHaveABody() && 8856 !CopyConstructor->isDeleted()) && 8857 "DefineImplicitCopyConstructor - call it for implicit copy ctor"); 8858 8859 CXXRecordDecl *ClassDecl = CopyConstructor->getParent(); 8860 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor"); 8861 8862 SynthesizedFunctionScope Scope(*this, CopyConstructor); 8863 DiagnosticErrorTrap Trap(Diags); 8864 8865 if (SetCtorInitializers(CopyConstructor, 0, 0, /*AnyErrors=*/false) || 8866 Trap.hasErrorOccurred()) { 8867 Diag(CurrentLocation, diag::note_member_synthesized_at) 8868 << CXXCopyConstructor << Context.getTagDeclType(ClassDecl); 8869 CopyConstructor->setInvalidDecl(); 8870 } else { 8871 Sema::CompoundScopeRAII CompoundScope(*this); 8872 CopyConstructor->setBody(ActOnCompoundStmt(CopyConstructor->getLocation(), 8873 CopyConstructor->getLocation(), 8874 MultiStmtArg(), 8875 /*isStmtExpr=*/false) 8876 .takeAs<Stmt>()); 8877 CopyConstructor->setImplicitlyDefined(true); 8878 } 8879 8880 CopyConstructor->setUsed(); 8881 if (ASTMutationListener *L = getASTMutationListener()) { 8882 L->CompletedImplicitDefinition(CopyConstructor); 8883 } 8884} 8885 8886Sema::ImplicitExceptionSpecification 8887Sema::ComputeDefaultedMoveCtorExceptionSpec(CXXMethodDecl *MD) { 8888 CXXRecordDecl *ClassDecl = MD->getParent(); 8889 8890 // C++ [except.spec]p14: 8891 // An implicitly declared special member function (Clause 12) shall have an 8892 // exception-specification. [...] 8893 ImplicitExceptionSpecification ExceptSpec(*this); 8894 if (ClassDecl->isInvalidDecl()) 8895 return ExceptSpec; 8896 8897 // Direct base-class constructors. 8898 for (CXXRecordDecl::base_class_iterator B = ClassDecl->bases_begin(), 8899 BEnd = ClassDecl->bases_end(); 8900 B != BEnd; ++B) { 8901 if (B->isVirtual()) // Handled below. 8902 continue; 8903 8904 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) { 8905 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl()); 8906 CXXConstructorDecl *Constructor = 8907 LookupMovingConstructor(BaseClassDecl, 0); 8908 // If this is a deleted function, add it anyway. This might be conformant 8909 // with the standard. This might not. I'm not sure. It might not matter. 8910 if (Constructor) 8911 ExceptSpec.CalledDecl(B->getLocStart(), Constructor); 8912 } 8913 } 8914 8915 // Virtual base-class constructors. 8916 for (CXXRecordDecl::base_class_iterator B = ClassDecl->vbases_begin(), 8917 BEnd = ClassDecl->vbases_end(); 8918 B != BEnd; ++B) { 8919 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) { 8920 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl()); 8921 CXXConstructorDecl *Constructor = 8922 LookupMovingConstructor(BaseClassDecl, 0); 8923 // If this is a deleted function, add it anyway. This might be conformant 8924 // with the standard. This might not. I'm not sure. It might not matter. 8925 if (Constructor) 8926 ExceptSpec.CalledDecl(B->getLocStart(), Constructor); 8927 } 8928 } 8929 8930 // Field constructors. 8931 for (RecordDecl::field_iterator F = ClassDecl->field_begin(), 8932 FEnd = ClassDecl->field_end(); 8933 F != FEnd; ++F) { 8934 QualType FieldType = Context.getBaseElementType(F->getType()); 8935 if (CXXRecordDecl *FieldRecDecl = FieldType->getAsCXXRecordDecl()) { 8936 CXXConstructorDecl *Constructor = 8937 LookupMovingConstructor(FieldRecDecl, FieldType.getCVRQualifiers()); 8938 // If this is a deleted function, add it anyway. This might be conformant 8939 // with the standard. This might not. I'm not sure. It might not matter. 8940 // In particular, the problem is that this function never gets called. It 8941 // might just be ill-formed because this function attempts to refer to 8942 // a deleted function here. 8943 if (Constructor) 8944 ExceptSpec.CalledDecl(F->getLocation(), Constructor); 8945 } 8946 } 8947 8948 return ExceptSpec; 8949} 8950 8951CXXConstructorDecl *Sema::DeclareImplicitMoveConstructor( 8952 CXXRecordDecl *ClassDecl) { 8953 // C++11 [class.copy]p9: 8954 // If the definition of a class X does not explicitly declare a move 8955 // constructor, one will be implicitly declared as defaulted if and only if: 8956 // 8957 // - [first 4 bullets] 8958 assert(ClassDecl->needsImplicitMoveConstructor()); 8959 8960 // [Checked after we build the declaration] 8961 // - the move assignment operator would not be implicitly defined as 8962 // deleted, 8963 8964 // [DR1402]: 8965 // - each of X's non-static data members and direct or virtual base classes 8966 // has a type that either has a move constructor or is trivially copyable. 8967 if (!subobjectsHaveMoveOrTrivialCopy(*this, ClassDecl, /*Constructor*/true)) { 8968 ClassDecl->setFailedImplicitMoveConstructor(); 8969 return 0; 8970 } 8971 8972 QualType ClassType = Context.getTypeDeclType(ClassDecl); 8973 QualType ArgType = Context.getRValueReferenceType(ClassType); 8974 8975 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl, 8976 CXXMoveConstructor, 8977 false); 8978 8979 DeclarationName Name 8980 = Context.DeclarationNames.getCXXConstructorName( 8981 Context.getCanonicalType(ClassType)); 8982 SourceLocation ClassLoc = ClassDecl->getLocation(); 8983 DeclarationNameInfo NameInfo(Name, ClassLoc); 8984 8985 // C++0x [class.copy]p11: 8986 // An implicitly-declared copy/move constructor is an inline public 8987 // member of its class. 8988 CXXConstructorDecl *MoveConstructor = CXXConstructorDecl::Create( 8989 Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/0, 8990 /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true, 8991 Constexpr); 8992 MoveConstructor->setAccess(AS_public); 8993 MoveConstructor->setDefaulted(); 8994 MoveConstructor->setTrivial(ClassDecl->hasTrivialMoveConstructor()); 8995 8996 // Build an exception specification pointing back at this member. 8997 FunctionProtoType::ExtProtoInfo EPI; 8998 EPI.ExceptionSpecType = EST_Unevaluated; 8999 EPI.ExceptionSpecDecl = MoveConstructor; 9000 MoveConstructor->setType( 9001 Context.getFunctionType(Context.VoidTy, &ArgType, 1, EPI)); 9002 9003 // Add the parameter to the constructor. 9004 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveConstructor, 9005 ClassLoc, ClassLoc, 9006 /*IdentifierInfo=*/0, 9007 ArgType, /*TInfo=*/0, 9008 SC_None, 9009 SC_None, 0); 9010 MoveConstructor->setParams(FromParam); 9011 9012 // C++0x [class.copy]p9: 9013 // If the definition of a class X does not explicitly declare a move 9014 // constructor, one will be implicitly declared as defaulted if and only if: 9015 // [...] 9016 // - the move constructor would not be implicitly defined as deleted. 9017 if (ShouldDeleteSpecialMember(MoveConstructor, CXXMoveConstructor)) { 9018 // Cache this result so that we don't try to generate this over and over 9019 // on every lookup, leaking memory and wasting time. 9020 ClassDecl->setFailedImplicitMoveConstructor(); 9021 return 0; 9022 } 9023 9024 // Note that we have declared this constructor. 9025 ++ASTContext::NumImplicitMoveConstructorsDeclared; 9026 9027 if (Scope *S = getScopeForContext(ClassDecl)) 9028 PushOnScopeChains(MoveConstructor, S, false); 9029 ClassDecl->addDecl(MoveConstructor); 9030 9031 return MoveConstructor; 9032} 9033 9034void Sema::DefineImplicitMoveConstructor(SourceLocation CurrentLocation, 9035 CXXConstructorDecl *MoveConstructor) { 9036 assert((MoveConstructor->isDefaulted() && 9037 MoveConstructor->isMoveConstructor() && 9038 !MoveConstructor->doesThisDeclarationHaveABody() && 9039 !MoveConstructor->isDeleted()) && 9040 "DefineImplicitMoveConstructor - call it for implicit move ctor"); 9041 9042 CXXRecordDecl *ClassDecl = MoveConstructor->getParent(); 9043 assert(ClassDecl && "DefineImplicitMoveConstructor - invalid constructor"); 9044 9045 SynthesizedFunctionScope Scope(*this, MoveConstructor); 9046 DiagnosticErrorTrap Trap(Diags); 9047 9048 if (SetCtorInitializers(MoveConstructor, 0, 0, /*AnyErrors=*/false) || 9049 Trap.hasErrorOccurred()) { 9050 Diag(CurrentLocation, diag::note_member_synthesized_at) 9051 << CXXMoveConstructor << Context.getTagDeclType(ClassDecl); 9052 MoveConstructor->setInvalidDecl(); 9053 } else { 9054 Sema::CompoundScopeRAII CompoundScope(*this); 9055 MoveConstructor->setBody(ActOnCompoundStmt(MoveConstructor->getLocation(), 9056 MoveConstructor->getLocation(), 9057 MultiStmtArg(), 9058 /*isStmtExpr=*/false) 9059 .takeAs<Stmt>()); 9060 MoveConstructor->setImplicitlyDefined(true); 9061 } 9062 9063 MoveConstructor->setUsed(); 9064 9065 if (ASTMutationListener *L = getASTMutationListener()) { 9066 L->CompletedImplicitDefinition(MoveConstructor); 9067 } 9068} 9069 9070bool Sema::isImplicitlyDeleted(FunctionDecl *FD) { 9071 return FD->isDeleted() && 9072 (FD->isDefaulted() || FD->isImplicit()) && 9073 isa<CXXMethodDecl>(FD); 9074} 9075 9076/// \brief Mark the call operator of the given lambda closure type as "used". 9077static void markLambdaCallOperatorUsed(Sema &S, CXXRecordDecl *Lambda) { 9078 CXXMethodDecl *CallOperator 9079 = cast<CXXMethodDecl>( 9080 *Lambda->lookup( 9081 S.Context.DeclarationNames.getCXXOperatorName(OO_Call)).first); 9082 CallOperator->setReferenced(); 9083 CallOperator->setUsed(); 9084} 9085 9086void Sema::DefineImplicitLambdaToFunctionPointerConversion( 9087 SourceLocation CurrentLocation, 9088 CXXConversionDecl *Conv) 9089{ 9090 CXXRecordDecl *Lambda = Conv->getParent(); 9091 9092 // Make sure that the lambda call operator is marked used. 9093 markLambdaCallOperatorUsed(*this, Lambda); 9094 9095 Conv->setUsed(); 9096 9097 SynthesizedFunctionScope Scope(*this, Conv); 9098 DiagnosticErrorTrap Trap(Diags); 9099 9100 // Return the address of the __invoke function. 9101 DeclarationName InvokeName = &Context.Idents.get("__invoke"); 9102 CXXMethodDecl *Invoke 9103 = cast<CXXMethodDecl>(*Lambda->lookup(InvokeName).first); 9104 Expr *FunctionRef = BuildDeclRefExpr(Invoke, Invoke->getType(), 9105 VK_LValue, Conv->getLocation()).take(); 9106 assert(FunctionRef && "Can't refer to __invoke function?"); 9107 Stmt *Return = ActOnReturnStmt(Conv->getLocation(), FunctionRef).take(); 9108 Conv->setBody(new (Context) CompoundStmt(Context, &Return, 1, 9109 Conv->getLocation(), 9110 Conv->getLocation())); 9111 9112 // Fill in the __invoke function with a dummy implementation. IR generation 9113 // will fill in the actual details. 9114 Invoke->setUsed(); 9115 Invoke->setReferenced(); 9116 Invoke->setBody(new (Context) CompoundStmt(Conv->getLocation())); 9117 9118 if (ASTMutationListener *L = getASTMutationListener()) { 9119 L->CompletedImplicitDefinition(Conv); 9120 L->CompletedImplicitDefinition(Invoke); 9121 } 9122} 9123 9124void Sema::DefineImplicitLambdaToBlockPointerConversion( 9125 SourceLocation CurrentLocation, 9126 CXXConversionDecl *Conv) 9127{ 9128 Conv->setUsed(); 9129 9130 SynthesizedFunctionScope Scope(*this, Conv); 9131 DiagnosticErrorTrap Trap(Diags); 9132 9133 // Copy-initialize the lambda object as needed to capture it. 9134 Expr *This = ActOnCXXThis(CurrentLocation).take(); 9135 Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).take(); 9136 9137 ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation, 9138 Conv->getLocation(), 9139 Conv, DerefThis); 9140 9141 // If we're not under ARC, make sure we still get the _Block_copy/autorelease 9142 // behavior. Note that only the general conversion function does this 9143 // (since it's unusable otherwise); in the case where we inline the 9144 // block literal, it has block literal lifetime semantics. 9145 if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount) 9146 BuildBlock = ImplicitCastExpr::Create(Context, BuildBlock.get()->getType(), 9147 CK_CopyAndAutoreleaseBlockObject, 9148 BuildBlock.get(), 0, VK_RValue); 9149 9150 if (BuildBlock.isInvalid()) { 9151 Diag(CurrentLocation, diag::note_lambda_to_block_conv); 9152 Conv->setInvalidDecl(); 9153 return; 9154 } 9155 9156 // Create the return statement that returns the block from the conversion 9157 // function. 9158 StmtResult Return = ActOnReturnStmt(Conv->getLocation(), BuildBlock.get()); 9159 if (Return.isInvalid()) { 9160 Diag(CurrentLocation, diag::note_lambda_to_block_conv); 9161 Conv->setInvalidDecl(); 9162 return; 9163 } 9164 9165 // Set the body of the conversion function. 9166 Stmt *ReturnS = Return.take(); 9167 Conv->setBody(new (Context) CompoundStmt(Context, &ReturnS, 1, 9168 Conv->getLocation(), 9169 Conv->getLocation())); 9170 9171 // We're done; notify the mutation listener, if any. 9172 if (ASTMutationListener *L = getASTMutationListener()) { 9173 L->CompletedImplicitDefinition(Conv); 9174 } 9175} 9176 9177/// \brief Determine whether the given list arguments contains exactly one 9178/// "real" (non-default) argument. 9179static bool hasOneRealArgument(MultiExprArg Args) { 9180 switch (Args.size()) { 9181 case 0: 9182 return false; 9183 9184 default: 9185 if (!Args[1]->isDefaultArgument()) 9186 return false; 9187 9188 // fall through 9189 case 1: 9190 return !Args[0]->isDefaultArgument(); 9191 } 9192 9193 return false; 9194} 9195 9196ExprResult 9197Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, 9198 CXXConstructorDecl *Constructor, 9199 MultiExprArg ExprArgs, 9200 bool HadMultipleCandidates, 9201 bool RequiresZeroInit, 9202 unsigned ConstructKind, 9203 SourceRange ParenRange) { 9204 bool Elidable = false; 9205 9206 // C++0x [class.copy]p34: 9207 // When certain criteria are met, an implementation is allowed to 9208 // omit the copy/move construction of a class object, even if the 9209 // copy/move constructor and/or destructor for the object have 9210 // side effects. [...] 9211 // - when a temporary class object that has not been bound to a 9212 // reference (12.2) would be copied/moved to a class object 9213 // with the same cv-unqualified type, the copy/move operation 9214 // can be omitted by constructing the temporary object 9215 // directly into the target of the omitted copy/move 9216 if (ConstructKind == CXXConstructExpr::CK_Complete && 9217 Constructor->isCopyOrMoveConstructor() && hasOneRealArgument(ExprArgs)) { 9218 Expr *SubExpr = ExprArgs[0]; 9219 Elidable = SubExpr->isTemporaryObject(Context, Constructor->getParent()); 9220 } 9221 9222 return BuildCXXConstructExpr(ConstructLoc, DeclInitType, Constructor, 9223 Elidable, ExprArgs, HadMultipleCandidates, 9224 RequiresZeroInit, ConstructKind, ParenRange); 9225} 9226 9227/// BuildCXXConstructExpr - Creates a complete call to a constructor, 9228/// including handling of its default argument expressions. 9229ExprResult 9230Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, 9231 CXXConstructorDecl *Constructor, bool Elidable, 9232 MultiExprArg ExprArgs, 9233 bool HadMultipleCandidates, 9234 bool RequiresZeroInit, 9235 unsigned ConstructKind, 9236 SourceRange ParenRange) { 9237 MarkFunctionReferenced(ConstructLoc, Constructor); 9238 return Owned(CXXConstructExpr::Create(Context, DeclInitType, ConstructLoc, 9239 Constructor, Elidable, ExprArgs, 9240 HadMultipleCandidates, /*FIXME*/false, 9241 RequiresZeroInit, 9242 static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind), 9243 ParenRange)); 9244} 9245 9246bool Sema::InitializeVarWithConstructor(VarDecl *VD, 9247 CXXConstructorDecl *Constructor, 9248 MultiExprArg Exprs, 9249 bool HadMultipleCandidates) { 9250 // FIXME: Provide the correct paren SourceRange when available. 9251 ExprResult TempResult = 9252 BuildCXXConstructExpr(VD->getLocation(), VD->getType(), Constructor, 9253 Exprs, HadMultipleCandidates, false, 9254 CXXConstructExpr::CK_Complete, SourceRange()); 9255 if (TempResult.isInvalid()) 9256 return true; 9257 9258 Expr *Temp = TempResult.takeAs<Expr>(); 9259 CheckImplicitConversions(Temp, VD->getLocation()); 9260 MarkFunctionReferenced(VD->getLocation(), Constructor); 9261 Temp = MaybeCreateExprWithCleanups(Temp); 9262 VD->setInit(Temp); 9263 9264 return false; 9265} 9266 9267void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) { 9268 if (VD->isInvalidDecl()) return; 9269 9270 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl()); 9271 if (ClassDecl->isInvalidDecl()) return; 9272 if (ClassDecl->hasIrrelevantDestructor()) return; 9273 if (ClassDecl->isDependentContext()) return; 9274 9275 CXXDestructorDecl *Destructor = LookupDestructor(ClassDecl); 9276 MarkFunctionReferenced(VD->getLocation(), Destructor); 9277 CheckDestructorAccess(VD->getLocation(), Destructor, 9278 PDiag(diag::err_access_dtor_var) 9279 << VD->getDeclName() 9280 << VD->getType()); 9281 DiagnoseUseOfDecl(Destructor, VD->getLocation()); 9282 9283 if (!VD->hasGlobalStorage()) return; 9284 9285 // Emit warning for non-trivial dtor in global scope (a real global, 9286 // class-static, function-static). 9287 Diag(VD->getLocation(), diag::warn_exit_time_destructor); 9288 9289 // TODO: this should be re-enabled for static locals by !CXAAtExit 9290 if (!VD->isStaticLocal()) 9291 Diag(VD->getLocation(), diag::warn_global_destructor); 9292} 9293 9294/// \brief Given a constructor and the set of arguments provided for the 9295/// constructor, convert the arguments and add any required default arguments 9296/// to form a proper call to this constructor. 9297/// 9298/// \returns true if an error occurred, false otherwise. 9299bool 9300Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor, 9301 MultiExprArg ArgsPtr, 9302 SourceLocation Loc, 9303 SmallVectorImpl<Expr*> &ConvertedArgs, 9304 bool AllowExplicit) { 9305 // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall. 9306 unsigned NumArgs = ArgsPtr.size(); 9307 Expr **Args = ArgsPtr.data(); 9308 9309 const FunctionProtoType *Proto 9310 = Constructor->getType()->getAs<FunctionProtoType>(); 9311 assert(Proto && "Constructor without a prototype?"); 9312 unsigned NumArgsInProto = Proto->getNumArgs(); 9313 9314 // If too few arguments are available, we'll fill in the rest with defaults. 9315 if (NumArgs < NumArgsInProto) 9316 ConvertedArgs.reserve(NumArgsInProto); 9317 else 9318 ConvertedArgs.reserve(NumArgs); 9319 9320 VariadicCallType CallType = 9321 Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply; 9322 SmallVector<Expr *, 8> AllArgs; 9323 bool Invalid = GatherArgumentsForCall(Loc, Constructor, 9324 Proto, 0, Args, NumArgs, AllArgs, 9325 CallType, AllowExplicit); 9326 ConvertedArgs.append(AllArgs.begin(), AllArgs.end()); 9327 9328 DiagnoseSentinelCalls(Constructor, Loc, AllArgs.data(), AllArgs.size()); 9329 9330 CheckConstructorCall(Constructor, AllArgs.data(), AllArgs.size(), 9331 Proto, Loc); 9332 9333 return Invalid; 9334} 9335 9336static inline bool 9337CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef, 9338 const FunctionDecl *FnDecl) { 9339 const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext(); 9340 if (isa<NamespaceDecl>(DC)) { 9341 return SemaRef.Diag(FnDecl->getLocation(), 9342 diag::err_operator_new_delete_declared_in_namespace) 9343 << FnDecl->getDeclName(); 9344 } 9345 9346 if (isa<TranslationUnitDecl>(DC) && 9347 FnDecl->getStorageClass() == SC_Static) { 9348 return SemaRef.Diag(FnDecl->getLocation(), 9349 diag::err_operator_new_delete_declared_static) 9350 << FnDecl->getDeclName(); 9351 } 9352 9353 return false; 9354} 9355 9356static inline bool 9357CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl, 9358 CanQualType ExpectedResultType, 9359 CanQualType ExpectedFirstParamType, 9360 unsigned DependentParamTypeDiag, 9361 unsigned InvalidParamTypeDiag) { 9362 QualType ResultType = 9363 FnDecl->getType()->getAs<FunctionType>()->getResultType(); 9364 9365 // Check that the result type is not dependent. 9366 if (ResultType->isDependentType()) 9367 return SemaRef.Diag(FnDecl->getLocation(), 9368 diag::err_operator_new_delete_dependent_result_type) 9369 << FnDecl->getDeclName() << ExpectedResultType; 9370 9371 // Check that the result type is what we expect. 9372 if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType) 9373 return SemaRef.Diag(FnDecl->getLocation(), 9374 diag::err_operator_new_delete_invalid_result_type) 9375 << FnDecl->getDeclName() << ExpectedResultType; 9376 9377 // A function template must have at least 2 parameters. 9378 if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2) 9379 return SemaRef.Diag(FnDecl->getLocation(), 9380 diag::err_operator_new_delete_template_too_few_parameters) 9381 << FnDecl->getDeclName(); 9382 9383 // The function decl must have at least 1 parameter. 9384 if (FnDecl->getNumParams() == 0) 9385 return SemaRef.Diag(FnDecl->getLocation(), 9386 diag::err_operator_new_delete_too_few_parameters) 9387 << FnDecl->getDeclName(); 9388 9389 // Check the first parameter type is not dependent. 9390 QualType FirstParamType = FnDecl->getParamDecl(0)->getType(); 9391 if (FirstParamType->isDependentType()) 9392 return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag) 9393 << FnDecl->getDeclName() << ExpectedFirstParamType; 9394 9395 // Check that the first parameter type is what we expect. 9396 if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() != 9397 ExpectedFirstParamType) 9398 return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag) 9399 << FnDecl->getDeclName() << ExpectedFirstParamType; 9400 9401 return false; 9402} 9403 9404static bool 9405CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) { 9406 // C++ [basic.stc.dynamic.allocation]p1: 9407 // A program is ill-formed if an allocation function is declared in a 9408 // namespace scope other than global scope or declared static in global 9409 // scope. 9410 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl)) 9411 return true; 9412 9413 CanQualType SizeTy = 9414 SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType()); 9415 9416 // C++ [basic.stc.dynamic.allocation]p1: 9417 // The return type shall be void*. The first parameter shall have type 9418 // std::size_t. 9419 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy, 9420 SizeTy, 9421 diag::err_operator_new_dependent_param_type, 9422 diag::err_operator_new_param_type)) 9423 return true; 9424 9425 // C++ [basic.stc.dynamic.allocation]p1: 9426 // The first parameter shall not have an associated default argument. 9427 if (FnDecl->getParamDecl(0)->hasDefaultArg()) 9428 return SemaRef.Diag(FnDecl->getLocation(), 9429 diag::err_operator_new_default_arg) 9430 << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange(); 9431 9432 return false; 9433} 9434 9435static bool 9436CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) { 9437 // C++ [basic.stc.dynamic.deallocation]p1: 9438 // A program is ill-formed if deallocation functions are declared in a 9439 // namespace scope other than global scope or declared static in global 9440 // scope. 9441 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl)) 9442 return true; 9443 9444 // C++ [basic.stc.dynamic.deallocation]p2: 9445 // Each deallocation function shall return void and its first parameter 9446 // shall be void*. 9447 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidTy, 9448 SemaRef.Context.VoidPtrTy, 9449 diag::err_operator_delete_dependent_param_type, 9450 diag::err_operator_delete_param_type)) 9451 return true; 9452 9453 return false; 9454} 9455 9456/// CheckOverloadedOperatorDeclaration - Check whether the declaration 9457/// of this overloaded operator is well-formed. If so, returns false; 9458/// otherwise, emits appropriate diagnostics and returns true. 9459bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) { 9460 assert(FnDecl && FnDecl->isOverloadedOperator() && 9461 "Expected an overloaded operator declaration"); 9462 9463 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator(); 9464 9465 // C++ [over.oper]p5: 9466 // The allocation and deallocation functions, operator new, 9467 // operator new[], operator delete and operator delete[], are 9468 // described completely in 3.7.3. The attributes and restrictions 9469 // found in the rest of this subclause do not apply to them unless 9470 // explicitly stated in 3.7.3. 9471 if (Op == OO_Delete || Op == OO_Array_Delete) 9472 return CheckOperatorDeleteDeclaration(*this, FnDecl); 9473 9474 if (Op == OO_New || Op == OO_Array_New) 9475 return CheckOperatorNewDeclaration(*this, FnDecl); 9476 9477 // C++ [over.oper]p6: 9478 // An operator function shall either be a non-static member 9479 // function or be a non-member function and have at least one 9480 // parameter whose type is a class, a reference to a class, an 9481 // enumeration, or a reference to an enumeration. 9482 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) { 9483 if (MethodDecl->isStatic()) 9484 return Diag(FnDecl->getLocation(), 9485 diag::err_operator_overload_static) << FnDecl->getDeclName(); 9486 } else { 9487 bool ClassOrEnumParam = false; 9488 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(), 9489 ParamEnd = FnDecl->param_end(); 9490 Param != ParamEnd; ++Param) { 9491 QualType ParamType = (*Param)->getType().getNonReferenceType(); 9492 if (ParamType->isDependentType() || ParamType->isRecordType() || 9493 ParamType->isEnumeralType()) { 9494 ClassOrEnumParam = true; 9495 break; 9496 } 9497 } 9498 9499 if (!ClassOrEnumParam) 9500 return Diag(FnDecl->getLocation(), 9501 diag::err_operator_overload_needs_class_or_enum) 9502 << FnDecl->getDeclName(); 9503 } 9504 9505 // C++ [over.oper]p8: 9506 // An operator function cannot have default arguments (8.3.6), 9507 // except where explicitly stated below. 9508 // 9509 // Only the function-call operator allows default arguments 9510 // (C++ [over.call]p1). 9511 if (Op != OO_Call) { 9512 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(); 9513 Param != FnDecl->param_end(); ++Param) { 9514 if ((*Param)->hasDefaultArg()) 9515 return Diag((*Param)->getLocation(), 9516 diag::err_operator_overload_default_arg) 9517 << FnDecl->getDeclName() << (*Param)->getDefaultArgRange(); 9518 } 9519 } 9520 9521 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = { 9522 { false, false, false } 9523#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 9524 , { Unary, Binary, MemberOnly } 9525#include "clang/Basic/OperatorKinds.def" 9526 }; 9527 9528 bool CanBeUnaryOperator = OperatorUses[Op][0]; 9529 bool CanBeBinaryOperator = OperatorUses[Op][1]; 9530 bool MustBeMemberOperator = OperatorUses[Op][2]; 9531 9532 // C++ [over.oper]p8: 9533 // [...] Operator functions cannot have more or fewer parameters 9534 // than the number required for the corresponding operator, as 9535 // described in the rest of this subclause. 9536 unsigned NumParams = FnDecl->getNumParams() 9537 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0); 9538 if (Op != OO_Call && 9539 ((NumParams == 1 && !CanBeUnaryOperator) || 9540 (NumParams == 2 && !CanBeBinaryOperator) || 9541 (NumParams < 1) || (NumParams > 2))) { 9542 // We have the wrong number of parameters. 9543 unsigned ErrorKind; 9544 if (CanBeUnaryOperator && CanBeBinaryOperator) { 9545 ErrorKind = 2; // 2 -> unary or binary. 9546 } else if (CanBeUnaryOperator) { 9547 ErrorKind = 0; // 0 -> unary 9548 } else { 9549 assert(CanBeBinaryOperator && 9550 "All non-call overloaded operators are unary or binary!"); 9551 ErrorKind = 1; // 1 -> binary 9552 } 9553 9554 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be) 9555 << FnDecl->getDeclName() << NumParams << ErrorKind; 9556 } 9557 9558 // Overloaded operators other than operator() cannot be variadic. 9559 if (Op != OO_Call && 9560 FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) { 9561 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic) 9562 << FnDecl->getDeclName(); 9563 } 9564 9565 // Some operators must be non-static member functions. 9566 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) { 9567 return Diag(FnDecl->getLocation(), 9568 diag::err_operator_overload_must_be_member) 9569 << FnDecl->getDeclName(); 9570 } 9571 9572 // C++ [over.inc]p1: 9573 // The user-defined function called operator++ implements the 9574 // prefix and postfix ++ operator. If this function is a member 9575 // function with no parameters, or a non-member function with one 9576 // parameter of class or enumeration type, it defines the prefix 9577 // increment operator ++ for objects of that type. If the function 9578 // is a member function with one parameter (which shall be of type 9579 // int) or a non-member function with two parameters (the second 9580 // of which shall be of type int), it defines the postfix 9581 // increment operator ++ for objects of that type. 9582 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) { 9583 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1); 9584 bool ParamIsInt = false; 9585 if (const BuiltinType *BT = LastParam->getType()->getAs<BuiltinType>()) 9586 ParamIsInt = BT->getKind() == BuiltinType::Int; 9587 9588 if (!ParamIsInt) 9589 return Diag(LastParam->getLocation(), 9590 diag::err_operator_overload_post_incdec_must_be_int) 9591 << LastParam->getType() << (Op == OO_MinusMinus); 9592 } 9593 9594 return false; 9595} 9596 9597/// CheckLiteralOperatorDeclaration - Check whether the declaration 9598/// of this literal operator function is well-formed. If so, returns 9599/// false; otherwise, emits appropriate diagnostics and returns true. 9600bool Sema::CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl) { 9601 if (isa<CXXMethodDecl>(FnDecl)) { 9602 Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace) 9603 << FnDecl->getDeclName(); 9604 return true; 9605 } 9606 9607 if (FnDecl->isExternC()) { 9608 Diag(FnDecl->getLocation(), diag::err_literal_operator_extern_c); 9609 return true; 9610 } 9611 9612 bool Valid = false; 9613 9614 // This might be the definition of a literal operator template. 9615 FunctionTemplateDecl *TpDecl = FnDecl->getDescribedFunctionTemplate(); 9616 // This might be a specialization of a literal operator template. 9617 if (!TpDecl) 9618 TpDecl = FnDecl->getPrimaryTemplate(); 9619 9620 // template <char...> type operator "" name() is the only valid template 9621 // signature, and the only valid signature with no parameters. 9622 if (TpDecl) { 9623 if (FnDecl->param_size() == 0) { 9624 // Must have only one template parameter 9625 TemplateParameterList *Params = TpDecl->getTemplateParameters(); 9626 if (Params->size() == 1) { 9627 NonTypeTemplateParmDecl *PmDecl = 9628 dyn_cast<NonTypeTemplateParmDecl>(Params->getParam(0)); 9629 9630 // The template parameter must be a char parameter pack. 9631 if (PmDecl && PmDecl->isTemplateParameterPack() && 9632 Context.hasSameType(PmDecl->getType(), Context.CharTy)) 9633 Valid = true; 9634 } 9635 } 9636 } else if (FnDecl->param_size()) { 9637 // Check the first parameter 9638 FunctionDecl::param_iterator Param = FnDecl->param_begin(); 9639 9640 QualType T = (*Param)->getType().getUnqualifiedType(); 9641 9642 // unsigned long long int, long double, and any character type are allowed 9643 // as the only parameters. 9644 if (Context.hasSameType(T, Context.UnsignedLongLongTy) || 9645 Context.hasSameType(T, Context.LongDoubleTy) || 9646 Context.hasSameType(T, Context.CharTy) || 9647 Context.hasSameType(T, Context.WCharTy) || 9648 Context.hasSameType(T, Context.Char16Ty) || 9649 Context.hasSameType(T, Context.Char32Ty)) { 9650 if (++Param == FnDecl->param_end()) 9651 Valid = true; 9652 goto FinishedParams; 9653 } 9654 9655 // Otherwise it must be a pointer to const; let's strip those qualifiers. 9656 const PointerType *PT = T->getAs<PointerType>(); 9657 if (!PT) 9658 goto FinishedParams; 9659 T = PT->getPointeeType(); 9660 if (!T.isConstQualified() || T.isVolatileQualified()) 9661 goto FinishedParams; 9662 T = T.getUnqualifiedType(); 9663 9664 // Move on to the second parameter; 9665 ++Param; 9666 9667 // If there is no second parameter, the first must be a const char * 9668 if (Param == FnDecl->param_end()) { 9669 if (Context.hasSameType(T, Context.CharTy)) 9670 Valid = true; 9671 goto FinishedParams; 9672 } 9673 9674 // const char *, const wchar_t*, const char16_t*, and const char32_t* 9675 // are allowed as the first parameter to a two-parameter function 9676 if (!(Context.hasSameType(T, Context.CharTy) || 9677 Context.hasSameType(T, Context.WCharTy) || 9678 Context.hasSameType(T, Context.Char16Ty) || 9679 Context.hasSameType(T, Context.Char32Ty))) 9680 goto FinishedParams; 9681 9682 // The second and final parameter must be an std::size_t 9683 T = (*Param)->getType().getUnqualifiedType(); 9684 if (Context.hasSameType(T, Context.getSizeType()) && 9685 ++Param == FnDecl->param_end()) 9686 Valid = true; 9687 } 9688 9689 // FIXME: This diagnostic is absolutely terrible. 9690FinishedParams: 9691 if (!Valid) { 9692 Diag(FnDecl->getLocation(), diag::err_literal_operator_params) 9693 << FnDecl->getDeclName(); 9694 return true; 9695 } 9696 9697 // A parameter-declaration-clause containing a default argument is not 9698 // equivalent to any of the permitted forms. 9699 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(), 9700 ParamEnd = FnDecl->param_end(); 9701 Param != ParamEnd; ++Param) { 9702 if ((*Param)->hasDefaultArg()) { 9703 Diag((*Param)->getDefaultArgRange().getBegin(), 9704 diag::err_literal_operator_default_argument) 9705 << (*Param)->getDefaultArgRange(); 9706 break; 9707 } 9708 } 9709 9710 StringRef LiteralName 9711 = FnDecl->getDeclName().getCXXLiteralIdentifier()->getName(); 9712 if (LiteralName[0] != '_') { 9713 // C++11 [usrlit.suffix]p1: 9714 // Literal suffix identifiers that do not start with an underscore 9715 // are reserved for future standardization. 9716 Diag(FnDecl->getLocation(), diag::warn_user_literal_reserved); 9717 } 9718 9719 return false; 9720} 9721 9722/// ActOnStartLinkageSpecification - Parsed the beginning of a C++ 9723/// linkage specification, including the language and (if present) 9724/// the '{'. ExternLoc is the location of the 'extern', LangLoc is 9725/// the location of the language string literal, which is provided 9726/// by Lang/StrSize. LBraceLoc, if valid, provides the location of 9727/// the '{' brace. Otherwise, this linkage specification does not 9728/// have any braces. 9729Decl *Sema::ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc, 9730 SourceLocation LangLoc, 9731 StringRef Lang, 9732 SourceLocation LBraceLoc) { 9733 LinkageSpecDecl::LanguageIDs Language; 9734 if (Lang == "\"C\"") 9735 Language = LinkageSpecDecl::lang_c; 9736 else if (Lang == "\"C++\"") 9737 Language = LinkageSpecDecl::lang_cxx; 9738 else { 9739 Diag(LangLoc, diag::err_bad_language); 9740 return 0; 9741 } 9742 9743 // FIXME: Add all the various semantics of linkage specifications 9744 9745 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext, 9746 ExternLoc, LangLoc, Language); 9747 CurContext->addDecl(D); 9748 PushDeclContext(S, D); 9749 return D; 9750} 9751 9752/// ActOnFinishLinkageSpecification - Complete the definition of 9753/// the C++ linkage specification LinkageSpec. If RBraceLoc is 9754/// valid, it's the position of the closing '}' brace in a linkage 9755/// specification that uses braces. 9756Decl *Sema::ActOnFinishLinkageSpecification(Scope *S, 9757 Decl *LinkageSpec, 9758 SourceLocation RBraceLoc) { 9759 if (LinkageSpec) { 9760 if (RBraceLoc.isValid()) { 9761 LinkageSpecDecl* LSDecl = cast<LinkageSpecDecl>(LinkageSpec); 9762 LSDecl->setRBraceLoc(RBraceLoc); 9763 } 9764 PopDeclContext(); 9765 } 9766 return LinkageSpec; 9767} 9768 9769/// \brief Perform semantic analysis for the variable declaration that 9770/// occurs within a C++ catch clause, returning the newly-created 9771/// variable. 9772VarDecl *Sema::BuildExceptionDeclaration(Scope *S, 9773 TypeSourceInfo *TInfo, 9774 SourceLocation StartLoc, 9775 SourceLocation Loc, 9776 IdentifierInfo *Name) { 9777 bool Invalid = false; 9778 QualType ExDeclType = TInfo->getType(); 9779 9780 // Arrays and functions decay. 9781 if (ExDeclType->isArrayType()) 9782 ExDeclType = Context.getArrayDecayedType(ExDeclType); 9783 else if (ExDeclType->isFunctionType()) 9784 ExDeclType = Context.getPointerType(ExDeclType); 9785 9786 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type. 9787 // The exception-declaration shall not denote a pointer or reference to an 9788 // incomplete type, other than [cv] void*. 9789 // N2844 forbids rvalue references. 9790 if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) { 9791 Diag(Loc, diag::err_catch_rvalue_ref); 9792 Invalid = true; 9793 } 9794 9795 QualType BaseType = ExDeclType; 9796 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference 9797 unsigned DK = diag::err_catch_incomplete; 9798 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) { 9799 BaseType = Ptr->getPointeeType(); 9800 Mode = 1; 9801 DK = diag::err_catch_incomplete_ptr; 9802 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) { 9803 // For the purpose of error recovery, we treat rvalue refs like lvalue refs. 9804 BaseType = Ref->getPointeeType(); 9805 Mode = 2; 9806 DK = diag::err_catch_incomplete_ref; 9807 } 9808 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) && 9809 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK)) 9810 Invalid = true; 9811 9812 if (!Invalid && !ExDeclType->isDependentType() && 9813 RequireNonAbstractType(Loc, ExDeclType, 9814 diag::err_abstract_type_in_decl, 9815 AbstractVariableType)) 9816 Invalid = true; 9817 9818 // Only the non-fragile NeXT runtime currently supports C++ catches 9819 // of ObjC types, and no runtime supports catching ObjC types by value. 9820 if (!Invalid && getLangOpts().ObjC1) { 9821 QualType T = ExDeclType; 9822 if (const ReferenceType *RT = T->getAs<ReferenceType>()) 9823 T = RT->getPointeeType(); 9824 9825 if (T->isObjCObjectType()) { 9826 Diag(Loc, diag::err_objc_object_catch); 9827 Invalid = true; 9828 } else if (T->isObjCObjectPointerType()) { 9829 // FIXME: should this be a test for macosx-fragile specifically? 9830 if (getLangOpts().ObjCRuntime.isFragile()) 9831 Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile); 9832 } 9833 } 9834 9835 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name, 9836 ExDeclType, TInfo, SC_None, SC_None); 9837 ExDecl->setExceptionVariable(true); 9838 9839 // In ARC, infer 'retaining' for variables of retainable type. 9840 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(ExDecl)) 9841 Invalid = true; 9842 9843 if (!Invalid && !ExDeclType->isDependentType()) { 9844 if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) { 9845 // C++ [except.handle]p16: 9846 // The object declared in an exception-declaration or, if the 9847 // exception-declaration does not specify a name, a temporary (12.2) is 9848 // copy-initialized (8.5) from the exception object. [...] 9849 // The object is destroyed when the handler exits, after the destruction 9850 // of any automatic objects initialized within the handler. 9851 // 9852 // We just pretend to initialize the object with itself, then make sure 9853 // it can be destroyed later. 9854 QualType initType = ExDeclType; 9855 9856 InitializedEntity entity = 9857 InitializedEntity::InitializeVariable(ExDecl); 9858 InitializationKind initKind = 9859 InitializationKind::CreateCopy(Loc, SourceLocation()); 9860 9861 Expr *opaqueValue = 9862 new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary); 9863 InitializationSequence sequence(*this, entity, initKind, &opaqueValue, 1); 9864 ExprResult result = sequence.Perform(*this, entity, initKind, 9865 MultiExprArg(&opaqueValue, 1)); 9866 if (result.isInvalid()) 9867 Invalid = true; 9868 else { 9869 // If the constructor used was non-trivial, set this as the 9870 // "initializer". 9871 CXXConstructExpr *construct = cast<CXXConstructExpr>(result.take()); 9872 if (!construct->getConstructor()->isTrivial()) { 9873 Expr *init = MaybeCreateExprWithCleanups(construct); 9874 ExDecl->setInit(init); 9875 } 9876 9877 // And make sure it's destructable. 9878 FinalizeVarWithDestructor(ExDecl, recordType); 9879 } 9880 } 9881 } 9882 9883 if (Invalid) 9884 ExDecl->setInvalidDecl(); 9885 9886 return ExDecl; 9887} 9888 9889/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch 9890/// handler. 9891Decl *Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) { 9892 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 9893 bool Invalid = D.isInvalidType(); 9894 9895 // Check for unexpanded parameter packs. 9896 if (TInfo && DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 9897 UPPC_ExceptionType)) { 9898 TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy, 9899 D.getIdentifierLoc()); 9900 Invalid = true; 9901 } 9902 9903 IdentifierInfo *II = D.getIdentifier(); 9904 if (NamedDecl *PrevDecl = LookupSingleName(S, II, D.getIdentifierLoc(), 9905 LookupOrdinaryName, 9906 ForRedeclaration)) { 9907 // The scope should be freshly made just for us. There is just no way 9908 // it contains any previous declaration. 9909 assert(!S->isDeclScope(PrevDecl)); 9910 if (PrevDecl->isTemplateParameter()) { 9911 // Maybe we will complain about the shadowed template parameter. 9912 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 9913 PrevDecl = 0; 9914 } 9915 } 9916 9917 if (D.getCXXScopeSpec().isSet() && !Invalid) { 9918 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator) 9919 << D.getCXXScopeSpec().getRange(); 9920 Invalid = true; 9921 } 9922 9923 VarDecl *ExDecl = BuildExceptionDeclaration(S, TInfo, 9924 D.getLocStart(), 9925 D.getIdentifierLoc(), 9926 D.getIdentifier()); 9927 if (Invalid) 9928 ExDecl->setInvalidDecl(); 9929 9930 // Add the exception declaration into this scope. 9931 if (II) 9932 PushOnScopeChains(ExDecl, S); 9933 else 9934 CurContext->addDecl(ExDecl); 9935 9936 ProcessDeclAttributes(S, ExDecl, D); 9937 return ExDecl; 9938} 9939 9940Decl *Sema::ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc, 9941 Expr *AssertExpr, 9942 Expr *AssertMessageExpr, 9943 SourceLocation RParenLoc) { 9944 StringLiteral *AssertMessage = cast<StringLiteral>(AssertMessageExpr); 9945 9946 if (DiagnoseUnexpandedParameterPack(AssertExpr, UPPC_StaticAssertExpression)) 9947 return 0; 9948 9949 return BuildStaticAssertDeclaration(StaticAssertLoc, AssertExpr, 9950 AssertMessage, RParenLoc, false); 9951} 9952 9953Decl *Sema::BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, 9954 Expr *AssertExpr, 9955 StringLiteral *AssertMessage, 9956 SourceLocation RParenLoc, 9957 bool Failed) { 9958 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent() && 9959 !Failed) { 9960 // In a static_assert-declaration, the constant-expression shall be a 9961 // constant expression that can be contextually converted to bool. 9962 ExprResult Converted = PerformContextuallyConvertToBool(AssertExpr); 9963 if (Converted.isInvalid()) 9964 Failed = true; 9965 9966 llvm::APSInt Cond; 9967 if (!Failed && VerifyIntegerConstantExpression(Converted.get(), &Cond, 9968 diag::err_static_assert_expression_is_not_constant, 9969 /*AllowFold=*/false).isInvalid()) 9970 Failed = true; 9971 9972 if (!Failed && !Cond) { 9973 llvm::SmallString<256> MsgBuffer; 9974 llvm::raw_svector_ostream Msg(MsgBuffer); 9975 AssertMessage->printPretty(Msg, 0, getPrintingPolicy()); 9976 Diag(StaticAssertLoc, diag::err_static_assert_failed) 9977 << Msg.str() << AssertExpr->getSourceRange(); 9978 Failed = true; 9979 } 9980 } 9981 9982 Decl *Decl = StaticAssertDecl::Create(Context, CurContext, StaticAssertLoc, 9983 AssertExpr, AssertMessage, RParenLoc, 9984 Failed); 9985 9986 CurContext->addDecl(Decl); 9987 return Decl; 9988} 9989 9990/// \brief Perform semantic analysis of the given friend type declaration. 9991/// 9992/// \returns A friend declaration that. 9993FriendDecl *Sema::CheckFriendTypeDecl(SourceLocation LocStart, 9994 SourceLocation FriendLoc, 9995 TypeSourceInfo *TSInfo) { 9996 assert(TSInfo && "NULL TypeSourceInfo for friend type declaration"); 9997 9998 QualType T = TSInfo->getType(); 9999 SourceRange TypeRange = TSInfo->getTypeLoc().getLocalSourceRange(); 10000 10001 // C++03 [class.friend]p2: 10002 // An elaborated-type-specifier shall be used in a friend declaration 10003 // for a class.* 10004 // 10005 // * The class-key of the elaborated-type-specifier is required. 10006 if (!ActiveTemplateInstantiations.empty()) { 10007 // Do not complain about the form of friend template types during 10008 // template instantiation; we will already have complained when the 10009 // template was declared. 10010 } else if (!T->isElaboratedTypeSpecifier()) { 10011 // If we evaluated the type to a record type, suggest putting 10012 // a tag in front. 10013 if (const RecordType *RT = T->getAs<RecordType>()) { 10014 RecordDecl *RD = RT->getDecl(); 10015 10016 std::string InsertionText = std::string(" ") + RD->getKindName(); 10017 10018 Diag(TypeRange.getBegin(), 10019 getLangOpts().CPlusPlus0x ? 10020 diag::warn_cxx98_compat_unelaborated_friend_type : 10021 diag::ext_unelaborated_friend_type) 10022 << (unsigned) RD->getTagKind() 10023 << T 10024 << FixItHint::CreateInsertion(PP.getLocForEndOfToken(FriendLoc), 10025 InsertionText); 10026 } else { 10027 Diag(FriendLoc, 10028 getLangOpts().CPlusPlus0x ? 10029 diag::warn_cxx98_compat_nonclass_type_friend : 10030 diag::ext_nonclass_type_friend) 10031 << T 10032 << TypeRange; 10033 } 10034 } else if (T->getAs<EnumType>()) { 10035 Diag(FriendLoc, 10036 getLangOpts().CPlusPlus0x ? 10037 diag::warn_cxx98_compat_enum_friend : 10038 diag::ext_enum_friend) 10039 << T 10040 << TypeRange; 10041 } 10042 10043 // C++11 [class.friend]p3: 10044 // A friend declaration that does not declare a function shall have one 10045 // of the following forms: 10046 // friend elaborated-type-specifier ; 10047 // friend simple-type-specifier ; 10048 // friend typename-specifier ; 10049 if (getLangOpts().CPlusPlus0x && LocStart != FriendLoc) 10050 Diag(FriendLoc, diag::err_friend_not_first_in_declaration) << T; 10051 10052 // If the type specifier in a friend declaration designates a (possibly 10053 // cv-qualified) class type, that class is declared as a friend; otherwise, 10054 // the friend declaration is ignored. 10055 return FriendDecl::Create(Context, CurContext, LocStart, TSInfo, FriendLoc); 10056} 10057 10058/// Handle a friend tag declaration where the scope specifier was 10059/// templated. 10060Decl *Sema::ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc, 10061 unsigned TagSpec, SourceLocation TagLoc, 10062 CXXScopeSpec &SS, 10063 IdentifierInfo *Name, SourceLocation NameLoc, 10064 AttributeList *Attr, 10065 MultiTemplateParamsArg TempParamLists) { 10066 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec); 10067 10068 bool isExplicitSpecialization = false; 10069 bool Invalid = false; 10070 10071 if (TemplateParameterList *TemplateParams 10072 = MatchTemplateParametersToScopeSpecifier(TagLoc, NameLoc, SS, 10073 TempParamLists.data(), 10074 TempParamLists.size(), 10075 /*friend*/ true, 10076 isExplicitSpecialization, 10077 Invalid)) { 10078 if (TemplateParams->size() > 0) { 10079 // This is a declaration of a class template. 10080 if (Invalid) 10081 return 0; 10082 10083 return CheckClassTemplate(S, TagSpec, TUK_Friend, TagLoc, 10084 SS, Name, NameLoc, Attr, 10085 TemplateParams, AS_public, 10086 /*ModulePrivateLoc=*/SourceLocation(), 10087 TempParamLists.size() - 1, 10088 TempParamLists.data()).take(); 10089 } else { 10090 // The "template<>" header is extraneous. 10091 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams) 10092 << TypeWithKeyword::getTagTypeKindName(Kind) << Name; 10093 isExplicitSpecialization = true; 10094 } 10095 } 10096 10097 if (Invalid) return 0; 10098 10099 bool isAllExplicitSpecializations = true; 10100 for (unsigned I = TempParamLists.size(); I-- > 0; ) { 10101 if (TempParamLists[I]->size()) { 10102 isAllExplicitSpecializations = false; 10103 break; 10104 } 10105 } 10106 10107 // FIXME: don't ignore attributes. 10108 10109 // If it's explicit specializations all the way down, just forget 10110 // about the template header and build an appropriate non-templated 10111 // friend. TODO: for source fidelity, remember the headers. 10112 if (isAllExplicitSpecializations) { 10113 if (SS.isEmpty()) { 10114 bool Owned = false; 10115 bool IsDependent = false; 10116 return ActOnTag(S, TagSpec, TUK_Friend, TagLoc, SS, Name, NameLoc, 10117 Attr, AS_public, 10118 /*ModulePrivateLoc=*/SourceLocation(), 10119 MultiTemplateParamsArg(), Owned, IsDependent, 10120 /*ScopedEnumKWLoc=*/SourceLocation(), 10121 /*ScopedEnumUsesClassTag=*/false, 10122 /*UnderlyingType=*/TypeResult()); 10123 } 10124 10125 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context); 10126 ElaboratedTypeKeyword Keyword 10127 = TypeWithKeyword::getKeywordForTagTypeKind(Kind); 10128 QualType T = CheckTypenameType(Keyword, TagLoc, QualifierLoc, 10129 *Name, NameLoc); 10130 if (T.isNull()) 10131 return 0; 10132 10133 TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T); 10134 if (isa<DependentNameType>(T)) { 10135 DependentNameTypeLoc TL = cast<DependentNameTypeLoc>(TSI->getTypeLoc()); 10136 TL.setElaboratedKeywordLoc(TagLoc); 10137 TL.setQualifierLoc(QualifierLoc); 10138 TL.setNameLoc(NameLoc); 10139 } else { 10140 ElaboratedTypeLoc TL = cast<ElaboratedTypeLoc>(TSI->getTypeLoc()); 10141 TL.setElaboratedKeywordLoc(TagLoc); 10142 TL.setQualifierLoc(QualifierLoc); 10143 cast<TypeSpecTypeLoc>(TL.getNamedTypeLoc()).setNameLoc(NameLoc); 10144 } 10145 10146 FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc, 10147 TSI, FriendLoc); 10148 Friend->setAccess(AS_public); 10149 CurContext->addDecl(Friend); 10150 return Friend; 10151 } 10152 10153 assert(SS.isNotEmpty() && "valid templated tag with no SS and no direct?"); 10154 10155 10156 10157 // Handle the case of a templated-scope friend class. e.g. 10158 // template <class T> class A<T>::B; 10159 // FIXME: we don't support these right now. 10160 ElaboratedTypeKeyword ETK = TypeWithKeyword::getKeywordForTagTypeKind(Kind); 10161 QualType T = Context.getDependentNameType(ETK, SS.getScopeRep(), Name); 10162 TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T); 10163 DependentNameTypeLoc TL = cast<DependentNameTypeLoc>(TSI->getTypeLoc()); 10164 TL.setElaboratedKeywordLoc(TagLoc); 10165 TL.setQualifierLoc(SS.getWithLocInContext(Context)); 10166 TL.setNameLoc(NameLoc); 10167 10168 FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc, 10169 TSI, FriendLoc); 10170 Friend->setAccess(AS_public); 10171 Friend->setUnsupportedFriend(true); 10172 CurContext->addDecl(Friend); 10173 return Friend; 10174} 10175 10176 10177/// Handle a friend type declaration. This works in tandem with 10178/// ActOnTag. 10179/// 10180/// Notes on friend class templates: 10181/// 10182/// We generally treat friend class declarations as if they were 10183/// declaring a class. So, for example, the elaborated type specifier 10184/// in a friend declaration is required to obey the restrictions of a 10185/// class-head (i.e. no typedefs in the scope chain), template 10186/// parameters are required to match up with simple template-ids, &c. 10187/// However, unlike when declaring a template specialization, it's 10188/// okay to refer to a template specialization without an empty 10189/// template parameter declaration, e.g. 10190/// friend class A<T>::B<unsigned>; 10191/// We permit this as a special case; if there are any template 10192/// parameters present at all, require proper matching, i.e. 10193/// template <> template \<class T> friend class A<int>::B; 10194Decl *Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, 10195 MultiTemplateParamsArg TempParams) { 10196 SourceLocation Loc = DS.getLocStart(); 10197 10198 assert(DS.isFriendSpecified()); 10199 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified); 10200 10201 // Try to convert the decl specifier to a type. This works for 10202 // friend templates because ActOnTag never produces a ClassTemplateDecl 10203 // for a TUK_Friend. 10204 Declarator TheDeclarator(DS, Declarator::MemberContext); 10205 TypeSourceInfo *TSI = GetTypeForDeclarator(TheDeclarator, S); 10206 QualType T = TSI->getType(); 10207 if (TheDeclarator.isInvalidType()) 10208 return 0; 10209 10210 if (DiagnoseUnexpandedParameterPack(Loc, TSI, UPPC_FriendDeclaration)) 10211 return 0; 10212 10213 // This is definitely an error in C++98. It's probably meant to 10214 // be forbidden in C++0x, too, but the specification is just 10215 // poorly written. 10216 // 10217 // The problem is with declarations like the following: 10218 // template <T> friend A<T>::foo; 10219 // where deciding whether a class C is a friend or not now hinges 10220 // on whether there exists an instantiation of A that causes 10221 // 'foo' to equal C. There are restrictions on class-heads 10222 // (which we declare (by fiat) elaborated friend declarations to 10223 // be) that makes this tractable. 10224 // 10225 // FIXME: handle "template <> friend class A<T>;", which 10226 // is possibly well-formed? Who even knows? 10227 if (TempParams.size() && !T->isElaboratedTypeSpecifier()) { 10228 Diag(Loc, diag::err_tagless_friend_type_template) 10229 << DS.getSourceRange(); 10230 return 0; 10231 } 10232 10233 // C++98 [class.friend]p1: A friend of a class is a function 10234 // or class that is not a member of the class . . . 10235 // This is fixed in DR77, which just barely didn't make the C++03 10236 // deadline. It's also a very silly restriction that seriously 10237 // affects inner classes and which nobody else seems to implement; 10238 // thus we never diagnose it, not even in -pedantic. 10239 // 10240 // But note that we could warn about it: it's always useless to 10241 // friend one of your own members (it's not, however, worthless to 10242 // friend a member of an arbitrary specialization of your template). 10243 10244 Decl *D; 10245 if (unsigned NumTempParamLists = TempParams.size()) 10246 D = FriendTemplateDecl::Create(Context, CurContext, Loc, 10247 NumTempParamLists, 10248 TempParams.data(), 10249 TSI, 10250 DS.getFriendSpecLoc()); 10251 else 10252 D = CheckFriendTypeDecl(Loc, DS.getFriendSpecLoc(), TSI); 10253 10254 if (!D) 10255 return 0; 10256 10257 D->setAccess(AS_public); 10258 CurContext->addDecl(D); 10259 10260 return D; 10261} 10262 10263Decl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D, 10264 MultiTemplateParamsArg TemplateParams) { 10265 const DeclSpec &DS = D.getDeclSpec(); 10266 10267 assert(DS.isFriendSpecified()); 10268 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified); 10269 10270 SourceLocation Loc = D.getIdentifierLoc(); 10271 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 10272 10273 // C++ [class.friend]p1 10274 // A friend of a class is a function or class.... 10275 // Note that this sees through typedefs, which is intended. 10276 // It *doesn't* see through dependent types, which is correct 10277 // according to [temp.arg.type]p3: 10278 // If a declaration acquires a function type through a 10279 // type dependent on a template-parameter and this causes 10280 // a declaration that does not use the syntactic form of a 10281 // function declarator to have a function type, the program 10282 // is ill-formed. 10283 if (!TInfo->getType()->isFunctionType()) { 10284 Diag(Loc, diag::err_unexpected_friend); 10285 10286 // It might be worthwhile to try to recover by creating an 10287 // appropriate declaration. 10288 return 0; 10289 } 10290 10291 // C++ [namespace.memdef]p3 10292 // - If a friend declaration in a non-local class first declares a 10293 // class or function, the friend class or function is a member 10294 // of the innermost enclosing namespace. 10295 // - The name of the friend is not found by simple name lookup 10296 // until a matching declaration is provided in that namespace 10297 // scope (either before or after the class declaration granting 10298 // friendship). 10299 // - If a friend function is called, its name may be found by the 10300 // name lookup that considers functions from namespaces and 10301 // classes associated with the types of the function arguments. 10302 // - When looking for a prior declaration of a class or a function 10303 // declared as a friend, scopes outside the innermost enclosing 10304 // namespace scope are not considered. 10305 10306 CXXScopeSpec &SS = D.getCXXScopeSpec(); 10307 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 10308 DeclarationName Name = NameInfo.getName(); 10309 assert(Name); 10310 10311 // Check for unexpanded parameter packs. 10312 if (DiagnoseUnexpandedParameterPack(Loc, TInfo, UPPC_FriendDeclaration) || 10313 DiagnoseUnexpandedParameterPack(NameInfo, UPPC_FriendDeclaration) || 10314 DiagnoseUnexpandedParameterPack(SS, UPPC_FriendDeclaration)) 10315 return 0; 10316 10317 // The context we found the declaration in, or in which we should 10318 // create the declaration. 10319 DeclContext *DC; 10320 Scope *DCScope = S; 10321 LookupResult Previous(*this, NameInfo, LookupOrdinaryName, 10322 ForRedeclaration); 10323 10324 // FIXME: there are different rules in local classes 10325 10326 // There are four cases here. 10327 // - There's no scope specifier, in which case we just go to the 10328 // appropriate scope and look for a function or function template 10329 // there as appropriate. 10330 // Recover from invalid scope qualifiers as if they just weren't there. 10331 if (SS.isInvalid() || !SS.isSet()) { 10332 // C++0x [namespace.memdef]p3: 10333 // If the name in a friend declaration is neither qualified nor 10334 // a template-id and the declaration is a function or an 10335 // elaborated-type-specifier, the lookup to determine whether 10336 // the entity has been previously declared shall not consider 10337 // any scopes outside the innermost enclosing namespace. 10338 // C++0x [class.friend]p11: 10339 // If a friend declaration appears in a local class and the name 10340 // specified is an unqualified name, a prior declaration is 10341 // looked up without considering scopes that are outside the 10342 // innermost enclosing non-class scope. For a friend function 10343 // declaration, if there is no prior declaration, the program is 10344 // ill-formed. 10345 bool isLocal = cast<CXXRecordDecl>(CurContext)->isLocalClass(); 10346 bool isTemplateId = D.getName().getKind() == UnqualifiedId::IK_TemplateId; 10347 10348 // Find the appropriate context according to the above. 10349 DC = CurContext; 10350 while (true) { 10351 // Skip class contexts. If someone can cite chapter and verse 10352 // for this behavior, that would be nice --- it's what GCC and 10353 // EDG do, and it seems like a reasonable intent, but the spec 10354 // really only says that checks for unqualified existing 10355 // declarations should stop at the nearest enclosing namespace, 10356 // not that they should only consider the nearest enclosing 10357 // namespace. 10358 while (DC->isRecord() || DC->isTransparentContext()) 10359 DC = DC->getParent(); 10360 10361 LookupQualifiedName(Previous, DC); 10362 10363 // TODO: decide what we think about using declarations. 10364 if (isLocal || !Previous.empty()) 10365 break; 10366 10367 if (isTemplateId) { 10368 if (isa<TranslationUnitDecl>(DC)) break; 10369 } else { 10370 if (DC->isFileContext()) break; 10371 } 10372 DC = DC->getParent(); 10373 } 10374 10375 // C++ [class.friend]p1: A friend of a class is a function or 10376 // class that is not a member of the class . . . 10377 // C++11 changes this for both friend types and functions. 10378 // Most C++ 98 compilers do seem to give an error here, so 10379 // we do, too. 10380 if (!Previous.empty() && DC->Equals(CurContext)) 10381 Diag(DS.getFriendSpecLoc(), 10382 getLangOpts().CPlusPlus0x ? 10383 diag::warn_cxx98_compat_friend_is_member : 10384 diag::err_friend_is_member); 10385 10386 DCScope = getScopeForDeclContext(S, DC); 10387 10388 // C++ [class.friend]p6: 10389 // A function can be defined in a friend declaration of a class if and 10390 // only if the class is a non-local class (9.8), the function name is 10391 // unqualified, and the function has namespace scope. 10392 if (isLocal && D.isFunctionDefinition()) { 10393 Diag(NameInfo.getBeginLoc(), diag::err_friend_def_in_local_class); 10394 } 10395 10396 // - There's a non-dependent scope specifier, in which case we 10397 // compute it and do a previous lookup there for a function 10398 // or function template. 10399 } else if (!SS.getScopeRep()->isDependent()) { 10400 DC = computeDeclContext(SS); 10401 if (!DC) return 0; 10402 10403 if (RequireCompleteDeclContext(SS, DC)) return 0; 10404 10405 LookupQualifiedName(Previous, DC); 10406 10407 // Ignore things found implicitly in the wrong scope. 10408 // TODO: better diagnostics for this case. Suggesting the right 10409 // qualified scope would be nice... 10410 LookupResult::Filter F = Previous.makeFilter(); 10411 while (F.hasNext()) { 10412 NamedDecl *D = F.next(); 10413 if (!DC->InEnclosingNamespaceSetOf( 10414 D->getDeclContext()->getRedeclContext())) 10415 F.erase(); 10416 } 10417 F.done(); 10418 10419 if (Previous.empty()) { 10420 D.setInvalidType(); 10421 Diag(Loc, diag::err_qualified_friend_not_found) 10422 << Name << TInfo->getType(); 10423 return 0; 10424 } 10425 10426 // C++ [class.friend]p1: A friend of a class is a function or 10427 // class that is not a member of the class . . . 10428 if (DC->Equals(CurContext)) 10429 Diag(DS.getFriendSpecLoc(), 10430 getLangOpts().CPlusPlus0x ? 10431 diag::warn_cxx98_compat_friend_is_member : 10432 diag::err_friend_is_member); 10433 10434 if (D.isFunctionDefinition()) { 10435 // C++ [class.friend]p6: 10436 // A function can be defined in a friend declaration of a class if and 10437 // only if the class is a non-local class (9.8), the function name is 10438 // unqualified, and the function has namespace scope. 10439 SemaDiagnosticBuilder DB 10440 = Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def); 10441 10442 DB << SS.getScopeRep(); 10443 if (DC->isFileContext()) 10444 DB << FixItHint::CreateRemoval(SS.getRange()); 10445 SS.clear(); 10446 } 10447 10448 // - There's a scope specifier that does not match any template 10449 // parameter lists, in which case we use some arbitrary context, 10450 // create a method or method template, and wait for instantiation. 10451 // - There's a scope specifier that does match some template 10452 // parameter lists, which we don't handle right now. 10453 } else { 10454 if (D.isFunctionDefinition()) { 10455 // C++ [class.friend]p6: 10456 // A function can be defined in a friend declaration of a class if and 10457 // only if the class is a non-local class (9.8), the function name is 10458 // unqualified, and the function has namespace scope. 10459 Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def) 10460 << SS.getScopeRep(); 10461 } 10462 10463 DC = CurContext; 10464 assert(isa<CXXRecordDecl>(DC) && "friend declaration not in class?"); 10465 } 10466 10467 if (!DC->isRecord()) { 10468 // This implies that it has to be an operator or function. 10469 if (D.getName().getKind() == UnqualifiedId::IK_ConstructorName || 10470 D.getName().getKind() == UnqualifiedId::IK_DestructorName || 10471 D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId) { 10472 Diag(Loc, diag::err_introducing_special_friend) << 10473 (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ? 0 : 10474 D.getName().getKind() == UnqualifiedId::IK_DestructorName ? 1 : 2); 10475 return 0; 10476 } 10477 } 10478 10479 // FIXME: This is an egregious hack to cope with cases where the scope stack 10480 // does not contain the declaration context, i.e., in an out-of-line 10481 // definition of a class. 10482 Scope FakeDCScope(S, Scope::DeclScope, Diags); 10483 if (!DCScope) { 10484 FakeDCScope.setEntity(DC); 10485 DCScope = &FakeDCScope; 10486 } 10487 10488 bool AddToScope = true; 10489 NamedDecl *ND = ActOnFunctionDeclarator(DCScope, D, DC, TInfo, Previous, 10490 TemplateParams, AddToScope); 10491 if (!ND) return 0; 10492 10493 assert(ND->getDeclContext() == DC); 10494 assert(ND->getLexicalDeclContext() == CurContext); 10495 10496 // Add the function declaration to the appropriate lookup tables, 10497 // adjusting the redeclarations list as necessary. We don't 10498 // want to do this yet if the friending class is dependent. 10499 // 10500 // Also update the scope-based lookup if the target context's 10501 // lookup context is in lexical scope. 10502 if (!CurContext->isDependentContext()) { 10503 DC = DC->getRedeclContext(); 10504 DC->makeDeclVisibleInContext(ND); 10505 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC)) 10506 PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false); 10507 } 10508 10509 FriendDecl *FrD = FriendDecl::Create(Context, CurContext, 10510 D.getIdentifierLoc(), ND, 10511 DS.getFriendSpecLoc()); 10512 FrD->setAccess(AS_public); 10513 CurContext->addDecl(FrD); 10514 10515 if (ND->isInvalidDecl()) { 10516 FrD->setInvalidDecl(); 10517 } else { 10518 if (DC->isRecord()) CheckFriendAccess(ND); 10519 10520 FunctionDecl *FD; 10521 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND)) 10522 FD = FTD->getTemplatedDecl(); 10523 else 10524 FD = cast<FunctionDecl>(ND); 10525 10526 // Mark templated-scope function declarations as unsupported. 10527 if (FD->getNumTemplateParameterLists()) 10528 FrD->setUnsupportedFriend(true); 10529 } 10530 10531 return ND; 10532} 10533 10534void Sema::SetDeclDeleted(Decl *Dcl, SourceLocation DelLoc) { 10535 AdjustDeclIfTemplate(Dcl); 10536 10537 FunctionDecl *Fn = dyn_cast<FunctionDecl>(Dcl); 10538 if (!Fn) { 10539 Diag(DelLoc, diag::err_deleted_non_function); 10540 return; 10541 } 10542 if (const FunctionDecl *Prev = Fn->getPreviousDecl()) { 10543 // Don't consider the implicit declaration we generate for explicit 10544 // specializations. FIXME: Do not generate these implicit declarations. 10545 if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization 10546 || Prev->getPreviousDecl()) && !Prev->isDefined()) { 10547 Diag(DelLoc, diag::err_deleted_decl_not_first); 10548 Diag(Prev->getLocation(), diag::note_previous_declaration); 10549 } 10550 // If the declaration wasn't the first, we delete the function anyway for 10551 // recovery. 10552 } 10553 Fn->setDeletedAsWritten(); 10554 10555 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Dcl); 10556 if (!MD) 10557 return; 10558 10559 // A deleted special member function is trivial if the corresponding 10560 // implicitly-declared function would have been. 10561 switch (getSpecialMember(MD)) { 10562 case CXXInvalid: 10563 break; 10564 case CXXDefaultConstructor: 10565 MD->setTrivial(MD->getParent()->hasTrivialDefaultConstructor()); 10566 break; 10567 case CXXCopyConstructor: 10568 MD->setTrivial(MD->getParent()->hasTrivialCopyConstructor()); 10569 break; 10570 case CXXMoveConstructor: 10571 MD->setTrivial(MD->getParent()->hasTrivialMoveConstructor()); 10572 break; 10573 case CXXCopyAssignment: 10574 MD->setTrivial(MD->getParent()->hasTrivialCopyAssignment()); 10575 break; 10576 case CXXMoveAssignment: 10577 MD->setTrivial(MD->getParent()->hasTrivialMoveAssignment()); 10578 break; 10579 case CXXDestructor: 10580 MD->setTrivial(MD->getParent()->hasTrivialDestructor()); 10581 break; 10582 } 10583} 10584 10585void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) { 10586 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Dcl); 10587 10588 if (MD) { 10589 if (MD->getParent()->isDependentType()) { 10590 MD->setDefaulted(); 10591 MD->setExplicitlyDefaulted(); 10592 return; 10593 } 10594 10595 CXXSpecialMember Member = getSpecialMember(MD); 10596 if (Member == CXXInvalid) { 10597 Diag(DefaultLoc, diag::err_default_special_members); 10598 return; 10599 } 10600 10601 MD->setDefaulted(); 10602 MD->setExplicitlyDefaulted(); 10603 10604 // If this definition appears within the record, do the checking when 10605 // the record is complete. 10606 const FunctionDecl *Primary = MD; 10607 if (const FunctionDecl *Pattern = MD->getTemplateInstantiationPattern()) 10608 // Find the uninstantiated declaration that actually had the '= default' 10609 // on it. 10610 Pattern->isDefined(Primary); 10611 10612 if (Primary == Primary->getCanonicalDecl()) 10613 return; 10614 10615 CheckExplicitlyDefaultedSpecialMember(MD); 10616 10617 switch (Member) { 10618 case CXXDefaultConstructor: { 10619 CXXConstructorDecl *CD = cast<CXXConstructorDecl>(MD); 10620 if (!CD->isInvalidDecl()) 10621 DefineImplicitDefaultConstructor(DefaultLoc, CD); 10622 break; 10623 } 10624 10625 case CXXCopyConstructor: { 10626 CXXConstructorDecl *CD = cast<CXXConstructorDecl>(MD); 10627 if (!CD->isInvalidDecl()) 10628 DefineImplicitCopyConstructor(DefaultLoc, CD); 10629 break; 10630 } 10631 10632 case CXXCopyAssignment: { 10633 if (!MD->isInvalidDecl()) 10634 DefineImplicitCopyAssignment(DefaultLoc, MD); 10635 break; 10636 } 10637 10638 case CXXDestructor: { 10639 CXXDestructorDecl *DD = cast<CXXDestructorDecl>(MD); 10640 if (!DD->isInvalidDecl()) 10641 DefineImplicitDestructor(DefaultLoc, DD); 10642 break; 10643 } 10644 10645 case CXXMoveConstructor: { 10646 CXXConstructorDecl *CD = cast<CXXConstructorDecl>(MD); 10647 if (!CD->isInvalidDecl()) 10648 DefineImplicitMoveConstructor(DefaultLoc, CD); 10649 break; 10650 } 10651 10652 case CXXMoveAssignment: { 10653 if (!MD->isInvalidDecl()) 10654 DefineImplicitMoveAssignment(DefaultLoc, MD); 10655 break; 10656 } 10657 10658 case CXXInvalid: 10659 llvm_unreachable("Invalid special member."); 10660 } 10661 } else { 10662 Diag(DefaultLoc, diag::err_default_special_members); 10663 } 10664} 10665 10666static void SearchForReturnInStmt(Sema &Self, Stmt *S) { 10667 for (Stmt::child_range CI = S->children(); CI; ++CI) { 10668 Stmt *SubStmt = *CI; 10669 if (!SubStmt) 10670 continue; 10671 if (isa<ReturnStmt>(SubStmt)) 10672 Self.Diag(SubStmt->getLocStart(), 10673 diag::err_return_in_constructor_handler); 10674 if (!isa<Expr>(SubStmt)) 10675 SearchForReturnInStmt(Self, SubStmt); 10676 } 10677} 10678 10679void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) { 10680 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) { 10681 CXXCatchStmt *Handler = TryBlock->getHandler(I); 10682 SearchForReturnInStmt(*this, Handler); 10683 } 10684} 10685 10686bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New, 10687 const CXXMethodDecl *Old) { 10688 QualType NewTy = New->getType()->getAs<FunctionType>()->getResultType(); 10689 QualType OldTy = Old->getType()->getAs<FunctionType>()->getResultType(); 10690 10691 if (Context.hasSameType(NewTy, OldTy) || 10692 NewTy->isDependentType() || OldTy->isDependentType()) 10693 return false; 10694 10695 // Check if the return types are covariant 10696 QualType NewClassTy, OldClassTy; 10697 10698 /// Both types must be pointers or references to classes. 10699 if (const PointerType *NewPT = NewTy->getAs<PointerType>()) { 10700 if (const PointerType *OldPT = OldTy->getAs<PointerType>()) { 10701 NewClassTy = NewPT->getPointeeType(); 10702 OldClassTy = OldPT->getPointeeType(); 10703 } 10704 } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) { 10705 if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) { 10706 if (NewRT->getTypeClass() == OldRT->getTypeClass()) { 10707 NewClassTy = NewRT->getPointeeType(); 10708 OldClassTy = OldRT->getPointeeType(); 10709 } 10710 } 10711 } 10712 10713 // The return types aren't either both pointers or references to a class type. 10714 if (NewClassTy.isNull()) { 10715 Diag(New->getLocation(), 10716 diag::err_different_return_type_for_overriding_virtual_function) 10717 << New->getDeclName() << NewTy << OldTy; 10718 Diag(Old->getLocation(), diag::note_overridden_virtual_function); 10719 10720 return true; 10721 } 10722 10723 // C++ [class.virtual]p6: 10724 // If the return type of D::f differs from the return type of B::f, the 10725 // class type in the return type of D::f shall be complete at the point of 10726 // declaration of D::f or shall be the class type D. 10727 if (const RecordType *RT = NewClassTy->getAs<RecordType>()) { 10728 if (!RT->isBeingDefined() && 10729 RequireCompleteType(New->getLocation(), NewClassTy, 10730 diag::err_covariant_return_incomplete, 10731 New->getDeclName())) 10732 return true; 10733 } 10734 10735 if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) { 10736 // Check if the new class derives from the old class. 10737 if (!IsDerivedFrom(NewClassTy, OldClassTy)) { 10738 Diag(New->getLocation(), 10739 diag::err_covariant_return_not_derived) 10740 << New->getDeclName() << NewTy << OldTy; 10741 Diag(Old->getLocation(), diag::note_overridden_virtual_function); 10742 return true; 10743 } 10744 10745 // Check if we the conversion from derived to base is valid. 10746 if (CheckDerivedToBaseConversion(NewClassTy, OldClassTy, 10747 diag::err_covariant_return_inaccessible_base, 10748 diag::err_covariant_return_ambiguous_derived_to_base_conv, 10749 // FIXME: Should this point to the return type? 10750 New->getLocation(), SourceRange(), New->getDeclName(), 0)) { 10751 // FIXME: this note won't trigger for delayed access control 10752 // diagnostics, and it's impossible to get an undelayed error 10753 // here from access control during the original parse because 10754 // the ParsingDeclSpec/ParsingDeclarator are still in scope. 10755 Diag(Old->getLocation(), diag::note_overridden_virtual_function); 10756 return true; 10757 } 10758 } 10759 10760 // The qualifiers of the return types must be the same. 10761 if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) { 10762 Diag(New->getLocation(), 10763 diag::err_covariant_return_type_different_qualifications) 10764 << New->getDeclName() << NewTy << OldTy; 10765 Diag(Old->getLocation(), diag::note_overridden_virtual_function); 10766 return true; 10767 }; 10768 10769 10770 // The new class type must have the same or less qualifiers as the old type. 10771 if (NewClassTy.isMoreQualifiedThan(OldClassTy)) { 10772 Diag(New->getLocation(), 10773 diag::err_covariant_return_type_class_type_more_qualified) 10774 << New->getDeclName() << NewTy << OldTy; 10775 Diag(Old->getLocation(), diag::note_overridden_virtual_function); 10776 return true; 10777 }; 10778 10779 return false; 10780} 10781 10782/// \brief Mark the given method pure. 10783/// 10784/// \param Method the method to be marked pure. 10785/// 10786/// \param InitRange the source range that covers the "0" initializer. 10787bool Sema::CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange) { 10788 SourceLocation EndLoc = InitRange.getEnd(); 10789 if (EndLoc.isValid()) 10790 Method->setRangeEnd(EndLoc); 10791 10792 if (Method->isVirtual() || Method->getParent()->isDependentContext()) { 10793 Method->setPure(); 10794 return false; 10795 } 10796 10797 if (!Method->isInvalidDecl()) 10798 Diag(Method->getLocation(), diag::err_non_virtual_pure) 10799 << Method->getDeclName() << InitRange; 10800 return true; 10801} 10802 10803/// \brief Determine whether the given declaration is a static data member. 10804static bool isStaticDataMember(Decl *D) { 10805 VarDecl *Var = dyn_cast_or_null<VarDecl>(D); 10806 if (!Var) 10807 return false; 10808 10809 return Var->isStaticDataMember(); 10810} 10811/// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse 10812/// an initializer for the out-of-line declaration 'Dcl'. The scope 10813/// is a fresh scope pushed for just this purpose. 10814/// 10815/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a 10816/// static data member of class X, names should be looked up in the scope of 10817/// class X. 10818void Sema::ActOnCXXEnterDeclInitializer(Scope *S, Decl *D) { 10819 // If there is no declaration, there was an error parsing it. 10820 if (D == 0 || D->isInvalidDecl()) return; 10821 10822 // We should only get called for declarations with scope specifiers, like: 10823 // int foo::bar; 10824 assert(D->isOutOfLine()); 10825 EnterDeclaratorContext(S, D->getDeclContext()); 10826 10827 // If we are parsing the initializer for a static data member, push a 10828 // new expression evaluation context that is associated with this static 10829 // data member. 10830 if (isStaticDataMember(D)) 10831 PushExpressionEvaluationContext(PotentiallyEvaluated, D); 10832} 10833 10834/// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an 10835/// initializer for the out-of-line declaration 'D'. 10836void Sema::ActOnCXXExitDeclInitializer(Scope *S, Decl *D) { 10837 // If there is no declaration, there was an error parsing it. 10838 if (D == 0 || D->isInvalidDecl()) return; 10839 10840 if (isStaticDataMember(D)) 10841 PopExpressionEvaluationContext(); 10842 10843 assert(D->isOutOfLine()); 10844 ExitDeclaratorContext(S); 10845} 10846 10847/// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a 10848/// C++ if/switch/while/for statement. 10849/// e.g: "if (int x = f()) {...}" 10850DeclResult Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) { 10851 // C++ 6.4p2: 10852 // The declarator shall not specify a function or an array. 10853 // The type-specifier-seq shall not contain typedef and shall not declare a 10854 // new class or enumeration. 10855 assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef && 10856 "Parser allowed 'typedef' as storage class of condition decl."); 10857 10858 Decl *Dcl = ActOnDeclarator(S, D); 10859 if (!Dcl) 10860 return true; 10861 10862 if (isa<FunctionDecl>(Dcl)) { // The declarator shall not specify a function. 10863 Diag(Dcl->getLocation(), diag::err_invalid_use_of_function_type) 10864 << D.getSourceRange(); 10865 return true; 10866 } 10867 10868 return Dcl; 10869} 10870 10871void Sema::LoadExternalVTableUses() { 10872 if (!ExternalSource) 10873 return; 10874 10875 SmallVector<ExternalVTableUse, 4> VTables; 10876 ExternalSource->ReadUsedVTables(VTables); 10877 SmallVector<VTableUse, 4> NewUses; 10878 for (unsigned I = 0, N = VTables.size(); I != N; ++I) { 10879 llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos 10880 = VTablesUsed.find(VTables[I].Record); 10881 // Even if a definition wasn't required before, it may be required now. 10882 if (Pos != VTablesUsed.end()) { 10883 if (!Pos->second && VTables[I].DefinitionRequired) 10884 Pos->second = true; 10885 continue; 10886 } 10887 10888 VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired; 10889 NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location)); 10890 } 10891 10892 VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end()); 10893} 10894 10895void Sema::MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, 10896 bool DefinitionRequired) { 10897 // Ignore any vtable uses in unevaluated operands or for classes that do 10898 // not have a vtable. 10899 if (!Class->isDynamicClass() || Class->isDependentContext() || 10900 CurContext->isDependentContext() || 10901 ExprEvalContexts.back().Context == Unevaluated) 10902 return; 10903 10904 // Try to insert this class into the map. 10905 LoadExternalVTableUses(); 10906 Class = cast<CXXRecordDecl>(Class->getCanonicalDecl()); 10907 std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator, bool> 10908 Pos = VTablesUsed.insert(std::make_pair(Class, DefinitionRequired)); 10909 if (!Pos.second) { 10910 // If we already had an entry, check to see if we are promoting this vtable 10911 // to required a definition. If so, we need to reappend to the VTableUses 10912 // list, since we may have already processed the first entry. 10913 if (DefinitionRequired && !Pos.first->second) { 10914 Pos.first->second = true; 10915 } else { 10916 // Otherwise, we can early exit. 10917 return; 10918 } 10919 } 10920 10921 // Local classes need to have their virtual members marked 10922 // immediately. For all other classes, we mark their virtual members 10923 // at the end of the translation unit. 10924 if (Class->isLocalClass()) 10925 MarkVirtualMembersReferenced(Loc, Class); 10926 else 10927 VTableUses.push_back(std::make_pair(Class, Loc)); 10928} 10929 10930bool Sema::DefineUsedVTables() { 10931 LoadExternalVTableUses(); 10932 if (VTableUses.empty()) 10933 return false; 10934 10935 // Note: The VTableUses vector could grow as a result of marking 10936 // the members of a class as "used", so we check the size each 10937 // time through the loop and prefer indices (which are stable) to 10938 // iterators (which are not). 10939 bool DefinedAnything = false; 10940 for (unsigned I = 0; I != VTableUses.size(); ++I) { 10941 CXXRecordDecl *Class = VTableUses[I].first->getDefinition(); 10942 if (!Class) 10943 continue; 10944 10945 SourceLocation Loc = VTableUses[I].second; 10946 10947 bool DefineVTable = true; 10948 10949 // If this class has a key function, but that key function is 10950 // defined in another translation unit, we don't need to emit the 10951 // vtable even though we're using it. 10952 const CXXMethodDecl *KeyFunction = Context.getKeyFunction(Class); 10953 if (KeyFunction && !KeyFunction->hasBody()) { 10954 switch (KeyFunction->getTemplateSpecializationKind()) { 10955 case TSK_Undeclared: 10956 case TSK_ExplicitSpecialization: 10957 case TSK_ExplicitInstantiationDeclaration: 10958 // The key function is in another translation unit. 10959 DefineVTable = false; 10960 break; 10961 10962 case TSK_ExplicitInstantiationDefinition: 10963 case TSK_ImplicitInstantiation: 10964 // We will be instantiating the key function. 10965 break; 10966 } 10967 } else if (!KeyFunction) { 10968 // If we have a class with no key function that is the subject 10969 // of an explicit instantiation declaration, suppress the 10970 // vtable; it will live with the explicit instantiation 10971 // definition. 10972 bool IsExplicitInstantiationDeclaration 10973 = Class->getTemplateSpecializationKind() 10974 == TSK_ExplicitInstantiationDeclaration; 10975 for (TagDecl::redecl_iterator R = Class->redecls_begin(), 10976 REnd = Class->redecls_end(); 10977 R != REnd; ++R) { 10978 TemplateSpecializationKind TSK 10979 = cast<CXXRecordDecl>(*R)->getTemplateSpecializationKind(); 10980 if (TSK == TSK_ExplicitInstantiationDeclaration) 10981 IsExplicitInstantiationDeclaration = true; 10982 else if (TSK == TSK_ExplicitInstantiationDefinition) { 10983 IsExplicitInstantiationDeclaration = false; 10984 break; 10985 } 10986 } 10987 10988 if (IsExplicitInstantiationDeclaration) 10989 DefineVTable = false; 10990 } 10991 10992 // The exception specifications for all virtual members may be needed even 10993 // if we are not providing an authoritative form of the vtable in this TU. 10994 // We may choose to emit it available_externally anyway. 10995 if (!DefineVTable) { 10996 MarkVirtualMemberExceptionSpecsNeeded(Loc, Class); 10997 continue; 10998 } 10999 11000 // Mark all of the virtual members of this class as referenced, so 11001 // that we can build a vtable. Then, tell the AST consumer that a 11002 // vtable for this class is required. 11003 DefinedAnything = true; 11004 MarkVirtualMembersReferenced(Loc, Class); 11005 CXXRecordDecl *Canonical = cast<CXXRecordDecl>(Class->getCanonicalDecl()); 11006 Consumer.HandleVTable(Class, VTablesUsed[Canonical]); 11007 11008 // Optionally warn if we're emitting a weak vtable. 11009 if (Class->getLinkage() == ExternalLinkage && 11010 Class->getTemplateSpecializationKind() != TSK_ImplicitInstantiation) { 11011 const FunctionDecl *KeyFunctionDef = 0; 11012 if (!KeyFunction || 11013 (KeyFunction->hasBody(KeyFunctionDef) && 11014 KeyFunctionDef->isInlined())) 11015 Diag(Class->getLocation(), Class->getTemplateSpecializationKind() == 11016 TSK_ExplicitInstantiationDefinition 11017 ? diag::warn_weak_template_vtable : diag::warn_weak_vtable) 11018 << Class; 11019 } 11020 } 11021 VTableUses.clear(); 11022 11023 return DefinedAnything; 11024} 11025 11026void Sema::MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc, 11027 const CXXRecordDecl *RD) { 11028 for (CXXRecordDecl::method_iterator I = RD->method_begin(), 11029 E = RD->method_end(); I != E; ++I) 11030 if ((*I)->isVirtual() && !(*I)->isPure()) 11031 ResolveExceptionSpec(Loc, (*I)->getType()->castAs<FunctionProtoType>()); 11032} 11033 11034void Sema::MarkVirtualMembersReferenced(SourceLocation Loc, 11035 const CXXRecordDecl *RD) { 11036 // Mark all functions which will appear in RD's vtable as used. 11037 CXXFinalOverriderMap FinalOverriders; 11038 RD->getFinalOverriders(FinalOverriders); 11039 for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(), 11040 E = FinalOverriders.end(); 11041 I != E; ++I) { 11042 for (OverridingMethods::const_iterator OI = I->second.begin(), 11043 OE = I->second.end(); 11044 OI != OE; ++OI) { 11045 assert(OI->second.size() > 0 && "no final overrider"); 11046 CXXMethodDecl *Overrider = OI->second.front().Method; 11047 11048 // C++ [basic.def.odr]p2: 11049 // [...] A virtual member function is used if it is not pure. [...] 11050 if (!Overrider->isPure()) 11051 MarkFunctionReferenced(Loc, Overrider); 11052 } 11053 } 11054 11055 // Only classes that have virtual bases need a VTT. 11056 if (RD->getNumVBases() == 0) 11057 return; 11058 11059 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(), 11060 e = RD->bases_end(); i != e; ++i) { 11061 const CXXRecordDecl *Base = 11062 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 11063 if (Base->getNumVBases() == 0) 11064 continue; 11065 MarkVirtualMembersReferenced(Loc, Base); 11066 } 11067} 11068 11069/// SetIvarInitializers - This routine builds initialization ASTs for the 11070/// Objective-C implementation whose ivars need be initialized. 11071void Sema::SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation) { 11072 if (!getLangOpts().CPlusPlus) 11073 return; 11074 if (ObjCInterfaceDecl *OID = ObjCImplementation->getClassInterface()) { 11075 SmallVector<ObjCIvarDecl*, 8> ivars; 11076 CollectIvarsToConstructOrDestruct(OID, ivars); 11077 if (ivars.empty()) 11078 return; 11079 SmallVector<CXXCtorInitializer*, 32> AllToInit; 11080 for (unsigned i = 0; i < ivars.size(); i++) { 11081 FieldDecl *Field = ivars[i]; 11082 if (Field->isInvalidDecl()) 11083 continue; 11084 11085 CXXCtorInitializer *Member; 11086 InitializedEntity InitEntity = InitializedEntity::InitializeMember(Field); 11087 InitializationKind InitKind = 11088 InitializationKind::CreateDefault(ObjCImplementation->getLocation()); 11089 11090 InitializationSequence InitSeq(*this, InitEntity, InitKind, 0, 0); 11091 ExprResult MemberInit = 11092 InitSeq.Perform(*this, InitEntity, InitKind, MultiExprArg()); 11093 MemberInit = MaybeCreateExprWithCleanups(MemberInit); 11094 // Note, MemberInit could actually come back empty if no initialization 11095 // is required (e.g., because it would call a trivial default constructor) 11096 if (!MemberInit.get() || MemberInit.isInvalid()) 11097 continue; 11098 11099 Member = 11100 new (Context) CXXCtorInitializer(Context, Field, SourceLocation(), 11101 SourceLocation(), 11102 MemberInit.takeAs<Expr>(), 11103 SourceLocation()); 11104 AllToInit.push_back(Member); 11105 11106 // Be sure that the destructor is accessible and is marked as referenced. 11107 if (const RecordType *RecordTy 11108 = Context.getBaseElementType(Field->getType()) 11109 ->getAs<RecordType>()) { 11110 CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl()); 11111 if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) { 11112 MarkFunctionReferenced(Field->getLocation(), Destructor); 11113 CheckDestructorAccess(Field->getLocation(), Destructor, 11114 PDiag(diag::err_access_dtor_ivar) 11115 << Context.getBaseElementType(Field->getType())); 11116 } 11117 } 11118 } 11119 ObjCImplementation->setIvarInitializers(Context, 11120 AllToInit.data(), AllToInit.size()); 11121 } 11122} 11123 11124static 11125void DelegatingCycleHelper(CXXConstructorDecl* Ctor, 11126 llvm::SmallSet<CXXConstructorDecl*, 4> &Valid, 11127 llvm::SmallSet<CXXConstructorDecl*, 4> &Invalid, 11128 llvm::SmallSet<CXXConstructorDecl*, 4> &Current, 11129 Sema &S) { 11130 llvm::SmallSet<CXXConstructorDecl*, 4>::iterator CI = Current.begin(), 11131 CE = Current.end(); 11132 if (Ctor->isInvalidDecl()) 11133 return; 11134 11135 CXXConstructorDecl *Target = Ctor->getTargetConstructor(); 11136 11137 // Target may not be determinable yet, for instance if this is a dependent 11138 // call in an uninstantiated template. 11139 if (Target) { 11140 const FunctionDecl *FNTarget = 0; 11141 (void)Target->hasBody(FNTarget); 11142 Target = const_cast<CXXConstructorDecl*>( 11143 cast_or_null<CXXConstructorDecl>(FNTarget)); 11144 } 11145 11146 CXXConstructorDecl *Canonical = Ctor->getCanonicalDecl(), 11147 // Avoid dereferencing a null pointer here. 11148 *TCanonical = Target ? Target->getCanonicalDecl() : 0; 11149 11150 if (!Current.insert(Canonical)) 11151 return; 11152 11153 // We know that beyond here, we aren't chaining into a cycle. 11154 if (!Target || !Target->isDelegatingConstructor() || 11155 Target->isInvalidDecl() || Valid.count(TCanonical)) { 11156 for (CI = Current.begin(), CE = Current.end(); CI != CE; ++CI) 11157 Valid.insert(*CI); 11158 Current.clear(); 11159 // We've hit a cycle. 11160 } else if (TCanonical == Canonical || Invalid.count(TCanonical) || 11161 Current.count(TCanonical)) { 11162 // If we haven't diagnosed this cycle yet, do so now. 11163 if (!Invalid.count(TCanonical)) { 11164 S.Diag((*Ctor->init_begin())->getSourceLocation(), 11165 diag::warn_delegating_ctor_cycle) 11166 << Ctor; 11167 11168 // Don't add a note for a function delegating directly to itself. 11169 if (TCanonical != Canonical) 11170 S.Diag(Target->getLocation(), diag::note_it_delegates_to); 11171 11172 CXXConstructorDecl *C = Target; 11173 while (C->getCanonicalDecl() != Canonical) { 11174 const FunctionDecl *FNTarget = 0; 11175 (void)C->getTargetConstructor()->hasBody(FNTarget); 11176 assert(FNTarget && "Ctor cycle through bodiless function"); 11177 11178 C = const_cast<CXXConstructorDecl*>( 11179 cast<CXXConstructorDecl>(FNTarget)); 11180 S.Diag(C->getLocation(), diag::note_which_delegates_to); 11181 } 11182 } 11183 11184 for (CI = Current.begin(), CE = Current.end(); CI != CE; ++CI) 11185 Invalid.insert(*CI); 11186 Current.clear(); 11187 } else { 11188 DelegatingCycleHelper(Target, Valid, Invalid, Current, S); 11189 } 11190} 11191 11192 11193void Sema::CheckDelegatingCtorCycles() { 11194 llvm::SmallSet<CXXConstructorDecl*, 4> Valid, Invalid, Current; 11195 11196 llvm::SmallSet<CXXConstructorDecl*, 4>::iterator CI = Current.begin(), 11197 CE = Current.end(); 11198 11199 for (DelegatingCtorDeclsType::iterator 11200 I = DelegatingCtorDecls.begin(ExternalSource), 11201 E = DelegatingCtorDecls.end(); 11202 I != E; ++I) 11203 DelegatingCycleHelper(*I, Valid, Invalid, Current, *this); 11204 11205 for (CI = Invalid.begin(), CE = Invalid.end(); CI != CE; ++CI) 11206 (*CI)->setInvalidDecl(); 11207} 11208 11209namespace { 11210 /// \brief AST visitor that finds references to the 'this' expression. 11211 class FindCXXThisExpr : public RecursiveASTVisitor<FindCXXThisExpr> { 11212 Sema &S; 11213 11214 public: 11215 explicit FindCXXThisExpr(Sema &S) : S(S) { } 11216 11217 bool VisitCXXThisExpr(CXXThisExpr *E) { 11218 S.Diag(E->getLocation(), diag::err_this_static_member_func) 11219 << E->isImplicit(); 11220 return false; 11221 } 11222 }; 11223} 11224 11225bool Sema::checkThisInStaticMemberFunctionType(CXXMethodDecl *Method) { 11226 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo(); 11227 if (!TSInfo) 11228 return false; 11229 11230 TypeLoc TL = TSInfo->getTypeLoc(); 11231 FunctionProtoTypeLoc *ProtoTL = dyn_cast<FunctionProtoTypeLoc>(&TL); 11232 if (!ProtoTL) 11233 return false; 11234 11235 // C++11 [expr.prim.general]p3: 11236 // [The expression this] shall not appear before the optional 11237 // cv-qualifier-seq and it shall not appear within the declaration of a 11238 // static member function (although its type and value category are defined 11239 // within a static member function as they are within a non-static member 11240 // function). [ Note: this is because declaration matching does not occur 11241 // until the complete declarator is known. - end note ] 11242 const FunctionProtoType *Proto = ProtoTL->getTypePtr(); 11243 FindCXXThisExpr Finder(*this); 11244 11245 // If the return type came after the cv-qualifier-seq, check it now. 11246 if (Proto->hasTrailingReturn() && 11247 !Finder.TraverseTypeLoc(ProtoTL->getResultLoc())) 11248 return true; 11249 11250 // Check the exception specification. 11251 if (checkThisInStaticMemberFunctionExceptionSpec(Method)) 11252 return true; 11253 11254 return checkThisInStaticMemberFunctionAttributes(Method); 11255} 11256 11257bool Sema::checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method) { 11258 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo(); 11259 if (!TSInfo) 11260 return false; 11261 11262 TypeLoc TL = TSInfo->getTypeLoc(); 11263 FunctionProtoTypeLoc *ProtoTL = dyn_cast<FunctionProtoTypeLoc>(&TL); 11264 if (!ProtoTL) 11265 return false; 11266 11267 const FunctionProtoType *Proto = ProtoTL->getTypePtr(); 11268 FindCXXThisExpr Finder(*this); 11269 11270 switch (Proto->getExceptionSpecType()) { 11271 case EST_Uninstantiated: 11272 case EST_Unevaluated: 11273 case EST_BasicNoexcept: 11274 case EST_DynamicNone: 11275 case EST_MSAny: 11276 case EST_None: 11277 break; 11278 11279 case EST_ComputedNoexcept: 11280 if (!Finder.TraverseStmt(Proto->getNoexceptExpr())) 11281 return true; 11282 11283 case EST_Dynamic: 11284 for (FunctionProtoType::exception_iterator E = Proto->exception_begin(), 11285 EEnd = Proto->exception_end(); 11286 E != EEnd; ++E) { 11287 if (!Finder.TraverseType(*E)) 11288 return true; 11289 } 11290 break; 11291 } 11292 11293 return false; 11294} 11295 11296bool Sema::checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method) { 11297 FindCXXThisExpr Finder(*this); 11298 11299 // Check attributes. 11300 for (Decl::attr_iterator A = Method->attr_begin(), AEnd = Method->attr_end(); 11301 A != AEnd; ++A) { 11302 // FIXME: This should be emitted by tblgen. 11303 Expr *Arg = 0; 11304 ArrayRef<Expr *> Args; 11305 if (GuardedByAttr *G = dyn_cast<GuardedByAttr>(*A)) 11306 Arg = G->getArg(); 11307 else if (PtGuardedByAttr *G = dyn_cast<PtGuardedByAttr>(*A)) 11308 Arg = G->getArg(); 11309 else if (AcquiredAfterAttr *AA = dyn_cast<AcquiredAfterAttr>(*A)) 11310 Args = ArrayRef<Expr *>(AA->args_begin(), AA->args_size()); 11311 else if (AcquiredBeforeAttr *AB = dyn_cast<AcquiredBeforeAttr>(*A)) 11312 Args = ArrayRef<Expr *>(AB->args_begin(), AB->args_size()); 11313 else if (ExclusiveLockFunctionAttr *ELF 11314 = dyn_cast<ExclusiveLockFunctionAttr>(*A)) 11315 Args = ArrayRef<Expr *>(ELF->args_begin(), ELF->args_size()); 11316 else if (SharedLockFunctionAttr *SLF 11317 = dyn_cast<SharedLockFunctionAttr>(*A)) 11318 Args = ArrayRef<Expr *>(SLF->args_begin(), SLF->args_size()); 11319 else if (ExclusiveTrylockFunctionAttr *ETLF 11320 = dyn_cast<ExclusiveTrylockFunctionAttr>(*A)) { 11321 Arg = ETLF->getSuccessValue(); 11322 Args = ArrayRef<Expr *>(ETLF->args_begin(), ETLF->args_size()); 11323 } else if (SharedTrylockFunctionAttr *STLF 11324 = dyn_cast<SharedTrylockFunctionAttr>(*A)) { 11325 Arg = STLF->getSuccessValue(); 11326 Args = ArrayRef<Expr *>(STLF->args_begin(), STLF->args_size()); 11327 } else if (UnlockFunctionAttr *UF = dyn_cast<UnlockFunctionAttr>(*A)) 11328 Args = ArrayRef<Expr *>(UF->args_begin(), UF->args_size()); 11329 else if (LockReturnedAttr *LR = dyn_cast<LockReturnedAttr>(*A)) 11330 Arg = LR->getArg(); 11331 else if (LocksExcludedAttr *LE = dyn_cast<LocksExcludedAttr>(*A)) 11332 Args = ArrayRef<Expr *>(LE->args_begin(), LE->args_size()); 11333 else if (ExclusiveLocksRequiredAttr *ELR 11334 = dyn_cast<ExclusiveLocksRequiredAttr>(*A)) 11335 Args = ArrayRef<Expr *>(ELR->args_begin(), ELR->args_size()); 11336 else if (SharedLocksRequiredAttr *SLR 11337 = dyn_cast<SharedLocksRequiredAttr>(*A)) 11338 Args = ArrayRef<Expr *>(SLR->args_begin(), SLR->args_size()); 11339 11340 if (Arg && !Finder.TraverseStmt(Arg)) 11341 return true; 11342 11343 for (unsigned I = 0, N = Args.size(); I != N; ++I) { 11344 if (!Finder.TraverseStmt(Args[I])) 11345 return true; 11346 } 11347 } 11348 11349 return false; 11350} 11351 11352void 11353Sema::checkExceptionSpecification(ExceptionSpecificationType EST, 11354 ArrayRef<ParsedType> DynamicExceptions, 11355 ArrayRef<SourceRange> DynamicExceptionRanges, 11356 Expr *NoexceptExpr, 11357 llvm::SmallVectorImpl<QualType> &Exceptions, 11358 FunctionProtoType::ExtProtoInfo &EPI) { 11359 Exceptions.clear(); 11360 EPI.ExceptionSpecType = EST; 11361 if (EST == EST_Dynamic) { 11362 Exceptions.reserve(DynamicExceptions.size()); 11363 for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) { 11364 // FIXME: Preserve type source info. 11365 QualType ET = GetTypeFromParser(DynamicExceptions[ei]); 11366 11367 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 11368 collectUnexpandedParameterPacks(ET, Unexpanded); 11369 if (!Unexpanded.empty()) { 11370 DiagnoseUnexpandedParameterPacks(DynamicExceptionRanges[ei].getBegin(), 11371 UPPC_ExceptionType, 11372 Unexpanded); 11373 continue; 11374 } 11375 11376 // Check that the type is valid for an exception spec, and 11377 // drop it if not. 11378 if (!CheckSpecifiedExceptionType(ET, DynamicExceptionRanges[ei])) 11379 Exceptions.push_back(ET); 11380 } 11381 EPI.NumExceptions = Exceptions.size(); 11382 EPI.Exceptions = Exceptions.data(); 11383 return; 11384 } 11385 11386 if (EST == EST_ComputedNoexcept) { 11387 // If an error occurred, there's no expression here. 11388 if (NoexceptExpr) { 11389 assert((NoexceptExpr->isTypeDependent() || 11390 NoexceptExpr->getType()->getCanonicalTypeUnqualified() == 11391 Context.BoolTy) && 11392 "Parser should have made sure that the expression is boolean"); 11393 if (NoexceptExpr && DiagnoseUnexpandedParameterPack(NoexceptExpr)) { 11394 EPI.ExceptionSpecType = EST_BasicNoexcept; 11395 return; 11396 } 11397 11398 if (!NoexceptExpr->isValueDependent()) 11399 NoexceptExpr = VerifyIntegerConstantExpression(NoexceptExpr, 0, 11400 diag::err_noexcept_needs_constant_expression, 11401 /*AllowFold*/ false).take(); 11402 EPI.NoexceptExpr = NoexceptExpr; 11403 } 11404 return; 11405 } 11406} 11407 11408/// IdentifyCUDATarget - Determine the CUDA compilation target for this function 11409Sema::CUDAFunctionTarget Sema::IdentifyCUDATarget(const FunctionDecl *D) { 11410 // Implicitly declared functions (e.g. copy constructors) are 11411 // __host__ __device__ 11412 if (D->isImplicit()) 11413 return CFT_HostDevice; 11414 11415 if (D->hasAttr<CUDAGlobalAttr>()) 11416 return CFT_Global; 11417 11418 if (D->hasAttr<CUDADeviceAttr>()) { 11419 if (D->hasAttr<CUDAHostAttr>()) 11420 return CFT_HostDevice; 11421 else 11422 return CFT_Device; 11423 } 11424 11425 return CFT_Host; 11426} 11427 11428bool Sema::CheckCUDATarget(CUDAFunctionTarget CallerTarget, 11429 CUDAFunctionTarget CalleeTarget) { 11430 // CUDA B.1.1 "The __device__ qualifier declares a function that is... 11431 // Callable from the device only." 11432 if (CallerTarget == CFT_Host && CalleeTarget == CFT_Device) 11433 return true; 11434 11435 // CUDA B.1.2 "The __global__ qualifier declares a function that is... 11436 // Callable from the host only." 11437 // CUDA B.1.3 "The __host__ qualifier declares a function that is... 11438 // Callable from the host only." 11439 if ((CallerTarget == CFT_Device || CallerTarget == CFT_Global) && 11440 (CalleeTarget == CFT_Host || CalleeTarget == CFT_Global)) 11441 return true; 11442 11443 if (CallerTarget == CFT_HostDevice && CalleeTarget != CFT_HostDevice) 11444 return true; 11445 11446 return false; 11447} 11448