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/AST/ASTConsumer.h" 16 #include "clang/AST/ASTContext.h" 17 #include "clang/AST/ASTLambda.h" 18 #include "clang/AST/ASTMutationListener.h" 19 #include "clang/AST/CXXInheritance.h" 20 #include "clang/AST/CharUnits.h" 21 #include "clang/AST/EvaluatedExprVisitor.h" 22 #include "clang/AST/ExprCXX.h" 23 #include "clang/AST/RecordLayout.h" 24 #include "clang/AST/RecursiveASTVisitor.h" 25 #include "clang/AST/StmtVisitor.h" 26 #include "clang/AST/TypeLoc.h" 27 #include "clang/AST/TypeOrdering.h" 28 #include "clang/Basic/PartialDiagnostic.h" 29 #include "clang/Basic/TargetInfo.h" 30 #include "clang/Lex/LiteralSupport.h" 31 #include "clang/Lex/Preprocessor.h" 32 #include "clang/Sema/CXXFieldCollector.h" 33 #include "clang/Sema/DeclSpec.h" 34 #include "clang/Sema/Initialization.h" 35 #include "clang/Sema/Lookup.h" 36 #include "clang/Sema/ParsedTemplate.h" 37 #include "clang/Sema/Scope.h" 38 #include "clang/Sema/ScopeInfo.h" 39 #include "clang/Sema/Template.h" 40 #include "llvm/ADT/STLExtras.h" 41 #include "llvm/ADT/SmallString.h" 42 #include <map> 43 #include <set> 44 45 using namespace clang; 46 47 //===----------------------------------------------------------------------===// 48 // CheckDefaultArgumentVisitor 49 //===----------------------------------------------------------------------===// 50 51 namespace { 52 /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses 53 /// the default argument of a parameter to determine whether it 54 /// contains any ill-formed subexpressions. For example, this will 55 /// diagnose the use of local variables or parameters within the 56 /// default argument expression. 57 class CheckDefaultArgumentVisitor 58 : public StmtVisitor<CheckDefaultArgumentVisitor, bool> { 59 Expr *DefaultArg; 60 Sema *S; 61 62 public: 63 CheckDefaultArgumentVisitor(Expr *defarg, Sema *s) 64 : DefaultArg(defarg), S(s) {} 65 66 bool VisitExpr(Expr *Node); 67 bool VisitDeclRefExpr(DeclRefExpr *DRE); 68 bool VisitCXXThisExpr(CXXThisExpr *ThisE); 69 bool VisitLambdaExpr(LambdaExpr *Lambda); 70 bool VisitPseudoObjectExpr(PseudoObjectExpr *POE); 71 }; 72 73 /// VisitExpr - Visit all of the children of this expression. 74 bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) { 75 bool IsInvalid = false; 76 for (Stmt *SubStmt : Node->children()) 77 IsInvalid |= Visit(SubStmt); 78 return IsInvalid; 79 } 80 81 /// VisitDeclRefExpr - Visit a reference to a declaration, to 82 /// determine whether this declaration can be used in the default 83 /// argument expression. 84 bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) { 85 NamedDecl *Decl = DRE->getDecl(); 86 if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) { 87 // C++ [dcl.fct.default]p9 88 // Default arguments are evaluated each time the function is 89 // called. The order of evaluation of function arguments is 90 // unspecified. Consequently, parameters of a function shall not 91 // be used in default argument expressions, even if they are not 92 // evaluated. Parameters of a function declared before a default 93 // argument expression are in scope and can hide namespace and 94 // class member names. 95 return S->Diag(DRE->getLocStart(), 96 diag::err_param_default_argument_references_param) 97 << Param->getDeclName() << DefaultArg->getSourceRange(); 98 } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) { 99 // C++ [dcl.fct.default]p7 100 // Local variables shall not be used in default argument 101 // expressions. 102 if (VDecl->isLocalVarDecl()) 103 return S->Diag(DRE->getLocStart(), 104 diag::err_param_default_argument_references_local) 105 << VDecl->getDeclName() << DefaultArg->getSourceRange(); 106 } 107 108 return false; 109 } 110 111 /// VisitCXXThisExpr - Visit a C++ "this" expression. 112 bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) { 113 // C++ [dcl.fct.default]p8: 114 // The keyword this shall not be used in a default argument of a 115 // member function. 116 return S->Diag(ThisE->getLocStart(), 117 diag::err_param_default_argument_references_this) 118 << ThisE->getSourceRange(); 119 } 120 121 bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(PseudoObjectExpr *POE) { 122 bool Invalid = false; 123 for (PseudoObjectExpr::semantics_iterator 124 i = POE->semantics_begin(), e = POE->semantics_end(); i != e; ++i) { 125 Expr *E = *i; 126 127 // Look through bindings. 128 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) { 129 E = OVE->getSourceExpr(); 130 assert(E && "pseudo-object binding without source expression?"); 131 } 132 133 Invalid |= Visit(E); 134 } 135 return Invalid; 136 } 137 138 bool CheckDefaultArgumentVisitor::VisitLambdaExpr(LambdaExpr *Lambda) { 139 // C++11 [expr.lambda.prim]p13: 140 // A lambda-expression appearing in a default argument shall not 141 // implicitly or explicitly capture any entity. 142 if (Lambda->capture_begin() == Lambda->capture_end()) 143 return false; 144 145 return S->Diag(Lambda->getLocStart(), 146 diag::err_lambda_capture_default_arg); 147 } 148 } 149 150 void 151 Sema::ImplicitExceptionSpecification::CalledDecl(SourceLocation CallLoc, 152 const CXXMethodDecl *Method) { 153 // If we have an MSAny spec already, don't bother. 154 if (!Method || ComputedEST == EST_MSAny) 155 return; 156 157 const FunctionProtoType *Proto 158 = Method->getType()->getAs<FunctionProtoType>(); 159 Proto = Self->ResolveExceptionSpec(CallLoc, Proto); 160 if (!Proto) 161 return; 162 163 ExceptionSpecificationType EST = Proto->getExceptionSpecType(); 164 165 // If we have a throw-all spec at this point, ignore the function. 166 if (ComputedEST == EST_None) 167 return; 168 169 switch(EST) { 170 // If this function can throw any exceptions, make a note of that. 171 case EST_MSAny: 172 case EST_None: 173 ClearExceptions(); 174 ComputedEST = EST; 175 return; 176 // FIXME: If the call to this decl is using any of its default arguments, we 177 // need to search them for potentially-throwing calls. 178 // If this function has a basic noexcept, it doesn't affect the outcome. 179 case EST_BasicNoexcept: 180 return; 181 // If we're still at noexcept(true) and there's a nothrow() callee, 182 // change to that specification. 183 case EST_DynamicNone: 184 if (ComputedEST == EST_BasicNoexcept) 185 ComputedEST = EST_DynamicNone; 186 return; 187 // Check out noexcept specs. 188 case EST_ComputedNoexcept: 189 { 190 FunctionProtoType::NoexceptResult NR = 191 Proto->getNoexceptSpec(Self->Context); 192 assert(NR != FunctionProtoType::NR_NoNoexcept && 193 "Must have noexcept result for EST_ComputedNoexcept."); 194 assert(NR != FunctionProtoType::NR_Dependent && 195 "Should not generate implicit declarations for dependent cases, " 196 "and don't know how to handle them anyway."); 197 // noexcept(false) -> no spec on the new function 198 if (NR == FunctionProtoType::NR_Throw) { 199 ClearExceptions(); 200 ComputedEST = EST_None; 201 } 202 // noexcept(true) won't change anything either. 203 return; 204 } 205 default: 206 break; 207 } 208 assert(EST == EST_Dynamic && "EST case not considered earlier."); 209 assert(ComputedEST != EST_None && 210 "Shouldn't collect exceptions when throw-all is guaranteed."); 211 ComputedEST = EST_Dynamic; 212 // Record the exceptions in this function's exception specification. 213 for (const auto &E : Proto->exceptions()) 214 if (ExceptionsSeen.insert(Self->Context.getCanonicalType(E)).second) 215 Exceptions.push_back(E); 216 } 217 218 void Sema::ImplicitExceptionSpecification::CalledExpr(Expr *E) { 219 if (!E || ComputedEST == EST_MSAny) 220 return; 221 222 // FIXME: 223 // 224 // C++0x [except.spec]p14: 225 // [An] implicit exception-specification specifies the type-id T if and 226 // only if T is allowed by the exception-specification of a function directly 227 // invoked by f's implicit definition; f shall allow all exceptions if any 228 // function it directly invokes allows all exceptions, and f shall allow no 229 // exceptions if every function it directly invokes allows no exceptions. 230 // 231 // Note in particular that if an implicit exception-specification is generated 232 // for a function containing a throw-expression, that specification can still 233 // be noexcept(true). 234 // 235 // Note also that 'directly invoked' is not defined in the standard, and there 236 // is no indication that we should only consider potentially-evaluated calls. 237 // 238 // Ultimately we should implement the intent of the standard: the exception 239 // specification should be the set of exceptions which can be thrown by the 240 // implicit definition. For now, we assume that any non-nothrow expression can 241 // throw any exception. 242 243 if (Self->canThrow(E)) 244 ComputedEST = EST_None; 245 } 246 247 bool 248 Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg, 249 SourceLocation EqualLoc) { 250 if (RequireCompleteType(Param->getLocation(), Param->getType(), 251 diag::err_typecheck_decl_incomplete_type)) { 252 Param->setInvalidDecl(); 253 return true; 254 } 255 256 // C++ [dcl.fct.default]p5 257 // A default argument expression is implicitly converted (clause 258 // 4) to the parameter type. The default argument expression has 259 // the same semantic constraints as the initializer expression in 260 // a declaration of a variable of the parameter type, using the 261 // copy-initialization semantics (8.5). 262 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context, 263 Param); 264 InitializationKind Kind = InitializationKind::CreateCopy(Param->getLocation(), 265 EqualLoc); 266 InitializationSequence InitSeq(*this, Entity, Kind, Arg); 267 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg); 268 if (Result.isInvalid()) 269 return true; 270 Arg = Result.getAs<Expr>(); 271 272 CheckCompletedExpr(Arg, EqualLoc); 273 Arg = MaybeCreateExprWithCleanups(Arg); 274 275 // Okay: add the default argument to the parameter 276 Param->setDefaultArg(Arg); 277 278 // We have already instantiated this parameter; provide each of the 279 // instantiations with the uninstantiated default argument. 280 UnparsedDefaultArgInstantiationsMap::iterator InstPos 281 = UnparsedDefaultArgInstantiations.find(Param); 282 if (InstPos != UnparsedDefaultArgInstantiations.end()) { 283 for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I) 284 InstPos->second[I]->setUninstantiatedDefaultArg(Arg); 285 286 // We're done tracking this parameter's instantiations. 287 UnparsedDefaultArgInstantiations.erase(InstPos); 288 } 289 290 return false; 291 } 292 293 /// ActOnParamDefaultArgument - Check whether the default argument 294 /// provided for a function parameter is well-formed. If so, attach it 295 /// to the parameter declaration. 296 void 297 Sema::ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc, 298 Expr *DefaultArg) { 299 if (!param || !DefaultArg) 300 return; 301 302 ParmVarDecl *Param = cast<ParmVarDecl>(param); 303 UnparsedDefaultArgLocs.erase(Param); 304 305 // Default arguments are only permitted in C++ 306 if (!getLangOpts().CPlusPlus) { 307 Diag(EqualLoc, diag::err_param_default_argument) 308 << DefaultArg->getSourceRange(); 309 Param->setInvalidDecl(); 310 return; 311 } 312 313 // Check for unexpanded parameter packs. 314 if (DiagnoseUnexpandedParameterPack(DefaultArg, UPPC_DefaultArgument)) { 315 Param->setInvalidDecl(); 316 return; 317 } 318 319 // C++11 [dcl.fct.default]p3 320 // A default argument expression [...] shall not be specified for a 321 // parameter pack. 322 if (Param->isParameterPack()) { 323 Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack) 324 << DefaultArg->getSourceRange(); 325 return; 326 } 327 328 // Check that the default argument is well-formed 329 CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg, this); 330 if (DefaultArgChecker.Visit(DefaultArg)) { 331 Param->setInvalidDecl(); 332 return; 333 } 334 335 SetParamDefaultArgument(Param, DefaultArg, EqualLoc); 336 } 337 338 /// ActOnParamUnparsedDefaultArgument - We've seen a default 339 /// argument for a function parameter, but we can't parse it yet 340 /// because we're inside a class definition. Note that this default 341 /// argument will be parsed later. 342 void Sema::ActOnParamUnparsedDefaultArgument(Decl *param, 343 SourceLocation EqualLoc, 344 SourceLocation ArgLoc) { 345 if (!param) 346 return; 347 348 ParmVarDecl *Param = cast<ParmVarDecl>(param); 349 Param->setUnparsedDefaultArg(); 350 UnparsedDefaultArgLocs[Param] = ArgLoc; 351 } 352 353 /// ActOnParamDefaultArgumentError - Parsing or semantic analysis of 354 /// the default argument for the parameter param failed. 355 void Sema::ActOnParamDefaultArgumentError(Decl *param, 356 SourceLocation EqualLoc) { 357 if (!param) 358 return; 359 360 ParmVarDecl *Param = cast<ParmVarDecl>(param); 361 Param->setInvalidDecl(); 362 UnparsedDefaultArgLocs.erase(Param); 363 Param->setDefaultArg(new(Context) 364 OpaqueValueExpr(EqualLoc, 365 Param->getType().getNonReferenceType(), 366 VK_RValue)); 367 } 368 369 /// CheckExtraCXXDefaultArguments - Check for any extra default 370 /// arguments in the declarator, which is not a function declaration 371 /// or definition and therefore is not permitted to have default 372 /// arguments. This routine should be invoked for every declarator 373 /// that is not a function declaration or definition. 374 void Sema::CheckExtraCXXDefaultArguments(Declarator &D) { 375 // C++ [dcl.fct.default]p3 376 // A default argument expression shall be specified only in the 377 // parameter-declaration-clause of a function declaration or in a 378 // template-parameter (14.1). It shall not be specified for a 379 // parameter pack. If it is specified in a 380 // parameter-declaration-clause, it shall not occur within a 381 // declarator or abstract-declarator of a parameter-declaration. 382 bool MightBeFunction = D.isFunctionDeclarationContext(); 383 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 384 DeclaratorChunk &chunk = D.getTypeObject(i); 385 if (chunk.Kind == DeclaratorChunk::Function) { 386 if (MightBeFunction) { 387 // This is a function declaration. It can have default arguments, but 388 // keep looking in case its return type is a function type with default 389 // arguments. 390 MightBeFunction = false; 391 continue; 392 } 393 for (unsigned argIdx = 0, e = chunk.Fun.NumParams; argIdx != e; 394 ++argIdx) { 395 ParmVarDecl *Param = cast<ParmVarDecl>(chunk.Fun.Params[argIdx].Param); 396 if (Param->hasUnparsedDefaultArg()) { 397 CachedTokens *Toks = chunk.Fun.Params[argIdx].DefaultArgTokens; 398 SourceRange SR; 399 if (Toks->size() > 1) 400 SR = SourceRange((*Toks)[1].getLocation(), 401 Toks->back().getLocation()); 402 else 403 SR = UnparsedDefaultArgLocs[Param]; 404 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc) 405 << SR; 406 delete Toks; 407 chunk.Fun.Params[argIdx].DefaultArgTokens = nullptr; 408 } else if (Param->getDefaultArg()) { 409 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc) 410 << Param->getDefaultArg()->getSourceRange(); 411 Param->setDefaultArg(nullptr); 412 } 413 } 414 } else if (chunk.Kind != DeclaratorChunk::Paren) { 415 MightBeFunction = false; 416 } 417 } 418 } 419 420 static bool functionDeclHasDefaultArgument(const FunctionDecl *FD) { 421 for (unsigned NumParams = FD->getNumParams(); NumParams > 0; --NumParams) { 422 const ParmVarDecl *PVD = FD->getParamDecl(NumParams-1); 423 if (!PVD->hasDefaultArg()) 424 return false; 425 if (!PVD->hasInheritedDefaultArg()) 426 return true; 427 } 428 return false; 429 } 430 431 /// MergeCXXFunctionDecl - Merge two declarations of the same C++ 432 /// function, once we already know that they have the same 433 /// type. Subroutine of MergeFunctionDecl. Returns true if there was an 434 /// error, false otherwise. 435 bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, 436 Scope *S) { 437 bool Invalid = false; 438 439 // The declaration context corresponding to the scope is the semantic 440 // parent, unless this is a local function declaration, in which case 441 // it is that surrounding function. 442 DeclContext *ScopeDC = New->isLocalExternDecl() 443 ? New->getLexicalDeclContext() 444 : New->getDeclContext(); 445 446 // Find the previous declaration for the purpose of default arguments. 447 FunctionDecl *PrevForDefaultArgs = Old; 448 for (/**/; PrevForDefaultArgs; 449 // Don't bother looking back past the latest decl if this is a local 450 // extern declaration; nothing else could work. 451 PrevForDefaultArgs = New->isLocalExternDecl() 452 ? nullptr 453 : PrevForDefaultArgs->getPreviousDecl()) { 454 // Ignore hidden declarations. 455 if (!LookupResult::isVisible(*this, PrevForDefaultArgs)) 456 continue; 457 458 if (S && !isDeclInScope(PrevForDefaultArgs, ScopeDC, S) && 459 !New->isCXXClassMember()) { 460 // Ignore default arguments of old decl if they are not in 461 // the same scope and this is not an out-of-line definition of 462 // a member function. 463 continue; 464 } 465 466 if (PrevForDefaultArgs->isLocalExternDecl() != New->isLocalExternDecl()) { 467 // If only one of these is a local function declaration, then they are 468 // declared in different scopes, even though isDeclInScope may think 469 // they're in the same scope. (If both are local, the scope check is 470 // sufficent, and if neither is local, then they are in the same scope.) 471 continue; 472 } 473 474 // We found our guy. 475 break; 476 } 477 478 // C++ [dcl.fct.default]p4: 479 // For non-template functions, default arguments can be added in 480 // later declarations of a function in the same 481 // scope. Declarations in different scopes have completely 482 // distinct sets of default arguments. That is, declarations in 483 // inner scopes do not acquire default arguments from 484 // declarations in outer scopes, and vice versa. In a given 485 // function declaration, all parameters subsequent to a 486 // parameter with a default argument shall have default 487 // arguments supplied in this or previous declarations. A 488 // default argument shall not be redefined by a later 489 // declaration (not even to the same value). 490 // 491 // C++ [dcl.fct.default]p6: 492 // Except for member functions of class templates, the default arguments 493 // in a member function definition that appears outside of the class 494 // definition are added to the set of default arguments provided by the 495 // member function declaration in the class definition. 496 for (unsigned p = 0, NumParams = PrevForDefaultArgs 497 ? PrevForDefaultArgs->getNumParams() 498 : 0; 499 p < NumParams; ++p) { 500 ParmVarDecl *OldParam = PrevForDefaultArgs->getParamDecl(p); 501 ParmVarDecl *NewParam = New->getParamDecl(p); 502 503 bool OldParamHasDfl = OldParam ? OldParam->hasDefaultArg() : false; 504 bool NewParamHasDfl = NewParam->hasDefaultArg(); 505 506 if (OldParamHasDfl && NewParamHasDfl) { 507 unsigned DiagDefaultParamID = 508 diag::err_param_default_argument_redefinition; 509 510 // MSVC accepts that default parameters be redefined for member functions 511 // of template class. The new default parameter's value is ignored. 512 Invalid = true; 513 if (getLangOpts().MicrosoftExt) { 514 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(New); 515 if (MD && MD->getParent()->getDescribedClassTemplate()) { 516 // Merge the old default argument into the new parameter. 517 NewParam->setHasInheritedDefaultArg(); 518 if (OldParam->hasUninstantiatedDefaultArg()) 519 NewParam->setUninstantiatedDefaultArg( 520 OldParam->getUninstantiatedDefaultArg()); 521 else 522 NewParam->setDefaultArg(OldParam->getInit()); 523 DiagDefaultParamID = diag::ext_param_default_argument_redefinition; 524 Invalid = false; 525 } 526 } 527 528 // FIXME: If we knew where the '=' was, we could easily provide a fix-it 529 // hint here. Alternatively, we could walk the type-source information 530 // for NewParam to find the last source location in the type... but it 531 // isn't worth the effort right now. This is the kind of test case that 532 // is hard to get right: 533 // int f(int); 534 // void g(int (*fp)(int) = f); 535 // void g(int (*fp)(int) = &f); 536 Diag(NewParam->getLocation(), DiagDefaultParamID) 537 << NewParam->getDefaultArgRange(); 538 539 // Look for the function declaration where the default argument was 540 // actually written, which may be a declaration prior to Old. 541 for (auto Older = PrevForDefaultArgs; 542 OldParam->hasInheritedDefaultArg(); /**/) { 543 Older = Older->getPreviousDecl(); 544 OldParam = Older->getParamDecl(p); 545 } 546 547 Diag(OldParam->getLocation(), diag::note_previous_definition) 548 << OldParam->getDefaultArgRange(); 549 } else if (OldParamHasDfl) { 550 // Merge the old default argument into the new parameter. 551 // It's important to use getInit() here; getDefaultArg() 552 // strips off any top-level ExprWithCleanups. 553 NewParam->setHasInheritedDefaultArg(); 554 if (OldParam->hasUnparsedDefaultArg()) 555 NewParam->setUnparsedDefaultArg(); 556 else if (OldParam->hasUninstantiatedDefaultArg()) 557 NewParam->setUninstantiatedDefaultArg( 558 OldParam->getUninstantiatedDefaultArg()); 559 else 560 NewParam->setDefaultArg(OldParam->getInit()); 561 } else if (NewParamHasDfl) { 562 if (New->getDescribedFunctionTemplate()) { 563 // Paragraph 4, quoted above, only applies to non-template functions. 564 Diag(NewParam->getLocation(), 565 diag::err_param_default_argument_template_redecl) 566 << NewParam->getDefaultArgRange(); 567 Diag(PrevForDefaultArgs->getLocation(), 568 diag::note_template_prev_declaration) 569 << false; 570 } else if (New->getTemplateSpecializationKind() 571 != TSK_ImplicitInstantiation && 572 New->getTemplateSpecializationKind() != TSK_Undeclared) { 573 // C++ [temp.expr.spec]p21: 574 // Default function arguments shall not be specified in a declaration 575 // or a definition for one of the following explicit specializations: 576 // - the explicit specialization of a function template; 577 // - the explicit specialization of a member function template; 578 // - the explicit specialization of a member function of a class 579 // template where the class template specialization to which the 580 // member function specialization belongs is implicitly 581 // instantiated. 582 Diag(NewParam->getLocation(), diag::err_template_spec_default_arg) 583 << (New->getTemplateSpecializationKind() ==TSK_ExplicitSpecialization) 584 << New->getDeclName() 585 << NewParam->getDefaultArgRange(); 586 } else if (New->getDeclContext()->isDependentContext()) { 587 // C++ [dcl.fct.default]p6 (DR217): 588 // Default arguments for a member function of a class template shall 589 // be specified on the initial declaration of the member function 590 // within the class template. 591 // 592 // Reading the tea leaves a bit in DR217 and its reference to DR205 593 // leads me to the conclusion that one cannot add default function 594 // arguments for an out-of-line definition of a member function of a 595 // dependent type. 596 int WhichKind = 2; 597 if (CXXRecordDecl *Record 598 = dyn_cast<CXXRecordDecl>(New->getDeclContext())) { 599 if (Record->getDescribedClassTemplate()) 600 WhichKind = 0; 601 else if (isa<ClassTemplatePartialSpecializationDecl>(Record)) 602 WhichKind = 1; 603 else 604 WhichKind = 2; 605 } 606 607 Diag(NewParam->getLocation(), 608 diag::err_param_default_argument_member_template_redecl) 609 << WhichKind 610 << NewParam->getDefaultArgRange(); 611 } 612 } 613 } 614 615 // DR1344: If a default argument is added outside a class definition and that 616 // default argument makes the function a special member function, the program 617 // is ill-formed. This can only happen for constructors. 618 if (isa<CXXConstructorDecl>(New) && 619 New->getMinRequiredArguments() < Old->getMinRequiredArguments()) { 620 CXXSpecialMember NewSM = getSpecialMember(cast<CXXMethodDecl>(New)), 621 OldSM = getSpecialMember(cast<CXXMethodDecl>(Old)); 622 if (NewSM != OldSM) { 623 ParmVarDecl *NewParam = New->getParamDecl(New->getMinRequiredArguments()); 624 assert(NewParam->hasDefaultArg()); 625 Diag(NewParam->getLocation(), diag::err_default_arg_makes_ctor_special) 626 << NewParam->getDefaultArgRange() << NewSM; 627 Diag(Old->getLocation(), diag::note_previous_declaration); 628 } 629 } 630 631 const FunctionDecl *Def; 632 // C++11 [dcl.constexpr]p1: If any declaration of a function or function 633 // template has a constexpr specifier then all its declarations shall 634 // contain the constexpr specifier. 635 if (New->isConstexpr() != Old->isConstexpr()) { 636 Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch) 637 << New << New->isConstexpr(); 638 Diag(Old->getLocation(), diag::note_previous_declaration); 639 Invalid = true; 640 } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() && 641 Old->isDefined(Def)) { 642 // C++11 [dcl.fcn.spec]p4: 643 // If the definition of a function appears in a translation unit before its 644 // first declaration as inline, the program is ill-formed. 645 Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New; 646 Diag(Def->getLocation(), diag::note_previous_definition); 647 Invalid = true; 648 } 649 650 // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default 651 // argument expression, that declaration shall be a definition and shall be 652 // the only declaration of the function or function template in the 653 // translation unit. 654 if (Old->getFriendObjectKind() == Decl::FOK_Undeclared && 655 functionDeclHasDefaultArgument(Old)) { 656 Diag(New->getLocation(), diag::err_friend_decl_with_def_arg_redeclared); 657 Diag(Old->getLocation(), diag::note_previous_declaration); 658 Invalid = true; 659 } 660 661 if (CheckEquivalentExceptionSpec(Old, New)) 662 Invalid = true; 663 664 return Invalid; 665 } 666 667 /// \brief Merge the exception specifications of two variable declarations. 668 /// 669 /// This is called when there's a redeclaration of a VarDecl. The function 670 /// checks if the redeclaration might have an exception specification and 671 /// validates compatibility and merges the specs if necessary. 672 void Sema::MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old) { 673 // Shortcut if exceptions are disabled. 674 if (!getLangOpts().CXXExceptions) 675 return; 676 677 assert(Context.hasSameType(New->getType(), Old->getType()) && 678 "Should only be called if types are otherwise the same."); 679 680 QualType NewType = New->getType(); 681 QualType OldType = Old->getType(); 682 683 // We're only interested in pointers and references to functions, as well 684 // as pointers to member functions. 685 if (const ReferenceType *R = NewType->getAs<ReferenceType>()) { 686 NewType = R->getPointeeType(); 687 OldType = OldType->getAs<ReferenceType>()->getPointeeType(); 688 } else if (const PointerType *P = NewType->getAs<PointerType>()) { 689 NewType = P->getPointeeType(); 690 OldType = OldType->getAs<PointerType>()->getPointeeType(); 691 } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) { 692 NewType = M->getPointeeType(); 693 OldType = OldType->getAs<MemberPointerType>()->getPointeeType(); 694 } 695 696 if (!NewType->isFunctionProtoType()) 697 return; 698 699 // There's lots of special cases for functions. For function pointers, system 700 // libraries are hopefully not as broken so that we don't need these 701 // workarounds. 702 if (CheckEquivalentExceptionSpec( 703 OldType->getAs<FunctionProtoType>(), Old->getLocation(), 704 NewType->getAs<FunctionProtoType>(), New->getLocation())) { 705 New->setInvalidDecl(); 706 } 707 } 708 709 /// CheckCXXDefaultArguments - Verify that the default arguments for a 710 /// function declaration are well-formed according to C++ 711 /// [dcl.fct.default]. 712 void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) { 713 unsigned NumParams = FD->getNumParams(); 714 unsigned p; 715 716 // Find first parameter with a default argument 717 for (p = 0; p < NumParams; ++p) { 718 ParmVarDecl *Param = FD->getParamDecl(p); 719 if (Param->hasDefaultArg()) 720 break; 721 } 722 723 // C++11 [dcl.fct.default]p4: 724 // In a given function declaration, each parameter subsequent to a parameter 725 // with a default argument shall have a default argument supplied in this or 726 // a previous declaration or shall be a function parameter pack. A default 727 // argument shall not be redefined by a later declaration (not even to the 728 // same value). 729 unsigned LastMissingDefaultArg = 0; 730 for (; p < NumParams; ++p) { 731 ParmVarDecl *Param = FD->getParamDecl(p); 732 if (!Param->hasDefaultArg() && !Param->isParameterPack()) { 733 if (Param->isInvalidDecl()) 734 /* We already complained about this parameter. */; 735 else if (Param->getIdentifier()) 736 Diag(Param->getLocation(), 737 diag::err_param_default_argument_missing_name) 738 << Param->getIdentifier(); 739 else 740 Diag(Param->getLocation(), 741 diag::err_param_default_argument_missing); 742 743 LastMissingDefaultArg = p; 744 } 745 } 746 747 if (LastMissingDefaultArg > 0) { 748 // Some default arguments were missing. Clear out all of the 749 // default arguments up to (and including) the last missing 750 // default argument, so that we leave the function parameters 751 // in a semantically valid state. 752 for (p = 0; p <= LastMissingDefaultArg; ++p) { 753 ParmVarDecl *Param = FD->getParamDecl(p); 754 if (Param->hasDefaultArg()) { 755 Param->setDefaultArg(nullptr); 756 } 757 } 758 } 759 } 760 761 // CheckConstexprParameterTypes - Check whether a function's parameter types 762 // are all literal types. If so, return true. If not, produce a suitable 763 // diagnostic and return false. 764 static bool CheckConstexprParameterTypes(Sema &SemaRef, 765 const FunctionDecl *FD) { 766 unsigned ArgIndex = 0; 767 const FunctionProtoType *FT = FD->getType()->getAs<FunctionProtoType>(); 768 for (FunctionProtoType::param_type_iterator i = FT->param_type_begin(), 769 e = FT->param_type_end(); 770 i != e; ++i, ++ArgIndex) { 771 const ParmVarDecl *PD = FD->getParamDecl(ArgIndex); 772 SourceLocation ParamLoc = PD->getLocation(); 773 if (!(*i)->isDependentType() && 774 SemaRef.RequireLiteralType(ParamLoc, *i, 775 diag::err_constexpr_non_literal_param, 776 ArgIndex+1, PD->getSourceRange(), 777 isa<CXXConstructorDecl>(FD))) 778 return false; 779 } 780 return true; 781 } 782 783 /// \brief Get diagnostic %select index for tag kind for 784 /// record diagnostic message. 785 /// WARNING: Indexes apply to particular diagnostics only! 786 /// 787 /// \returns diagnostic %select index. 788 static unsigned getRecordDiagFromTagKind(TagTypeKind Tag) { 789 switch (Tag) { 790 case TTK_Struct: return 0; 791 case TTK_Interface: return 1; 792 case TTK_Class: return 2; 793 default: llvm_unreachable("Invalid tag kind for record diagnostic!"); 794 } 795 } 796 797 // CheckConstexprFunctionDecl - Check whether a function declaration satisfies 798 // the requirements of a constexpr function definition or a constexpr 799 // constructor definition. If so, return true. If not, produce appropriate 800 // diagnostics and return false. 801 // 802 // This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360. 803 bool Sema::CheckConstexprFunctionDecl(const FunctionDecl *NewFD) { 804 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 805 if (MD && MD->isInstance()) { 806 // C++11 [dcl.constexpr]p4: 807 // The definition of a constexpr constructor shall satisfy the following 808 // constraints: 809 // - the class shall not have any virtual base classes; 810 const CXXRecordDecl *RD = MD->getParent(); 811 if (RD->getNumVBases()) { 812 Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base) 813 << isa<CXXConstructorDecl>(NewFD) 814 << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getNumVBases(); 815 for (const auto &I : RD->vbases()) 816 Diag(I.getLocStart(), 817 diag::note_constexpr_virtual_base_here) << I.getSourceRange(); 818 return false; 819 } 820 } 821 822 if (!isa<CXXConstructorDecl>(NewFD)) { 823 // C++11 [dcl.constexpr]p3: 824 // The definition of a constexpr function shall satisfy the following 825 // constraints: 826 // - it shall not be virtual; 827 const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD); 828 if (Method && Method->isVirtual()) { 829 Method = Method->getCanonicalDecl(); 830 Diag(Method->getLocation(), diag::err_constexpr_virtual); 831 832 // If it's not obvious why this function is virtual, find an overridden 833 // function which uses the 'virtual' keyword. 834 const CXXMethodDecl *WrittenVirtual = Method; 835 while (!WrittenVirtual->isVirtualAsWritten()) 836 WrittenVirtual = *WrittenVirtual->begin_overridden_methods(); 837 if (WrittenVirtual != Method) 838 Diag(WrittenVirtual->getLocation(), 839 diag::note_overridden_virtual_function); 840 return false; 841 } 842 843 // - its return type shall be a literal type; 844 QualType RT = NewFD->getReturnType(); 845 if (!RT->isDependentType() && 846 RequireLiteralType(NewFD->getLocation(), RT, 847 diag::err_constexpr_non_literal_return)) 848 return false; 849 } 850 851 // - each of its parameter types shall be a literal type; 852 if (!CheckConstexprParameterTypes(*this, NewFD)) 853 return false; 854 855 return true; 856 } 857 858 /// Check the given declaration statement is legal within a constexpr function 859 /// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3. 860 /// 861 /// \return true if the body is OK (maybe only as an extension), false if we 862 /// have diagnosed a problem. 863 static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl, 864 DeclStmt *DS, SourceLocation &Cxx1yLoc) { 865 // C++11 [dcl.constexpr]p3 and p4: 866 // The definition of a constexpr function(p3) or constructor(p4) [...] shall 867 // contain only 868 for (const auto *DclIt : DS->decls()) { 869 switch (DclIt->getKind()) { 870 case Decl::StaticAssert: 871 case Decl::Using: 872 case Decl::UsingShadow: 873 case Decl::UsingDirective: 874 case Decl::UnresolvedUsingTypename: 875 case Decl::UnresolvedUsingValue: 876 // - static_assert-declarations 877 // - using-declarations, 878 // - using-directives, 879 continue; 880 881 case Decl::Typedef: 882 case Decl::TypeAlias: { 883 // - typedef declarations and alias-declarations that do not define 884 // classes or enumerations, 885 const auto *TN = cast<TypedefNameDecl>(DclIt); 886 if (TN->getUnderlyingType()->isVariablyModifiedType()) { 887 // Don't allow variably-modified types in constexpr functions. 888 TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc(); 889 SemaRef.Diag(TL.getBeginLoc(), diag::err_constexpr_vla) 890 << TL.getSourceRange() << TL.getType() 891 << isa<CXXConstructorDecl>(Dcl); 892 return false; 893 } 894 continue; 895 } 896 897 case Decl::Enum: 898 case Decl::CXXRecord: 899 // C++1y allows types to be defined, not just declared. 900 if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition()) 901 SemaRef.Diag(DS->getLocStart(), 902 SemaRef.getLangOpts().CPlusPlus14 903 ? diag::warn_cxx11_compat_constexpr_type_definition 904 : diag::ext_constexpr_type_definition) 905 << isa<CXXConstructorDecl>(Dcl); 906 continue; 907 908 case Decl::EnumConstant: 909 case Decl::IndirectField: 910 case Decl::ParmVar: 911 // These can only appear with other declarations which are banned in 912 // C++11 and permitted in C++1y, so ignore them. 913 continue; 914 915 case Decl::Var: { 916 // C++1y [dcl.constexpr]p3 allows anything except: 917 // a definition of a variable of non-literal type or of static or 918 // thread storage duration or for which no initialization is performed. 919 const auto *VD = cast<VarDecl>(DclIt); 920 if (VD->isThisDeclarationADefinition()) { 921 if (VD->isStaticLocal()) { 922 SemaRef.Diag(VD->getLocation(), 923 diag::err_constexpr_local_var_static) 924 << isa<CXXConstructorDecl>(Dcl) 925 << (VD->getTLSKind() == VarDecl::TLS_Dynamic); 926 return false; 927 } 928 if (!VD->getType()->isDependentType() && 929 SemaRef.RequireLiteralType( 930 VD->getLocation(), VD->getType(), 931 diag::err_constexpr_local_var_non_literal_type, 932 isa<CXXConstructorDecl>(Dcl))) 933 return false; 934 if (!VD->getType()->isDependentType() && 935 !VD->hasInit() && !VD->isCXXForRangeDecl()) { 936 SemaRef.Diag(VD->getLocation(), 937 diag::err_constexpr_local_var_no_init) 938 << isa<CXXConstructorDecl>(Dcl); 939 return false; 940 } 941 } 942 SemaRef.Diag(VD->getLocation(), 943 SemaRef.getLangOpts().CPlusPlus14 944 ? diag::warn_cxx11_compat_constexpr_local_var 945 : diag::ext_constexpr_local_var) 946 << isa<CXXConstructorDecl>(Dcl); 947 continue; 948 } 949 950 case Decl::NamespaceAlias: 951 case Decl::Function: 952 // These are disallowed in C++11 and permitted in C++1y. Allow them 953 // everywhere as an extension. 954 if (!Cxx1yLoc.isValid()) 955 Cxx1yLoc = DS->getLocStart(); 956 continue; 957 958 default: 959 SemaRef.Diag(DS->getLocStart(), diag::err_constexpr_body_invalid_stmt) 960 << isa<CXXConstructorDecl>(Dcl); 961 return false; 962 } 963 } 964 965 return true; 966 } 967 968 /// Check that the given field is initialized within a constexpr constructor. 969 /// 970 /// \param Dcl The constexpr constructor being checked. 971 /// \param Field The field being checked. This may be a member of an anonymous 972 /// struct or union nested within the class being checked. 973 /// \param Inits All declarations, including anonymous struct/union members and 974 /// indirect members, for which any initialization was provided. 975 /// \param Diagnosed Set to true if an error is produced. 976 static void CheckConstexprCtorInitializer(Sema &SemaRef, 977 const FunctionDecl *Dcl, 978 FieldDecl *Field, 979 llvm::SmallSet<Decl*, 16> &Inits, 980 bool &Diagnosed) { 981 if (Field->isInvalidDecl()) 982 return; 983 984 if (Field->isUnnamedBitfield()) 985 return; 986 987 // Anonymous unions with no variant members and empty anonymous structs do not 988 // need to be explicitly initialized. FIXME: Anonymous structs that contain no 989 // indirect fields don't need initializing. 990 if (Field->isAnonymousStructOrUnion() && 991 (Field->getType()->isUnionType() 992 ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers() 993 : Field->getType()->getAsCXXRecordDecl()->isEmpty())) 994 return; 995 996 if (!Inits.count(Field)) { 997 if (!Diagnosed) { 998 SemaRef.Diag(Dcl->getLocation(), diag::err_constexpr_ctor_missing_init); 999 Diagnosed = true; 1000 } 1001 SemaRef.Diag(Field->getLocation(), diag::note_constexpr_ctor_missing_init); 1002 } else if (Field->isAnonymousStructOrUnion()) { 1003 const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl(); 1004 for (auto *I : RD->fields()) 1005 // If an anonymous union contains an anonymous struct of which any member 1006 // is initialized, all members must be initialized. 1007 if (!RD->isUnion() || Inits.count(I)) 1008 CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed); 1009 } 1010 } 1011 1012 /// Check the provided statement is allowed in a constexpr function 1013 /// definition. 1014 static bool 1015 CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S, 1016 SmallVectorImpl<SourceLocation> &ReturnStmts, 1017 SourceLocation &Cxx1yLoc) { 1018 // - its function-body shall be [...] a compound-statement that contains only 1019 switch (S->getStmtClass()) { 1020 case Stmt::NullStmtClass: 1021 // - null statements, 1022 return true; 1023 1024 case Stmt::DeclStmtClass: 1025 // - static_assert-declarations 1026 // - using-declarations, 1027 // - using-directives, 1028 // - typedef declarations and alias-declarations that do not define 1029 // classes or enumerations, 1030 if (!CheckConstexprDeclStmt(SemaRef, Dcl, cast<DeclStmt>(S), Cxx1yLoc)) 1031 return false; 1032 return true; 1033 1034 case Stmt::ReturnStmtClass: 1035 // - and exactly one return statement; 1036 if (isa<CXXConstructorDecl>(Dcl)) { 1037 // C++1y allows return statements in constexpr constructors. 1038 if (!Cxx1yLoc.isValid()) 1039 Cxx1yLoc = S->getLocStart(); 1040 return true; 1041 } 1042 1043 ReturnStmts.push_back(S->getLocStart()); 1044 return true; 1045 1046 case Stmt::CompoundStmtClass: { 1047 // C++1y allows compound-statements. 1048 if (!Cxx1yLoc.isValid()) 1049 Cxx1yLoc = S->getLocStart(); 1050 1051 CompoundStmt *CompStmt = cast<CompoundStmt>(S); 1052 for (auto *BodyIt : CompStmt->body()) { 1053 if (!CheckConstexprFunctionStmt(SemaRef, Dcl, BodyIt, ReturnStmts, 1054 Cxx1yLoc)) 1055 return false; 1056 } 1057 return true; 1058 } 1059 1060 case Stmt::AttributedStmtClass: 1061 if (!Cxx1yLoc.isValid()) 1062 Cxx1yLoc = S->getLocStart(); 1063 return true; 1064 1065 case Stmt::IfStmtClass: { 1066 // C++1y allows if-statements. 1067 if (!Cxx1yLoc.isValid()) 1068 Cxx1yLoc = S->getLocStart(); 1069 1070 IfStmt *If = cast<IfStmt>(S); 1071 if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts, 1072 Cxx1yLoc)) 1073 return false; 1074 if (If->getElse() && 1075 !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts, 1076 Cxx1yLoc)) 1077 return false; 1078 return true; 1079 } 1080 1081 case Stmt::WhileStmtClass: 1082 case Stmt::DoStmtClass: 1083 case Stmt::ForStmtClass: 1084 case Stmt::CXXForRangeStmtClass: 1085 case Stmt::ContinueStmtClass: 1086 // C++1y allows all of these. We don't allow them as extensions in C++11, 1087 // because they don't make sense without variable mutation. 1088 if (!SemaRef.getLangOpts().CPlusPlus14) 1089 break; 1090 if (!Cxx1yLoc.isValid()) 1091 Cxx1yLoc = S->getLocStart(); 1092 for (Stmt *SubStmt : S->children()) 1093 if (SubStmt && 1094 !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts, 1095 Cxx1yLoc)) 1096 return false; 1097 return true; 1098 1099 case Stmt::SwitchStmtClass: 1100 case Stmt::CaseStmtClass: 1101 case Stmt::DefaultStmtClass: 1102 case Stmt::BreakStmtClass: 1103 // C++1y allows switch-statements, and since they don't need variable 1104 // mutation, we can reasonably allow them in C++11 as an extension. 1105 if (!Cxx1yLoc.isValid()) 1106 Cxx1yLoc = S->getLocStart(); 1107 for (Stmt *SubStmt : S->children()) 1108 if (SubStmt && 1109 !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts, 1110 Cxx1yLoc)) 1111 return false; 1112 return true; 1113 1114 default: 1115 if (!isa<Expr>(S)) 1116 break; 1117 1118 // C++1y allows expression-statements. 1119 if (!Cxx1yLoc.isValid()) 1120 Cxx1yLoc = S->getLocStart(); 1121 return true; 1122 } 1123 1124 SemaRef.Diag(S->getLocStart(), diag::err_constexpr_body_invalid_stmt) 1125 << isa<CXXConstructorDecl>(Dcl); 1126 return false; 1127 } 1128 1129 /// Check the body for the given constexpr function declaration only contains 1130 /// the permitted types of statement. C++11 [dcl.constexpr]p3,p4. 1131 /// 1132 /// \return true if the body is OK, false if we have diagnosed a problem. 1133 bool Sema::CheckConstexprFunctionBody(const FunctionDecl *Dcl, Stmt *Body) { 1134 if (isa<CXXTryStmt>(Body)) { 1135 // C++11 [dcl.constexpr]p3: 1136 // The definition of a constexpr function shall satisfy the following 1137 // constraints: [...] 1138 // - its function-body shall be = delete, = default, or a 1139 // compound-statement 1140 // 1141 // C++11 [dcl.constexpr]p4: 1142 // In the definition of a constexpr constructor, [...] 1143 // - its function-body shall not be a function-try-block; 1144 Diag(Body->getLocStart(), diag::err_constexpr_function_try_block) 1145 << isa<CXXConstructorDecl>(Dcl); 1146 return false; 1147 } 1148 1149 SmallVector<SourceLocation, 4> ReturnStmts; 1150 1151 // - its function-body shall be [...] a compound-statement that contains only 1152 // [... list of cases ...] 1153 CompoundStmt *CompBody = cast<CompoundStmt>(Body); 1154 SourceLocation Cxx1yLoc; 1155 for (auto *BodyIt : CompBody->body()) { 1156 if (!CheckConstexprFunctionStmt(*this, Dcl, BodyIt, ReturnStmts, Cxx1yLoc)) 1157 return false; 1158 } 1159 1160 if (Cxx1yLoc.isValid()) 1161 Diag(Cxx1yLoc, 1162 getLangOpts().CPlusPlus14 1163 ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt 1164 : diag::ext_constexpr_body_invalid_stmt) 1165 << isa<CXXConstructorDecl>(Dcl); 1166 1167 if (const CXXConstructorDecl *Constructor 1168 = dyn_cast<CXXConstructorDecl>(Dcl)) { 1169 const CXXRecordDecl *RD = Constructor->getParent(); 1170 // DR1359: 1171 // - every non-variant non-static data member and base class sub-object 1172 // shall be initialized; 1173 // DR1460: 1174 // - if the class is a union having variant members, exactly one of them 1175 // shall be initialized; 1176 if (RD->isUnion()) { 1177 if (Constructor->getNumCtorInitializers() == 0 && 1178 RD->hasVariantMembers()) { 1179 Diag(Dcl->getLocation(), diag::err_constexpr_union_ctor_no_init); 1180 return false; 1181 } 1182 } else if (!Constructor->isDependentContext() && 1183 !Constructor->isDelegatingConstructor()) { 1184 assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases"); 1185 1186 // Skip detailed checking if we have enough initializers, and we would 1187 // allow at most one initializer per member. 1188 bool AnyAnonStructUnionMembers = false; 1189 unsigned Fields = 0; 1190 for (CXXRecordDecl::field_iterator I = RD->field_begin(), 1191 E = RD->field_end(); I != E; ++I, ++Fields) { 1192 if (I->isAnonymousStructOrUnion()) { 1193 AnyAnonStructUnionMembers = true; 1194 break; 1195 } 1196 } 1197 // DR1460: 1198 // - if the class is a union-like class, but is not a union, for each of 1199 // its anonymous union members having variant members, exactly one of 1200 // them shall be initialized; 1201 if (AnyAnonStructUnionMembers || 1202 Constructor->getNumCtorInitializers() != RD->getNumBases() + Fields) { 1203 // Check initialization of non-static data members. Base classes are 1204 // always initialized so do not need to be checked. Dependent bases 1205 // might not have initializers in the member initializer list. 1206 llvm::SmallSet<Decl*, 16> Inits; 1207 for (const auto *I: Constructor->inits()) { 1208 if (FieldDecl *FD = I->getMember()) 1209 Inits.insert(FD); 1210 else if (IndirectFieldDecl *ID = I->getIndirectMember()) 1211 Inits.insert(ID->chain_begin(), ID->chain_end()); 1212 } 1213 1214 bool Diagnosed = false; 1215 for (auto *I : RD->fields()) 1216 CheckConstexprCtorInitializer(*this, Dcl, I, Inits, Diagnosed); 1217 if (Diagnosed) 1218 return false; 1219 } 1220 } 1221 } else { 1222 if (ReturnStmts.empty()) { 1223 // C++1y doesn't require constexpr functions to contain a 'return' 1224 // statement. We still do, unless the return type might be void, because 1225 // otherwise if there's no return statement, the function cannot 1226 // be used in a core constant expression. 1227 bool OK = getLangOpts().CPlusPlus14 && 1228 (Dcl->getReturnType()->isVoidType() || 1229 Dcl->getReturnType()->isDependentType()); 1230 Diag(Dcl->getLocation(), 1231 OK ? diag::warn_cxx11_compat_constexpr_body_no_return 1232 : diag::err_constexpr_body_no_return); 1233 if (!OK) 1234 return false; 1235 } else if (ReturnStmts.size() > 1) { 1236 Diag(ReturnStmts.back(), 1237 getLangOpts().CPlusPlus14 1238 ? diag::warn_cxx11_compat_constexpr_body_multiple_return 1239 : diag::ext_constexpr_body_multiple_return); 1240 for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I) 1241 Diag(ReturnStmts[I], diag::note_constexpr_body_previous_return); 1242 } 1243 } 1244 1245 // C++11 [dcl.constexpr]p5: 1246 // if no function argument values exist such that the function invocation 1247 // substitution would produce a constant expression, the program is 1248 // ill-formed; no diagnostic required. 1249 // C++11 [dcl.constexpr]p3: 1250 // - every constructor call and implicit conversion used in initializing the 1251 // return value shall be one of those allowed in a constant expression. 1252 // C++11 [dcl.constexpr]p4: 1253 // - every constructor involved in initializing non-static data members and 1254 // base class sub-objects shall be a constexpr constructor. 1255 SmallVector<PartialDiagnosticAt, 8> Diags; 1256 if (!Expr::isPotentialConstantExpr(Dcl, Diags)) { 1257 Diag(Dcl->getLocation(), diag::ext_constexpr_function_never_constant_expr) 1258 << isa<CXXConstructorDecl>(Dcl); 1259 for (size_t I = 0, N = Diags.size(); I != N; ++I) 1260 Diag(Diags[I].first, Diags[I].second); 1261 // Don't return false here: we allow this for compatibility in 1262 // system headers. 1263 } 1264 1265 return true; 1266 } 1267 1268 /// isCurrentClassName - Determine whether the identifier II is the 1269 /// name of the class type currently being defined. In the case of 1270 /// nested classes, this will only return true if II is the name of 1271 /// the innermost class. 1272 bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *, 1273 const CXXScopeSpec *SS) { 1274 assert(getLangOpts().CPlusPlus && "No class names in C!"); 1275 1276 CXXRecordDecl *CurDecl; 1277 if (SS && SS->isSet() && !SS->isInvalid()) { 1278 DeclContext *DC = computeDeclContext(*SS, true); 1279 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC); 1280 } else 1281 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext); 1282 1283 if (CurDecl && CurDecl->getIdentifier()) 1284 return &II == CurDecl->getIdentifier(); 1285 return false; 1286 } 1287 1288 /// \brief Determine whether the identifier II is a typo for the name of 1289 /// the class type currently being defined. If so, update it to the identifier 1290 /// that should have been used. 1291 bool Sema::isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS) { 1292 assert(getLangOpts().CPlusPlus && "No class names in C!"); 1293 1294 if (!getLangOpts().SpellChecking) 1295 return false; 1296 1297 CXXRecordDecl *CurDecl; 1298 if (SS && SS->isSet() && !SS->isInvalid()) { 1299 DeclContext *DC = computeDeclContext(*SS, true); 1300 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC); 1301 } else 1302 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext); 1303 1304 if (CurDecl && CurDecl->getIdentifier() && II != CurDecl->getIdentifier() && 1305 3 * II->getName().edit_distance(CurDecl->getIdentifier()->getName()) 1306 < II->getLength()) { 1307 II = CurDecl->getIdentifier(); 1308 return true; 1309 } 1310 1311 return false; 1312 } 1313 1314 /// \brief Determine whether the given class is a base class of the given 1315 /// class, including looking at dependent bases. 1316 static bool findCircularInheritance(const CXXRecordDecl *Class, 1317 const CXXRecordDecl *Current) { 1318 SmallVector<const CXXRecordDecl*, 8> Queue; 1319 1320 Class = Class->getCanonicalDecl(); 1321 while (true) { 1322 for (const auto &I : Current->bases()) { 1323 CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl(); 1324 if (!Base) 1325 continue; 1326 1327 Base = Base->getDefinition(); 1328 if (!Base) 1329 continue; 1330 1331 if (Base->getCanonicalDecl() == Class) 1332 return true; 1333 1334 Queue.push_back(Base); 1335 } 1336 1337 if (Queue.empty()) 1338 return false; 1339 1340 Current = Queue.pop_back_val(); 1341 } 1342 1343 return false; 1344 } 1345 1346 /// \brief Check the validity of a C++ base class specifier. 1347 /// 1348 /// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics 1349 /// and returns NULL otherwise. 1350 CXXBaseSpecifier * 1351 Sema::CheckBaseSpecifier(CXXRecordDecl *Class, 1352 SourceRange SpecifierRange, 1353 bool Virtual, AccessSpecifier Access, 1354 TypeSourceInfo *TInfo, 1355 SourceLocation EllipsisLoc) { 1356 QualType BaseType = TInfo->getType(); 1357 1358 // C++ [class.union]p1: 1359 // A union shall not have base classes. 1360 if (Class->isUnion()) { 1361 Diag(Class->getLocation(), diag::err_base_clause_on_union) 1362 << SpecifierRange; 1363 return nullptr; 1364 } 1365 1366 if (EllipsisLoc.isValid() && 1367 !TInfo->getType()->containsUnexpandedParameterPack()) { 1368 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) 1369 << TInfo->getTypeLoc().getSourceRange(); 1370 EllipsisLoc = SourceLocation(); 1371 } 1372 1373 SourceLocation BaseLoc = TInfo->getTypeLoc().getBeginLoc(); 1374 1375 if (BaseType->isDependentType()) { 1376 // Make sure that we don't have circular inheritance among our dependent 1377 // bases. For non-dependent bases, the check for completeness below handles 1378 // this. 1379 if (CXXRecordDecl *BaseDecl = BaseType->getAsCXXRecordDecl()) { 1380 if (BaseDecl->getCanonicalDecl() == Class->getCanonicalDecl() || 1381 ((BaseDecl = BaseDecl->getDefinition()) && 1382 findCircularInheritance(Class, BaseDecl))) { 1383 Diag(BaseLoc, diag::err_circular_inheritance) 1384 << BaseType << Context.getTypeDeclType(Class); 1385 1386 if (BaseDecl->getCanonicalDecl() != Class->getCanonicalDecl()) 1387 Diag(BaseDecl->getLocation(), diag::note_previous_decl) 1388 << BaseType; 1389 1390 return nullptr; 1391 } 1392 } 1393 1394 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual, 1395 Class->getTagKind() == TTK_Class, 1396 Access, TInfo, EllipsisLoc); 1397 } 1398 1399 // Base specifiers must be record types. 1400 if (!BaseType->isRecordType()) { 1401 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange; 1402 return nullptr; 1403 } 1404 1405 // C++ [class.union]p1: 1406 // A union shall not be used as a base class. 1407 if (BaseType->isUnionType()) { 1408 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange; 1409 return nullptr; 1410 } 1411 1412 // For the MS ABI, propagate DLL attributes to base class templates. 1413 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) { 1414 if (Attr *ClassAttr = getDLLAttr(Class)) { 1415 if (auto *BaseTemplate = dyn_cast_or_null<ClassTemplateSpecializationDecl>( 1416 BaseType->getAsCXXRecordDecl())) { 1417 propagateDLLAttrToBaseClassTemplate(Class, ClassAttr, BaseTemplate, 1418 BaseLoc); 1419 } 1420 } 1421 } 1422 1423 // C++ [class.derived]p2: 1424 // The class-name in a base-specifier shall not be an incompletely 1425 // defined class. 1426 if (RequireCompleteType(BaseLoc, BaseType, 1427 diag::err_incomplete_base_class, SpecifierRange)) { 1428 Class->setInvalidDecl(); 1429 return nullptr; 1430 } 1431 1432 // If the base class is polymorphic or isn't empty, the new one is/isn't, too. 1433 RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl(); 1434 assert(BaseDecl && "Record type has no declaration"); 1435 BaseDecl = BaseDecl->getDefinition(); 1436 assert(BaseDecl && "Base type is not incomplete, but has no definition"); 1437 CXXRecordDecl *CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl); 1438 assert(CXXBaseDecl && "Base type is not a C++ type"); 1439 1440 // A class which contains a flexible array member is not suitable for use as a 1441 // base class: 1442 // - If the layout determines that a base comes before another base, 1443 // the flexible array member would index into the subsequent base. 1444 // - If the layout determines that base comes before the derived class, 1445 // the flexible array member would index into the derived class. 1446 if (CXXBaseDecl->hasFlexibleArrayMember()) { 1447 Diag(BaseLoc, diag::err_base_class_has_flexible_array_member) 1448 << CXXBaseDecl->getDeclName(); 1449 return nullptr; 1450 } 1451 1452 // C++ [class]p3: 1453 // If a class is marked final and it appears as a base-type-specifier in 1454 // base-clause, the program is ill-formed. 1455 if (FinalAttr *FA = CXXBaseDecl->getAttr<FinalAttr>()) { 1456 Diag(BaseLoc, diag::err_class_marked_final_used_as_base) 1457 << CXXBaseDecl->getDeclName() 1458 << FA->isSpelledAsSealed(); 1459 Diag(CXXBaseDecl->getLocation(), diag::note_entity_declared_at) 1460 << CXXBaseDecl->getDeclName() << FA->getRange(); 1461 return nullptr; 1462 } 1463 1464 if (BaseDecl->isInvalidDecl()) 1465 Class->setInvalidDecl(); 1466 1467 // Create the base specifier. 1468 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual, 1469 Class->getTagKind() == TTK_Class, 1470 Access, TInfo, EllipsisLoc); 1471 } 1472 1473 /// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is 1474 /// one entry in the base class list of a class specifier, for 1475 /// example: 1476 /// class foo : public bar, virtual private baz { 1477 /// 'public bar' and 'virtual private baz' are each base-specifiers. 1478 BaseResult 1479 Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange, 1480 ParsedAttributes &Attributes, 1481 bool Virtual, AccessSpecifier Access, 1482 ParsedType basetype, SourceLocation BaseLoc, 1483 SourceLocation EllipsisLoc) { 1484 if (!classdecl) 1485 return true; 1486 1487 AdjustDeclIfTemplate(classdecl); 1488 CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl); 1489 if (!Class) 1490 return true; 1491 1492 // We haven't yet attached the base specifiers. 1493 Class->setIsParsingBaseSpecifiers(); 1494 1495 // We do not support any C++11 attributes on base-specifiers yet. 1496 // Diagnose any attributes we see. 1497 if (!Attributes.empty()) { 1498 for (AttributeList *Attr = Attributes.getList(); Attr; 1499 Attr = Attr->getNext()) { 1500 if (Attr->isInvalid() || 1501 Attr->getKind() == AttributeList::IgnoredAttribute) 1502 continue; 1503 Diag(Attr->getLoc(), 1504 Attr->getKind() == AttributeList::UnknownAttribute 1505 ? diag::warn_unknown_attribute_ignored 1506 : diag::err_base_specifier_attribute) 1507 << Attr->getName(); 1508 } 1509 } 1510 1511 TypeSourceInfo *TInfo = nullptr; 1512 GetTypeFromParser(basetype, &TInfo); 1513 1514 if (EllipsisLoc.isInvalid() && 1515 DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo, 1516 UPPC_BaseType)) 1517 return true; 1518 1519 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange, 1520 Virtual, Access, TInfo, 1521 EllipsisLoc)) 1522 return BaseSpec; 1523 else 1524 Class->setInvalidDecl(); 1525 1526 return true; 1527 } 1528 1529 /// Use small set to collect indirect bases. As this is only used 1530 /// locally, there's no need to abstract the small size parameter. 1531 typedef llvm::SmallPtrSet<QualType, 4> IndirectBaseSet; 1532 1533 /// \brief Recursively add the bases of Type. Don't add Type itself. 1534 static void 1535 NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set, 1536 const QualType &Type) 1537 { 1538 // Even though the incoming type is a base, it might not be 1539 // a class -- it could be a template parm, for instance. 1540 if (auto Rec = Type->getAs<RecordType>()) { 1541 auto Decl = Rec->getAsCXXRecordDecl(); 1542 1543 // Iterate over its bases. 1544 for (const auto &BaseSpec : Decl->bases()) { 1545 QualType Base = Context.getCanonicalType(BaseSpec.getType()) 1546 .getUnqualifiedType(); 1547 if (Set.insert(Base).second) 1548 // If we've not already seen it, recurse. 1549 NoteIndirectBases(Context, Set, Base); 1550 } 1551 } 1552 } 1553 1554 /// \brief Performs the actual work of attaching the given base class 1555 /// specifiers to a C++ class. 1556 bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases, 1557 unsigned NumBases) { 1558 if (NumBases == 0) 1559 return false; 1560 1561 // Used to keep track of which base types we have already seen, so 1562 // that we can properly diagnose redundant direct base types. Note 1563 // that the key is always the unqualified canonical type of the base 1564 // class. 1565 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes; 1566 1567 // Used to track indirect bases so we can see if a direct base is 1568 // ambiguous. 1569 IndirectBaseSet IndirectBaseTypes; 1570 1571 // Copy non-redundant base specifiers into permanent storage. 1572 unsigned NumGoodBases = 0; 1573 bool Invalid = false; 1574 for (unsigned idx = 0; idx < NumBases; ++idx) { 1575 QualType NewBaseType 1576 = Context.getCanonicalType(Bases[idx]->getType()); 1577 NewBaseType = NewBaseType.getLocalUnqualifiedType(); 1578 1579 CXXBaseSpecifier *&KnownBase = KnownBaseTypes[NewBaseType]; 1580 if (KnownBase) { 1581 // C++ [class.mi]p3: 1582 // A class shall not be specified as a direct base class of a 1583 // derived class more than once. 1584 Diag(Bases[idx]->getLocStart(), 1585 diag::err_duplicate_base_class) 1586 << KnownBase->getType() 1587 << Bases[idx]->getSourceRange(); 1588 1589 // Delete the duplicate base class specifier; we're going to 1590 // overwrite its pointer later. 1591 Context.Deallocate(Bases[idx]); 1592 1593 Invalid = true; 1594 } else { 1595 // Okay, add this new base class. 1596 KnownBase = Bases[idx]; 1597 Bases[NumGoodBases++] = Bases[idx]; 1598 1599 // Note this base's direct & indirect bases, if there could be ambiguity. 1600 if (NumBases > 1) 1601 NoteIndirectBases(Context, IndirectBaseTypes, NewBaseType); 1602 1603 if (const RecordType *Record = NewBaseType->getAs<RecordType>()) { 1604 const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); 1605 if (Class->isInterface() && 1606 (!RD->isInterface() || 1607 KnownBase->getAccessSpecifier() != AS_public)) { 1608 // The Microsoft extension __interface does not permit bases that 1609 // are not themselves public interfaces. 1610 Diag(KnownBase->getLocStart(), diag::err_invalid_base_in_interface) 1611 << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getName() 1612 << RD->getSourceRange(); 1613 Invalid = true; 1614 } 1615 if (RD->hasAttr<WeakAttr>()) 1616 Class->addAttr(WeakAttr::CreateImplicit(Context)); 1617 } 1618 } 1619 } 1620 1621 // Attach the remaining base class specifiers to the derived class. 1622 Class->setBases(Bases, NumGoodBases); 1623 1624 for (unsigned idx = 0; idx < NumGoodBases; ++idx) { 1625 // Check whether this direct base is inaccessible due to ambiguity. 1626 QualType BaseType = Bases[idx]->getType(); 1627 CanQualType CanonicalBase = Context.getCanonicalType(BaseType) 1628 .getUnqualifiedType(); 1629 1630 if (IndirectBaseTypes.count(CanonicalBase)) { 1631 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 1632 /*DetectVirtual=*/true); 1633 bool found 1634 = Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths); 1635 assert(found); 1636 (void)found; 1637 1638 if (Paths.isAmbiguous(CanonicalBase)) 1639 Diag(Bases[idx]->getLocStart (), diag::warn_inaccessible_base_class) 1640 << BaseType << getAmbiguousPathsDisplayString(Paths) 1641 << Bases[idx]->getSourceRange(); 1642 else 1643 assert(Bases[idx]->isVirtual()); 1644 } 1645 1646 // Delete the base class specifier, since its data has been copied 1647 // into the CXXRecordDecl. 1648 Context.Deallocate(Bases[idx]); 1649 } 1650 1651 return Invalid; 1652 } 1653 1654 /// ActOnBaseSpecifiers - Attach the given base specifiers to the 1655 /// class, after checking whether there are any duplicate base 1656 /// classes. 1657 void Sema::ActOnBaseSpecifiers(Decl *ClassDecl, CXXBaseSpecifier **Bases, 1658 unsigned NumBases) { 1659 if (!ClassDecl || !Bases || !NumBases) 1660 return; 1661 1662 AdjustDeclIfTemplate(ClassDecl); 1663 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), Bases, NumBases); 1664 } 1665 1666 /// \brief Determine whether the type \p Derived is a C++ class that is 1667 /// derived from the type \p Base. 1668 bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base) { 1669 if (!getLangOpts().CPlusPlus) 1670 return false; 1671 1672 CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl(); 1673 if (!DerivedRD) 1674 return false; 1675 1676 CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl(); 1677 if (!BaseRD) 1678 return false; 1679 1680 // If either the base or the derived type is invalid, don't try to 1681 // check whether one is derived from the other. 1682 if (BaseRD->isInvalidDecl() || DerivedRD->isInvalidDecl()) 1683 return false; 1684 1685 // FIXME: In a modules build, do we need the entire path to be visible for us 1686 // to be able to use the inheritance relationship? 1687 if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined()) 1688 return false; 1689 1690 return DerivedRD->isDerivedFrom(BaseRD); 1691 } 1692 1693 /// \brief Determine whether the type \p Derived is a C++ class that is 1694 /// derived from the type \p Base. 1695 bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base, 1696 CXXBasePaths &Paths) { 1697 if (!getLangOpts().CPlusPlus) 1698 return false; 1699 1700 CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl(); 1701 if (!DerivedRD) 1702 return false; 1703 1704 CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl(); 1705 if (!BaseRD) 1706 return false; 1707 1708 if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined()) 1709 return false; 1710 1711 return DerivedRD->isDerivedFrom(BaseRD, Paths); 1712 } 1713 1714 void Sema::BuildBasePathArray(const CXXBasePaths &Paths, 1715 CXXCastPath &BasePathArray) { 1716 assert(BasePathArray.empty() && "Base path array must be empty!"); 1717 assert(Paths.isRecordingPaths() && "Must record paths!"); 1718 1719 const CXXBasePath &Path = Paths.front(); 1720 1721 // We first go backward and check if we have a virtual base. 1722 // FIXME: It would be better if CXXBasePath had the base specifier for 1723 // the nearest virtual base. 1724 unsigned Start = 0; 1725 for (unsigned I = Path.size(); I != 0; --I) { 1726 if (Path[I - 1].Base->isVirtual()) { 1727 Start = I - 1; 1728 break; 1729 } 1730 } 1731 1732 // Now add all bases. 1733 for (unsigned I = Start, E = Path.size(); I != E; ++I) 1734 BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base)); 1735 } 1736 1737 /// CheckDerivedToBaseConversion - Check whether the Derived-to-Base 1738 /// conversion (where Derived and Base are class types) is 1739 /// well-formed, meaning that the conversion is unambiguous (and 1740 /// that all of the base classes are accessible). Returns true 1741 /// and emits a diagnostic if the code is ill-formed, returns false 1742 /// otherwise. Loc is the location where this routine should point to 1743 /// if there is an error, and Range is the source range to highlight 1744 /// if there is an error. 1745 bool 1746 Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base, 1747 unsigned InaccessibleBaseID, 1748 unsigned AmbigiousBaseConvID, 1749 SourceLocation Loc, SourceRange Range, 1750 DeclarationName Name, 1751 CXXCastPath *BasePath) { 1752 // First, determine whether the path from Derived to Base is 1753 // ambiguous. This is slightly more expensive than checking whether 1754 // the Derived to Base conversion exists, because here we need to 1755 // explore multiple paths to determine if there is an ambiguity. 1756 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 1757 /*DetectVirtual=*/false); 1758 bool DerivationOkay = IsDerivedFrom(Loc, Derived, Base, Paths); 1759 assert(DerivationOkay && 1760 "Can only be used with a derived-to-base conversion"); 1761 (void)DerivationOkay; 1762 1763 if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType())) { 1764 if (InaccessibleBaseID) { 1765 // Check that the base class can be accessed. 1766 switch (CheckBaseClassAccess(Loc, Base, Derived, Paths.front(), 1767 InaccessibleBaseID)) { 1768 case AR_inaccessible: 1769 return true; 1770 case AR_accessible: 1771 case AR_dependent: 1772 case AR_delayed: 1773 break; 1774 } 1775 } 1776 1777 // Build a base path if necessary. 1778 if (BasePath) 1779 BuildBasePathArray(Paths, *BasePath); 1780 return false; 1781 } 1782 1783 if (AmbigiousBaseConvID) { 1784 // We know that the derived-to-base conversion is ambiguous, and 1785 // we're going to produce a diagnostic. Perform the derived-to-base 1786 // search just one more time to compute all of the possible paths so 1787 // that we can print them out. This is more expensive than any of 1788 // the previous derived-to-base checks we've done, but at this point 1789 // performance isn't as much of an issue. 1790 Paths.clear(); 1791 Paths.setRecordingPaths(true); 1792 bool StillOkay = IsDerivedFrom(Loc, Derived, Base, Paths); 1793 assert(StillOkay && "Can only be used with a derived-to-base conversion"); 1794 (void)StillOkay; 1795 1796 // Build up a textual representation of the ambiguous paths, e.g., 1797 // D -> B -> A, that will be used to illustrate the ambiguous 1798 // conversions in the diagnostic. We only print one of the paths 1799 // to each base class subobject. 1800 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths); 1801 1802 Diag(Loc, AmbigiousBaseConvID) 1803 << Derived << Base << PathDisplayStr << Range << Name; 1804 } 1805 return true; 1806 } 1807 1808 bool 1809 Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base, 1810 SourceLocation Loc, SourceRange Range, 1811 CXXCastPath *BasePath, 1812 bool IgnoreAccess) { 1813 return CheckDerivedToBaseConversion(Derived, Base, 1814 IgnoreAccess ? 0 1815 : diag::err_upcast_to_inaccessible_base, 1816 diag::err_ambiguous_derived_to_base_conv, 1817 Loc, Range, DeclarationName(), 1818 BasePath); 1819 } 1820 1821 1822 /// @brief Builds a string representing ambiguous paths from a 1823 /// specific derived class to different subobjects of the same base 1824 /// class. 1825 /// 1826 /// This function builds a string that can be used in error messages 1827 /// to show the different paths that one can take through the 1828 /// inheritance hierarchy to go from the derived class to different 1829 /// subobjects of a base class. The result looks something like this: 1830 /// @code 1831 /// struct D -> struct B -> struct A 1832 /// struct D -> struct C -> struct A 1833 /// @endcode 1834 std::string Sema::getAmbiguousPathsDisplayString(CXXBasePaths &Paths) { 1835 std::string PathDisplayStr; 1836 std::set<unsigned> DisplayedPaths; 1837 for (CXXBasePaths::paths_iterator Path = Paths.begin(); 1838 Path != Paths.end(); ++Path) { 1839 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) { 1840 // We haven't displayed a path to this particular base 1841 // class subobject yet. 1842 PathDisplayStr += "\n "; 1843 PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString(); 1844 for (CXXBasePath::const_iterator Element = Path->begin(); 1845 Element != Path->end(); ++Element) 1846 PathDisplayStr += " -> " + Element->Base->getType().getAsString(); 1847 } 1848 } 1849 1850 return PathDisplayStr; 1851 } 1852 1853 //===----------------------------------------------------------------------===// 1854 // C++ class member Handling 1855 //===----------------------------------------------------------------------===// 1856 1857 /// ActOnAccessSpecifier - Parsed an access specifier followed by a colon. 1858 bool Sema::ActOnAccessSpecifier(AccessSpecifier Access, 1859 SourceLocation ASLoc, 1860 SourceLocation ColonLoc, 1861 AttributeList *Attrs) { 1862 assert(Access != AS_none && "Invalid kind for syntactic access specifier!"); 1863 AccessSpecDecl *ASDecl = AccessSpecDecl::Create(Context, Access, CurContext, 1864 ASLoc, ColonLoc); 1865 CurContext->addHiddenDecl(ASDecl); 1866 return ProcessAccessDeclAttributeList(ASDecl, Attrs); 1867 } 1868 1869 /// CheckOverrideControl - Check C++11 override control semantics. 1870 void Sema::CheckOverrideControl(NamedDecl *D) { 1871 if (D->isInvalidDecl()) 1872 return; 1873 1874 // We only care about "override" and "final" declarations. 1875 if (!D->hasAttr<OverrideAttr>() && !D->hasAttr<FinalAttr>()) 1876 return; 1877 1878 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D); 1879 1880 // We can't check dependent instance methods. 1881 if (MD && MD->isInstance() && 1882 (MD->getParent()->hasAnyDependentBases() || 1883 MD->getType()->isDependentType())) 1884 return; 1885 1886 if (MD && !MD->isVirtual()) { 1887 // If we have a non-virtual method, check if if hides a virtual method. 1888 // (In that case, it's most likely the method has the wrong type.) 1889 SmallVector<CXXMethodDecl *, 8> OverloadedMethods; 1890 FindHiddenVirtualMethods(MD, OverloadedMethods); 1891 1892 if (!OverloadedMethods.empty()) { 1893 if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) { 1894 Diag(OA->getLocation(), 1895 diag::override_keyword_hides_virtual_member_function) 1896 << "override" << (OverloadedMethods.size() > 1); 1897 } else if (FinalAttr *FA = D->getAttr<FinalAttr>()) { 1898 Diag(FA->getLocation(), 1899 diag::override_keyword_hides_virtual_member_function) 1900 << (FA->isSpelledAsSealed() ? "sealed" : "final") 1901 << (OverloadedMethods.size() > 1); 1902 } 1903 NoteHiddenVirtualMethods(MD, OverloadedMethods); 1904 MD->setInvalidDecl(); 1905 return; 1906 } 1907 // Fall through into the general case diagnostic. 1908 // FIXME: We might want to attempt typo correction here. 1909 } 1910 1911 if (!MD || !MD->isVirtual()) { 1912 if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) { 1913 Diag(OA->getLocation(), 1914 diag::override_keyword_only_allowed_on_virtual_member_functions) 1915 << "override" << FixItHint::CreateRemoval(OA->getLocation()); 1916 D->dropAttr<OverrideAttr>(); 1917 } 1918 if (FinalAttr *FA = D->getAttr<FinalAttr>()) { 1919 Diag(FA->getLocation(), 1920 diag::override_keyword_only_allowed_on_virtual_member_functions) 1921 << (FA->isSpelledAsSealed() ? "sealed" : "final") 1922 << FixItHint::CreateRemoval(FA->getLocation()); 1923 D->dropAttr<FinalAttr>(); 1924 } 1925 return; 1926 } 1927 1928 // C++11 [class.virtual]p5: 1929 // If a function is marked with the virt-specifier override and 1930 // does not override a member function of a base class, the program is 1931 // ill-formed. 1932 bool HasOverriddenMethods = 1933 MD->begin_overridden_methods() != MD->end_overridden_methods(); 1934 if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods) 1935 Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding) 1936 << MD->getDeclName(); 1937 } 1938 1939 void Sema::DiagnoseAbsenceOfOverrideControl(NamedDecl *D) { 1940 if (D->isInvalidDecl() || D->hasAttr<OverrideAttr>()) 1941 return; 1942 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D); 1943 if (!MD || MD->isImplicit() || MD->hasAttr<FinalAttr>() || 1944 isa<CXXDestructorDecl>(MD)) 1945 return; 1946 1947 SourceLocation Loc = MD->getLocation(); 1948 SourceLocation SpellingLoc = Loc; 1949 if (getSourceManager().isMacroArgExpansion(Loc)) 1950 SpellingLoc = getSourceManager().getImmediateExpansionRange(Loc).first; 1951 SpellingLoc = getSourceManager().getSpellingLoc(SpellingLoc); 1952 if (SpellingLoc.isValid() && getSourceManager().isInSystemHeader(SpellingLoc)) 1953 return; 1954 1955 if (MD->size_overridden_methods() > 0) { 1956 Diag(MD->getLocation(), diag::warn_function_marked_not_override_overriding) 1957 << MD->getDeclName(); 1958 const CXXMethodDecl *OMD = *MD->begin_overridden_methods(); 1959 Diag(OMD->getLocation(), diag::note_overridden_virtual_function); 1960 } 1961 } 1962 1963 /// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member 1964 /// function overrides a virtual member function marked 'final', according to 1965 /// C++11 [class.virtual]p4. 1966 bool Sema::CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, 1967 const CXXMethodDecl *Old) { 1968 FinalAttr *FA = Old->getAttr<FinalAttr>(); 1969 if (!FA) 1970 return false; 1971 1972 Diag(New->getLocation(), diag::err_final_function_overridden) 1973 << New->getDeclName() 1974 << FA->isSpelledAsSealed(); 1975 Diag(Old->getLocation(), diag::note_overridden_virtual_function); 1976 return true; 1977 } 1978 1979 static bool InitializationHasSideEffects(const FieldDecl &FD) { 1980 const Type *T = FD.getType()->getBaseElementTypeUnsafe(); 1981 // FIXME: Destruction of ObjC lifetime types has side-effects. 1982 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 1983 return !RD->isCompleteDefinition() || 1984 !RD->hasTrivialDefaultConstructor() || 1985 !RD->hasTrivialDestructor(); 1986 return false; 1987 } 1988 1989 static AttributeList *getMSPropertyAttr(AttributeList *list) { 1990 for (AttributeList *it = list; it != nullptr; it = it->getNext()) 1991 if (it->isDeclspecPropertyAttribute()) 1992 return it; 1993 return nullptr; 1994 } 1995 1996 /// ActOnCXXMemberDeclarator - This is invoked when a C++ class member 1997 /// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the 1998 /// bitfield width if there is one, 'InitExpr' specifies the initializer if 1999 /// one has been parsed, and 'InitStyle' is set if an in-class initializer is 2000 /// present (but parsing it has been deferred). 2001 NamedDecl * 2002 Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D, 2003 MultiTemplateParamsArg TemplateParameterLists, 2004 Expr *BW, const VirtSpecifiers &VS, 2005 InClassInitStyle InitStyle) { 2006 const DeclSpec &DS = D.getDeclSpec(); 2007 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 2008 DeclarationName Name = NameInfo.getName(); 2009 SourceLocation Loc = NameInfo.getLoc(); 2010 2011 // For anonymous bitfields, the location should point to the type. 2012 if (Loc.isInvalid()) 2013 Loc = D.getLocStart(); 2014 2015 Expr *BitWidth = static_cast<Expr*>(BW); 2016 2017 assert(isa<CXXRecordDecl>(CurContext)); 2018 assert(!DS.isFriendSpecified()); 2019 2020 bool isFunc = D.isDeclarationOfFunction(); 2021 2022 if (cast<CXXRecordDecl>(CurContext)->isInterface()) { 2023 // The Microsoft extension __interface only permits public member functions 2024 // and prohibits constructors, destructors, operators, non-public member 2025 // functions, static methods and data members. 2026 unsigned InvalidDecl; 2027 bool ShowDeclName = true; 2028 if (!isFunc) 2029 InvalidDecl = (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) ? 0 : 1; 2030 else if (AS != AS_public) 2031 InvalidDecl = 2; 2032 else if (DS.getStorageClassSpec() == DeclSpec::SCS_static) 2033 InvalidDecl = 3; 2034 else switch (Name.getNameKind()) { 2035 case DeclarationName::CXXConstructorName: 2036 InvalidDecl = 4; 2037 ShowDeclName = false; 2038 break; 2039 2040 case DeclarationName::CXXDestructorName: 2041 InvalidDecl = 5; 2042 ShowDeclName = false; 2043 break; 2044 2045 case DeclarationName::CXXOperatorName: 2046 case DeclarationName::CXXConversionFunctionName: 2047 InvalidDecl = 6; 2048 break; 2049 2050 default: 2051 InvalidDecl = 0; 2052 break; 2053 } 2054 2055 if (InvalidDecl) { 2056 if (ShowDeclName) 2057 Diag(Loc, diag::err_invalid_member_in_interface) 2058 << (InvalidDecl-1) << Name; 2059 else 2060 Diag(Loc, diag::err_invalid_member_in_interface) 2061 << (InvalidDecl-1) << ""; 2062 return nullptr; 2063 } 2064 } 2065 2066 // C++ 9.2p6: A member shall not be declared to have automatic storage 2067 // duration (auto, register) or with the extern storage-class-specifier. 2068 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class 2069 // data members and cannot be applied to names declared const or static, 2070 // and cannot be applied to reference members. 2071 switch (DS.getStorageClassSpec()) { 2072 case DeclSpec::SCS_unspecified: 2073 case DeclSpec::SCS_typedef: 2074 case DeclSpec::SCS_static: 2075 break; 2076 case DeclSpec::SCS_mutable: 2077 if (isFunc) { 2078 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function); 2079 2080 // FIXME: It would be nicer if the keyword was ignored only for this 2081 // declarator. Otherwise we could get follow-up errors. 2082 D.getMutableDeclSpec().ClearStorageClassSpecs(); 2083 } 2084 break; 2085 default: 2086 Diag(DS.getStorageClassSpecLoc(), 2087 diag::err_storageclass_invalid_for_member); 2088 D.getMutableDeclSpec().ClearStorageClassSpecs(); 2089 break; 2090 } 2091 2092 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified || 2093 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) && 2094 !isFunc); 2095 2096 if (DS.isConstexprSpecified() && isInstField) { 2097 SemaDiagnosticBuilder B = 2098 Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr_member); 2099 SourceLocation ConstexprLoc = DS.getConstexprSpecLoc(); 2100 if (InitStyle == ICIS_NoInit) { 2101 B << 0 << 0; 2102 if (D.getDeclSpec().getTypeQualifiers() & DeclSpec::TQ_const) 2103 B << FixItHint::CreateRemoval(ConstexprLoc); 2104 else { 2105 B << FixItHint::CreateReplacement(ConstexprLoc, "const"); 2106 D.getMutableDeclSpec().ClearConstexprSpec(); 2107 const char *PrevSpec; 2108 unsigned DiagID; 2109 bool Failed = D.getMutableDeclSpec().SetTypeQual( 2110 DeclSpec::TQ_const, ConstexprLoc, PrevSpec, DiagID, getLangOpts()); 2111 (void)Failed; 2112 assert(!Failed && "Making a constexpr member const shouldn't fail"); 2113 } 2114 } else { 2115 B << 1; 2116 const char *PrevSpec; 2117 unsigned DiagID; 2118 if (D.getMutableDeclSpec().SetStorageClassSpec( 2119 *this, DeclSpec::SCS_static, ConstexprLoc, PrevSpec, DiagID, 2120 Context.getPrintingPolicy())) { 2121 assert(DS.getStorageClassSpec() == DeclSpec::SCS_mutable && 2122 "This is the only DeclSpec that should fail to be applied"); 2123 B << 1; 2124 } else { 2125 B << 0 << FixItHint::CreateInsertion(ConstexprLoc, "static "); 2126 isInstField = false; 2127 } 2128 } 2129 } 2130 2131 NamedDecl *Member; 2132 if (isInstField) { 2133 CXXScopeSpec &SS = D.getCXXScopeSpec(); 2134 2135 // Data members must have identifiers for names. 2136 if (!Name.isIdentifier()) { 2137 Diag(Loc, diag::err_bad_variable_name) 2138 << Name; 2139 return nullptr; 2140 } 2141 2142 IdentifierInfo *II = Name.getAsIdentifierInfo(); 2143 2144 // Member field could not be with "template" keyword. 2145 // So TemplateParameterLists should be empty in this case. 2146 if (TemplateParameterLists.size()) { 2147 TemplateParameterList* TemplateParams = TemplateParameterLists[0]; 2148 if (TemplateParams->size()) { 2149 // There is no such thing as a member field template. 2150 Diag(D.getIdentifierLoc(), diag::err_template_member) 2151 << II 2152 << SourceRange(TemplateParams->getTemplateLoc(), 2153 TemplateParams->getRAngleLoc()); 2154 } else { 2155 // There is an extraneous 'template<>' for this member. 2156 Diag(TemplateParams->getTemplateLoc(), 2157 diag::err_template_member_noparams) 2158 << II 2159 << SourceRange(TemplateParams->getTemplateLoc(), 2160 TemplateParams->getRAngleLoc()); 2161 } 2162 return nullptr; 2163 } 2164 2165 if (SS.isSet() && !SS.isInvalid()) { 2166 // The user provided a superfluous scope specifier inside a class 2167 // definition: 2168 // 2169 // class X { 2170 // int X::member; 2171 // }; 2172 if (DeclContext *DC = computeDeclContext(SS, false)) 2173 diagnoseQualifiedDeclaration(SS, DC, Name, D.getIdentifierLoc()); 2174 else 2175 Diag(D.getIdentifierLoc(), diag::err_member_qualification) 2176 << Name << SS.getRange(); 2177 2178 SS.clear(); 2179 } 2180 2181 AttributeList *MSPropertyAttr = 2182 getMSPropertyAttr(D.getDeclSpec().getAttributes().getList()); 2183 if (MSPropertyAttr) { 2184 Member = HandleMSProperty(S, cast<CXXRecordDecl>(CurContext), Loc, D, 2185 BitWidth, InitStyle, AS, MSPropertyAttr); 2186 if (!Member) 2187 return nullptr; 2188 isInstField = false; 2189 } else { 2190 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D, 2191 BitWidth, InitStyle, AS); 2192 assert(Member && "HandleField never returns null"); 2193 } 2194 } else { 2195 Member = HandleDeclarator(S, D, TemplateParameterLists); 2196 if (!Member) 2197 return nullptr; 2198 2199 // Non-instance-fields can't have a bitfield. 2200 if (BitWidth) { 2201 if (Member->isInvalidDecl()) { 2202 // don't emit another diagnostic. 2203 } else if (isa<VarDecl>(Member) || isa<VarTemplateDecl>(Member)) { 2204 // C++ 9.6p3: A bit-field shall not be a static member. 2205 // "static member 'A' cannot be a bit-field" 2206 Diag(Loc, diag::err_static_not_bitfield) 2207 << Name << BitWidth->getSourceRange(); 2208 } else if (isa<TypedefDecl>(Member)) { 2209 // "typedef member 'x' cannot be a bit-field" 2210 Diag(Loc, diag::err_typedef_not_bitfield) 2211 << Name << BitWidth->getSourceRange(); 2212 } else { 2213 // A function typedef ("typedef int f(); f a;"). 2214 // C++ 9.6p3: A bit-field shall have integral or enumeration type. 2215 Diag(Loc, diag::err_not_integral_type_bitfield) 2216 << Name << cast<ValueDecl>(Member)->getType() 2217 << BitWidth->getSourceRange(); 2218 } 2219 2220 BitWidth = nullptr; 2221 Member->setInvalidDecl(); 2222 } 2223 2224 Member->setAccess(AS); 2225 2226 // If we have declared a member function template or static data member 2227 // template, set the access of the templated declaration as well. 2228 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member)) 2229 FunTmpl->getTemplatedDecl()->setAccess(AS); 2230 else if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(Member)) 2231 VarTmpl->getTemplatedDecl()->setAccess(AS); 2232 } 2233 2234 if (VS.isOverrideSpecified()) 2235 Member->addAttr(new (Context) OverrideAttr(VS.getOverrideLoc(), Context, 0)); 2236 if (VS.isFinalSpecified()) 2237 Member->addAttr(new (Context) FinalAttr(VS.getFinalLoc(), Context, 2238 VS.isFinalSpelledSealed())); 2239 2240 if (VS.getLastLocation().isValid()) { 2241 // Update the end location of a method that has a virt-specifiers. 2242 if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member)) 2243 MD->setRangeEnd(VS.getLastLocation()); 2244 } 2245 2246 CheckOverrideControl(Member); 2247 2248 assert((Name || isInstField) && "No identifier for non-field ?"); 2249 2250 if (isInstField) { 2251 FieldDecl *FD = cast<FieldDecl>(Member); 2252 FieldCollector->Add(FD); 2253 2254 if (!Diags.isIgnored(diag::warn_unused_private_field, FD->getLocation())) { 2255 // Remember all explicit private FieldDecls that have a name, no side 2256 // effects and are not part of a dependent type declaration. 2257 if (!FD->isImplicit() && FD->getDeclName() && 2258 FD->getAccess() == AS_private && 2259 !FD->hasAttr<UnusedAttr>() && 2260 !FD->getParent()->isDependentContext() && 2261 !InitializationHasSideEffects(*FD)) 2262 UnusedPrivateFields.insert(FD); 2263 } 2264 } 2265 2266 return Member; 2267 } 2268 2269 namespace { 2270 class UninitializedFieldVisitor 2271 : public EvaluatedExprVisitor<UninitializedFieldVisitor> { 2272 Sema &S; 2273 // List of Decls to generate a warning on. Also remove Decls that become 2274 // initialized. 2275 llvm::SmallPtrSetImpl<ValueDecl*> &Decls; 2276 // List of base classes of the record. Classes are removed after their 2277 // initializers. 2278 llvm::SmallPtrSetImpl<QualType> &BaseClasses; 2279 // Vector of decls to be removed from the Decl set prior to visiting the 2280 // nodes. These Decls may have been initialized in the prior initializer. 2281 llvm::SmallVector<ValueDecl*, 4> DeclsToRemove; 2282 // If non-null, add a note to the warning pointing back to the constructor. 2283 const CXXConstructorDecl *Constructor; 2284 // Variables to hold state when processing an initializer list. When 2285 // InitList is true, special case initialization of FieldDecls matching 2286 // InitListFieldDecl. 2287 bool InitList; 2288 FieldDecl *InitListFieldDecl; 2289 llvm::SmallVector<unsigned, 4> InitFieldIndex; 2290 2291 public: 2292 typedef EvaluatedExprVisitor<UninitializedFieldVisitor> Inherited; 2293 UninitializedFieldVisitor(Sema &S, 2294 llvm::SmallPtrSetImpl<ValueDecl*> &Decls, 2295 llvm::SmallPtrSetImpl<QualType> &BaseClasses) 2296 : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses), 2297 Constructor(nullptr), InitList(false), InitListFieldDecl(nullptr) {} 2298 2299 // Returns true if the use of ME is not an uninitialized use. 2300 bool IsInitListMemberExprInitialized(MemberExpr *ME, 2301 bool CheckReferenceOnly) { 2302 llvm::SmallVector<FieldDecl*, 4> Fields; 2303 bool ReferenceField = false; 2304 while (ME) { 2305 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()); 2306 if (!FD) 2307 return false; 2308 Fields.push_back(FD); 2309 if (FD->getType()->isReferenceType()) 2310 ReferenceField = true; 2311 ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParenImpCasts()); 2312 } 2313 2314 // Binding a reference to an unintialized field is not an 2315 // uninitialized use. 2316 if (CheckReferenceOnly && !ReferenceField) 2317 return true; 2318 2319 llvm::SmallVector<unsigned, 4> UsedFieldIndex; 2320 // Discard the first field since it is the field decl that is being 2321 // initialized. 2322 for (auto I = Fields.rbegin() + 1, E = Fields.rend(); I != E; ++I) { 2323 UsedFieldIndex.push_back((*I)->getFieldIndex()); 2324 } 2325 2326 for (auto UsedIter = UsedFieldIndex.begin(), 2327 UsedEnd = UsedFieldIndex.end(), 2328 OrigIter = InitFieldIndex.begin(), 2329 OrigEnd = InitFieldIndex.end(); 2330 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) { 2331 if (*UsedIter < *OrigIter) 2332 return true; 2333 if (*UsedIter > *OrigIter) 2334 break; 2335 } 2336 2337 return false; 2338 } 2339 2340 void HandleMemberExpr(MemberExpr *ME, bool CheckReferenceOnly, 2341 bool AddressOf) { 2342 if (isa<EnumConstantDecl>(ME->getMemberDecl())) 2343 return; 2344 2345 // FieldME is the inner-most MemberExpr that is not an anonymous struct 2346 // or union. 2347 MemberExpr *FieldME = ME; 2348 2349 bool AllPODFields = FieldME->getType().isPODType(S.Context); 2350 2351 Expr *Base = ME; 2352 while (MemberExpr *SubME = 2353 dyn_cast<MemberExpr>(Base->IgnoreParenImpCasts())) { 2354 2355 if (isa<VarDecl>(SubME->getMemberDecl())) 2356 return; 2357 2358 if (FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl())) 2359 if (!FD->isAnonymousStructOrUnion()) 2360 FieldME = SubME; 2361 2362 if (!FieldME->getType().isPODType(S.Context)) 2363 AllPODFields = false; 2364 2365 Base = SubME->getBase(); 2366 } 2367 2368 if (!isa<CXXThisExpr>(Base->IgnoreParenImpCasts())) 2369 return; 2370 2371 if (AddressOf && AllPODFields) 2372 return; 2373 2374 ValueDecl* FoundVD = FieldME->getMemberDecl(); 2375 2376 if (ImplicitCastExpr *BaseCast = dyn_cast<ImplicitCastExpr>(Base)) { 2377 while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) { 2378 BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr()); 2379 } 2380 2381 if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) { 2382 QualType T = BaseCast->getType(); 2383 if (T->isPointerType() && 2384 BaseClasses.count(T->getPointeeType())) { 2385 S.Diag(FieldME->getExprLoc(), diag::warn_base_class_is_uninit) 2386 << T->getPointeeType() << FoundVD; 2387 } 2388 } 2389 } 2390 2391 if (!Decls.count(FoundVD)) 2392 return; 2393 2394 const bool IsReference = FoundVD->getType()->isReferenceType(); 2395 2396 if (InitList && !AddressOf && FoundVD == InitListFieldDecl) { 2397 // Special checking for initializer lists. 2398 if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) { 2399 return; 2400 } 2401 } else { 2402 // Prevent double warnings on use of unbounded references. 2403 if (CheckReferenceOnly && !IsReference) 2404 return; 2405 } 2406 2407 unsigned diag = IsReference 2408 ? diag::warn_reference_field_is_uninit 2409 : diag::warn_field_is_uninit; 2410 S.Diag(FieldME->getExprLoc(), diag) << FoundVD; 2411 if (Constructor) 2412 S.Diag(Constructor->getLocation(), 2413 diag::note_uninit_in_this_constructor) 2414 << (Constructor->isDefaultConstructor() && Constructor->isImplicit()); 2415 2416 } 2417 2418 void HandleValue(Expr *E, bool AddressOf) { 2419 E = E->IgnoreParens(); 2420 2421 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 2422 HandleMemberExpr(ME, false /*CheckReferenceOnly*/, 2423 AddressOf /*AddressOf*/); 2424 return; 2425 } 2426 2427 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 2428 Visit(CO->getCond()); 2429 HandleValue(CO->getTrueExpr(), AddressOf); 2430 HandleValue(CO->getFalseExpr(), AddressOf); 2431 return; 2432 } 2433 2434 if (BinaryConditionalOperator *BCO = 2435 dyn_cast<BinaryConditionalOperator>(E)) { 2436 Visit(BCO->getCond()); 2437 HandleValue(BCO->getFalseExpr(), AddressOf); 2438 return; 2439 } 2440 2441 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) { 2442 HandleValue(OVE->getSourceExpr(), AddressOf); 2443 return; 2444 } 2445 2446 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 2447 switch (BO->getOpcode()) { 2448 default: 2449 break; 2450 case(BO_PtrMemD): 2451 case(BO_PtrMemI): 2452 HandleValue(BO->getLHS(), AddressOf); 2453 Visit(BO->getRHS()); 2454 return; 2455 case(BO_Comma): 2456 Visit(BO->getLHS()); 2457 HandleValue(BO->getRHS(), AddressOf); 2458 return; 2459 } 2460 } 2461 2462 Visit(E); 2463 } 2464 2465 void CheckInitListExpr(InitListExpr *ILE) { 2466 InitFieldIndex.push_back(0); 2467 for (auto Child : ILE->children()) { 2468 if (InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) { 2469 CheckInitListExpr(SubList); 2470 } else { 2471 Visit(Child); 2472 } 2473 ++InitFieldIndex.back(); 2474 } 2475 InitFieldIndex.pop_back(); 2476 } 2477 2478 void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor, 2479 FieldDecl *Field, const Type *BaseClass) { 2480 // Remove Decls that may have been initialized in the previous 2481 // initializer. 2482 for (ValueDecl* VD : DeclsToRemove) 2483 Decls.erase(VD); 2484 DeclsToRemove.clear(); 2485 2486 Constructor = FieldConstructor; 2487 InitListExpr *ILE = dyn_cast<InitListExpr>(E); 2488 2489 if (ILE && Field) { 2490 InitList = true; 2491 InitListFieldDecl = Field; 2492 InitFieldIndex.clear(); 2493 CheckInitListExpr(ILE); 2494 } else { 2495 InitList = false; 2496 Visit(E); 2497 } 2498 2499 if (Field) 2500 Decls.erase(Field); 2501 if (BaseClass) 2502 BaseClasses.erase(BaseClass->getCanonicalTypeInternal()); 2503 } 2504 2505 void VisitMemberExpr(MemberExpr *ME) { 2506 // All uses of unbounded reference fields will warn. 2507 HandleMemberExpr(ME, true /*CheckReferenceOnly*/, false /*AddressOf*/); 2508 } 2509 2510 void VisitImplicitCastExpr(ImplicitCastExpr *E) { 2511 if (E->getCastKind() == CK_LValueToRValue) { 2512 HandleValue(E->getSubExpr(), false /*AddressOf*/); 2513 return; 2514 } 2515 2516 Inherited::VisitImplicitCastExpr(E); 2517 } 2518 2519 void VisitCXXConstructExpr(CXXConstructExpr *E) { 2520 if (E->getConstructor()->isCopyConstructor()) { 2521 Expr *ArgExpr = E->getArg(0); 2522 if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr)) 2523 if (ILE->getNumInits() == 1) 2524 ArgExpr = ILE->getInit(0); 2525 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr)) 2526 if (ICE->getCastKind() == CK_NoOp) 2527 ArgExpr = ICE->getSubExpr(); 2528 HandleValue(ArgExpr, false /*AddressOf*/); 2529 return; 2530 } 2531 Inherited::VisitCXXConstructExpr(E); 2532 } 2533 2534 void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 2535 Expr *Callee = E->getCallee(); 2536 if (isa<MemberExpr>(Callee)) { 2537 HandleValue(Callee, false /*AddressOf*/); 2538 for (auto Arg : E->arguments()) 2539 Visit(Arg); 2540 return; 2541 } 2542 2543 Inherited::VisitCXXMemberCallExpr(E); 2544 } 2545 2546 void VisitCallExpr(CallExpr *E) { 2547 // Treat std::move as a use. 2548 if (E->getNumArgs() == 1) { 2549 if (FunctionDecl *FD = E->getDirectCallee()) { 2550 if (FD->isInStdNamespace() && FD->getIdentifier() && 2551 FD->getIdentifier()->isStr("move")) { 2552 HandleValue(E->getArg(0), false /*AddressOf*/); 2553 return; 2554 } 2555 } 2556 } 2557 2558 Inherited::VisitCallExpr(E); 2559 } 2560 2561 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 2562 Expr *Callee = E->getCallee(); 2563 2564 if (isa<UnresolvedLookupExpr>(Callee)) 2565 return Inherited::VisitCXXOperatorCallExpr(E); 2566 2567 Visit(Callee); 2568 for (auto Arg : E->arguments()) 2569 HandleValue(Arg->IgnoreParenImpCasts(), false /*AddressOf*/); 2570 } 2571 2572 void VisitBinaryOperator(BinaryOperator *E) { 2573 // If a field assignment is detected, remove the field from the 2574 // uninitiailized field set. 2575 if (E->getOpcode() == BO_Assign) 2576 if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getLHS())) 2577 if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) 2578 if (!FD->getType()->isReferenceType()) 2579 DeclsToRemove.push_back(FD); 2580 2581 if (E->isCompoundAssignmentOp()) { 2582 HandleValue(E->getLHS(), false /*AddressOf*/); 2583 Visit(E->getRHS()); 2584 return; 2585 } 2586 2587 Inherited::VisitBinaryOperator(E); 2588 } 2589 2590 void VisitUnaryOperator(UnaryOperator *E) { 2591 if (E->isIncrementDecrementOp()) { 2592 HandleValue(E->getSubExpr(), false /*AddressOf*/); 2593 return; 2594 } 2595 if (E->getOpcode() == UO_AddrOf) { 2596 if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getSubExpr())) { 2597 HandleValue(ME->getBase(), true /*AddressOf*/); 2598 return; 2599 } 2600 } 2601 2602 Inherited::VisitUnaryOperator(E); 2603 } 2604 }; 2605 2606 // Diagnose value-uses of fields to initialize themselves, e.g. 2607 // foo(foo) 2608 // where foo is not also a parameter to the constructor. 2609 // Also diagnose across field uninitialized use such as 2610 // x(y), y(x) 2611 // TODO: implement -Wuninitialized and fold this into that framework. 2612 static void DiagnoseUninitializedFields( 2613 Sema &SemaRef, const CXXConstructorDecl *Constructor) { 2614 2615 if (SemaRef.getDiagnostics().isIgnored(diag::warn_field_is_uninit, 2616 Constructor->getLocation())) { 2617 return; 2618 } 2619 2620 if (Constructor->isInvalidDecl()) 2621 return; 2622 2623 const CXXRecordDecl *RD = Constructor->getParent(); 2624 2625 if (RD->getDescribedClassTemplate()) 2626 return; 2627 2628 // Holds fields that are uninitialized. 2629 llvm::SmallPtrSet<ValueDecl*, 4> UninitializedFields; 2630 2631 // At the beginning, all fields are uninitialized. 2632 for (auto *I : RD->decls()) { 2633 if (auto *FD = dyn_cast<FieldDecl>(I)) { 2634 UninitializedFields.insert(FD); 2635 } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(I)) { 2636 UninitializedFields.insert(IFD->getAnonField()); 2637 } 2638 } 2639 2640 llvm::SmallPtrSet<QualType, 4> UninitializedBaseClasses; 2641 for (auto I : RD->bases()) 2642 UninitializedBaseClasses.insert(I.getType().getCanonicalType()); 2643 2644 if (UninitializedFields.empty() && UninitializedBaseClasses.empty()) 2645 return; 2646 2647 UninitializedFieldVisitor UninitializedChecker(SemaRef, 2648 UninitializedFields, 2649 UninitializedBaseClasses); 2650 2651 for (const auto *FieldInit : Constructor->inits()) { 2652 if (UninitializedFields.empty() && UninitializedBaseClasses.empty()) 2653 break; 2654 2655 Expr *InitExpr = FieldInit->getInit(); 2656 if (!InitExpr) 2657 continue; 2658 2659 if (CXXDefaultInitExpr *Default = 2660 dyn_cast<CXXDefaultInitExpr>(InitExpr)) { 2661 InitExpr = Default->getExpr(); 2662 if (!InitExpr) 2663 continue; 2664 // In class initializers will point to the constructor. 2665 UninitializedChecker.CheckInitializer(InitExpr, Constructor, 2666 FieldInit->getAnyMember(), 2667 FieldInit->getBaseClass()); 2668 } else { 2669 UninitializedChecker.CheckInitializer(InitExpr, nullptr, 2670 FieldInit->getAnyMember(), 2671 FieldInit->getBaseClass()); 2672 } 2673 } 2674 } 2675 } // namespace 2676 2677 /// \brief Enter a new C++ default initializer scope. After calling this, the 2678 /// caller must call \ref ActOnFinishCXXInClassMemberInitializer, even if 2679 /// parsing or instantiating the initializer failed. 2680 void Sema::ActOnStartCXXInClassMemberInitializer() { 2681 // Create a synthetic function scope to represent the call to the constructor 2682 // that notionally surrounds a use of this initializer. 2683 PushFunctionScope(); 2684 } 2685 2686 /// \brief This is invoked after parsing an in-class initializer for a 2687 /// non-static C++ class member, and after instantiating an in-class initializer 2688 /// in a class template. Such actions are deferred until the class is complete. 2689 void Sema::ActOnFinishCXXInClassMemberInitializer(Decl *D, 2690 SourceLocation InitLoc, 2691 Expr *InitExpr) { 2692 // Pop the notional constructor scope we created earlier. 2693 PopFunctionScopeInfo(nullptr, D); 2694 2695 FieldDecl *FD = dyn_cast<FieldDecl>(D); 2696 assert((isa<MSPropertyDecl>(D) || FD->getInClassInitStyle() != ICIS_NoInit) && 2697 "must set init style when field is created"); 2698 2699 if (!InitExpr) { 2700 D->setInvalidDecl(); 2701 if (FD) 2702 FD->removeInClassInitializer(); 2703 return; 2704 } 2705 2706 if (DiagnoseUnexpandedParameterPack(InitExpr, UPPC_Initializer)) { 2707 FD->setInvalidDecl(); 2708 FD->removeInClassInitializer(); 2709 return; 2710 } 2711 2712 ExprResult Init = InitExpr; 2713 if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent()) { 2714 InitializedEntity Entity = InitializedEntity::InitializeMember(FD); 2715 InitializationKind Kind = FD->getInClassInitStyle() == ICIS_ListInit 2716 ? InitializationKind::CreateDirectList(InitExpr->getLocStart()) 2717 : InitializationKind::CreateCopy(InitExpr->getLocStart(), InitLoc); 2718 InitializationSequence Seq(*this, Entity, Kind, InitExpr); 2719 Init = Seq.Perform(*this, Entity, Kind, InitExpr); 2720 if (Init.isInvalid()) { 2721 FD->setInvalidDecl(); 2722 return; 2723 } 2724 } 2725 2726 // C++11 [class.base.init]p7: 2727 // The initialization of each base and member constitutes a 2728 // full-expression. 2729 Init = ActOnFinishFullExpr(Init.get(), InitLoc); 2730 if (Init.isInvalid()) { 2731 FD->setInvalidDecl(); 2732 return; 2733 } 2734 2735 InitExpr = Init.get(); 2736 2737 FD->setInClassInitializer(InitExpr); 2738 } 2739 2740 /// \brief Find the direct and/or virtual base specifiers that 2741 /// correspond to the given base type, for use in base initialization 2742 /// within a constructor. 2743 static bool FindBaseInitializer(Sema &SemaRef, 2744 CXXRecordDecl *ClassDecl, 2745 QualType BaseType, 2746 const CXXBaseSpecifier *&DirectBaseSpec, 2747 const CXXBaseSpecifier *&VirtualBaseSpec) { 2748 // First, check for a direct base class. 2749 DirectBaseSpec = nullptr; 2750 for (const auto &Base : ClassDecl->bases()) { 2751 if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base.getType())) { 2752 // We found a direct base of this type. That's what we're 2753 // initializing. 2754 DirectBaseSpec = &Base; 2755 break; 2756 } 2757 } 2758 2759 // Check for a virtual base class. 2760 // FIXME: We might be able to short-circuit this if we know in advance that 2761 // there are no virtual bases. 2762 VirtualBaseSpec = nullptr; 2763 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) { 2764 // We haven't found a base yet; search the class hierarchy for a 2765 // virtual base class. 2766 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 2767 /*DetectVirtual=*/false); 2768 if (SemaRef.IsDerivedFrom(ClassDecl->getLocation(), 2769 SemaRef.Context.getTypeDeclType(ClassDecl), 2770 BaseType, Paths)) { 2771 for (CXXBasePaths::paths_iterator Path = Paths.begin(); 2772 Path != Paths.end(); ++Path) { 2773 if (Path->back().Base->isVirtual()) { 2774 VirtualBaseSpec = Path->back().Base; 2775 break; 2776 } 2777 } 2778 } 2779 } 2780 2781 return DirectBaseSpec || VirtualBaseSpec; 2782 } 2783 2784 /// \brief Handle a C++ member initializer using braced-init-list syntax. 2785 MemInitResult 2786 Sema::ActOnMemInitializer(Decl *ConstructorD, 2787 Scope *S, 2788 CXXScopeSpec &SS, 2789 IdentifierInfo *MemberOrBase, 2790 ParsedType TemplateTypeTy, 2791 const DeclSpec &DS, 2792 SourceLocation IdLoc, 2793 Expr *InitList, 2794 SourceLocation EllipsisLoc) { 2795 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy, 2796 DS, IdLoc, InitList, 2797 EllipsisLoc); 2798 } 2799 2800 /// \brief Handle a C++ member initializer using parentheses syntax. 2801 MemInitResult 2802 Sema::ActOnMemInitializer(Decl *ConstructorD, 2803 Scope *S, 2804 CXXScopeSpec &SS, 2805 IdentifierInfo *MemberOrBase, 2806 ParsedType TemplateTypeTy, 2807 const DeclSpec &DS, 2808 SourceLocation IdLoc, 2809 SourceLocation LParenLoc, 2810 ArrayRef<Expr *> Args, 2811 SourceLocation RParenLoc, 2812 SourceLocation EllipsisLoc) { 2813 Expr *List = new (Context) ParenListExpr(Context, LParenLoc, 2814 Args, RParenLoc); 2815 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy, 2816 DS, IdLoc, List, EllipsisLoc); 2817 } 2818 2819 namespace { 2820 2821 // Callback to only accept typo corrections that can be a valid C++ member 2822 // intializer: either a non-static field member or a base class. 2823 class MemInitializerValidatorCCC : public CorrectionCandidateCallback { 2824 public: 2825 explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl) 2826 : ClassDecl(ClassDecl) {} 2827 2828 bool ValidateCandidate(const TypoCorrection &candidate) override { 2829 if (NamedDecl *ND = candidate.getCorrectionDecl()) { 2830 if (FieldDecl *Member = dyn_cast<FieldDecl>(ND)) 2831 return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl); 2832 return isa<TypeDecl>(ND); 2833 } 2834 return false; 2835 } 2836 2837 private: 2838 CXXRecordDecl *ClassDecl; 2839 }; 2840 2841 } 2842 2843 /// \brief Handle a C++ member initializer. 2844 MemInitResult 2845 Sema::BuildMemInitializer(Decl *ConstructorD, 2846 Scope *S, 2847 CXXScopeSpec &SS, 2848 IdentifierInfo *MemberOrBase, 2849 ParsedType TemplateTypeTy, 2850 const DeclSpec &DS, 2851 SourceLocation IdLoc, 2852 Expr *Init, 2853 SourceLocation EllipsisLoc) { 2854 ExprResult Res = CorrectDelayedTyposInExpr(Init); 2855 if (!Res.isUsable()) 2856 return true; 2857 Init = Res.get(); 2858 2859 if (!ConstructorD) 2860 return true; 2861 2862 AdjustDeclIfTemplate(ConstructorD); 2863 2864 CXXConstructorDecl *Constructor 2865 = dyn_cast<CXXConstructorDecl>(ConstructorD); 2866 if (!Constructor) { 2867 // The user wrote a constructor initializer on a function that is 2868 // not a C++ constructor. Ignore the error for now, because we may 2869 // have more member initializers coming; we'll diagnose it just 2870 // once in ActOnMemInitializers. 2871 return true; 2872 } 2873 2874 CXXRecordDecl *ClassDecl = Constructor->getParent(); 2875 2876 // C++ [class.base.init]p2: 2877 // Names in a mem-initializer-id are looked up in the scope of the 2878 // constructor's class and, if not found in that scope, are looked 2879 // up in the scope containing the constructor's definition. 2880 // [Note: if the constructor's class contains a member with the 2881 // same name as a direct or virtual base class of the class, a 2882 // mem-initializer-id naming the member or base class and composed 2883 // of a single identifier refers to the class member. A 2884 // mem-initializer-id for the hidden base class may be specified 2885 // using a qualified name. ] 2886 if (!SS.getScopeRep() && !TemplateTypeTy) { 2887 // Look for a member, first. 2888 DeclContext::lookup_result Result = ClassDecl->lookup(MemberOrBase); 2889 if (!Result.empty()) { 2890 ValueDecl *Member; 2891 if ((Member = dyn_cast<FieldDecl>(Result.front())) || 2892 (Member = dyn_cast<IndirectFieldDecl>(Result.front()))) { 2893 if (EllipsisLoc.isValid()) 2894 Diag(EllipsisLoc, diag::err_pack_expansion_member_init) 2895 << MemberOrBase 2896 << SourceRange(IdLoc, Init->getSourceRange().getEnd()); 2897 2898 return BuildMemberInitializer(Member, Init, IdLoc); 2899 } 2900 } 2901 } 2902 // It didn't name a member, so see if it names a class. 2903 QualType BaseType; 2904 TypeSourceInfo *TInfo = nullptr; 2905 2906 if (TemplateTypeTy) { 2907 BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo); 2908 } else if (DS.getTypeSpecType() == TST_decltype) { 2909 BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc()); 2910 } else { 2911 LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName); 2912 LookupParsedName(R, S, &SS); 2913 2914 TypeDecl *TyD = R.getAsSingle<TypeDecl>(); 2915 if (!TyD) { 2916 if (R.isAmbiguous()) return true; 2917 2918 // We don't want access-control diagnostics here. 2919 R.suppressDiagnostics(); 2920 2921 if (SS.isSet() && isDependentScopeSpecifier(SS)) { 2922 bool NotUnknownSpecialization = false; 2923 DeclContext *DC = computeDeclContext(SS, false); 2924 if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC)) 2925 NotUnknownSpecialization = !Record->hasAnyDependentBases(); 2926 2927 if (!NotUnknownSpecialization) { 2928 // When the scope specifier can refer to a member of an unknown 2929 // specialization, we take it as a type name. 2930 BaseType = CheckTypenameType(ETK_None, SourceLocation(), 2931 SS.getWithLocInContext(Context), 2932 *MemberOrBase, IdLoc); 2933 if (BaseType.isNull()) 2934 return true; 2935 2936 R.clear(); 2937 R.setLookupName(MemberOrBase); 2938 } 2939 } 2940 2941 // If no results were found, try to correct typos. 2942 TypoCorrection Corr; 2943 if (R.empty() && BaseType.isNull() && 2944 (Corr = CorrectTypo( 2945 R.getLookupNameInfo(), R.getLookupKind(), S, &SS, 2946 llvm::make_unique<MemInitializerValidatorCCC>(ClassDecl), 2947 CTK_ErrorRecovery, ClassDecl))) { 2948 if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) { 2949 // We have found a non-static data member with a similar 2950 // name to what was typed; complain and initialize that 2951 // member. 2952 diagnoseTypo(Corr, 2953 PDiag(diag::err_mem_init_not_member_or_class_suggest) 2954 << MemberOrBase << true); 2955 return BuildMemberInitializer(Member, Init, IdLoc); 2956 } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) { 2957 const CXXBaseSpecifier *DirectBaseSpec; 2958 const CXXBaseSpecifier *VirtualBaseSpec; 2959 if (FindBaseInitializer(*this, ClassDecl, 2960 Context.getTypeDeclType(Type), 2961 DirectBaseSpec, VirtualBaseSpec)) { 2962 // We have found a direct or virtual base class with a 2963 // similar name to what was typed; complain and initialize 2964 // that base class. 2965 diagnoseTypo(Corr, 2966 PDiag(diag::err_mem_init_not_member_or_class_suggest) 2967 << MemberOrBase << false, 2968 PDiag() /*Suppress note, we provide our own.*/); 2969 2970 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec 2971 : VirtualBaseSpec; 2972 Diag(BaseSpec->getLocStart(), 2973 diag::note_base_class_specified_here) 2974 << BaseSpec->getType() 2975 << BaseSpec->getSourceRange(); 2976 2977 TyD = Type; 2978 } 2979 } 2980 } 2981 2982 if (!TyD && BaseType.isNull()) { 2983 Diag(IdLoc, diag::err_mem_init_not_member_or_class) 2984 << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd()); 2985 return true; 2986 } 2987 } 2988 2989 if (BaseType.isNull()) { 2990 BaseType = Context.getTypeDeclType(TyD); 2991 MarkAnyDeclReferenced(TyD->getLocation(), TyD, /*OdrUse=*/false); 2992 if (SS.isSet()) { 2993 BaseType = Context.getElaboratedType(ETK_None, SS.getScopeRep(), 2994 BaseType); 2995 TInfo = Context.CreateTypeSourceInfo(BaseType); 2996 ElaboratedTypeLoc TL = TInfo->getTypeLoc().castAs<ElaboratedTypeLoc>(); 2997 TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc); 2998 TL.setElaboratedKeywordLoc(SourceLocation()); 2999 TL.setQualifierLoc(SS.getWithLocInContext(Context)); 3000 } 3001 } 3002 } 3003 3004 if (!TInfo) 3005 TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc); 3006 3007 return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc); 3008 } 3009 3010 /// Checks a member initializer expression for cases where reference (or 3011 /// pointer) members are bound to by-value parameters (or their addresses). 3012 static void CheckForDanglingReferenceOrPointer(Sema &S, ValueDecl *Member, 3013 Expr *Init, 3014 SourceLocation IdLoc) { 3015 QualType MemberTy = Member->getType(); 3016 3017 // We only handle pointers and references currently. 3018 // FIXME: Would this be relevant for ObjC object pointers? Or block pointers? 3019 if (!MemberTy->isReferenceType() && !MemberTy->isPointerType()) 3020 return; 3021 3022 const bool IsPointer = MemberTy->isPointerType(); 3023 if (IsPointer) { 3024 if (const UnaryOperator *Op 3025 = dyn_cast<UnaryOperator>(Init->IgnoreParenImpCasts())) { 3026 // The only case we're worried about with pointers requires taking the 3027 // address. 3028 if (Op->getOpcode() != UO_AddrOf) 3029 return; 3030 3031 Init = Op->getSubExpr(); 3032 } else { 3033 // We only handle address-of expression initializers for pointers. 3034 return; 3035 } 3036 } 3037 3038 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Init->IgnoreParens())) { 3039 // We only warn when referring to a non-reference parameter declaration. 3040 const ParmVarDecl *Parameter = dyn_cast<ParmVarDecl>(DRE->getDecl()); 3041 if (!Parameter || Parameter->getType()->isReferenceType()) 3042 return; 3043 3044 S.Diag(Init->getExprLoc(), 3045 IsPointer ? diag::warn_init_ptr_member_to_parameter_addr 3046 : diag::warn_bind_ref_member_to_parameter) 3047 << Member << Parameter << Init->getSourceRange(); 3048 } else { 3049 // Other initializers are fine. 3050 return; 3051 } 3052 3053 S.Diag(Member->getLocation(), diag::note_ref_or_ptr_member_declared_here) 3054 << (unsigned)IsPointer; 3055 } 3056 3057 MemInitResult 3058 Sema::BuildMemberInitializer(ValueDecl *Member, Expr *Init, 3059 SourceLocation IdLoc) { 3060 FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member); 3061 IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member); 3062 assert((DirectMember || IndirectMember) && 3063 "Member must be a FieldDecl or IndirectFieldDecl"); 3064 3065 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) 3066 return true; 3067 3068 if (Member->isInvalidDecl()) 3069 return true; 3070 3071 MultiExprArg Args; 3072 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) { 3073 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs()); 3074 } else if (InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) { 3075 Args = MultiExprArg(InitList->getInits(), InitList->getNumInits()); 3076 } else { 3077 // Template instantiation doesn't reconstruct ParenListExprs for us. 3078 Args = Init; 3079 } 3080 3081 SourceRange InitRange = Init->getSourceRange(); 3082 3083 if (Member->getType()->isDependentType() || Init->isTypeDependent()) { 3084 // Can't check initialization for a member of dependent type or when 3085 // any of the arguments are type-dependent expressions. 3086 DiscardCleanupsInEvaluationContext(); 3087 } else { 3088 bool InitList = false; 3089 if (isa<InitListExpr>(Init)) { 3090 InitList = true; 3091 Args = Init; 3092 } 3093 3094 // Initialize the member. 3095 InitializedEntity MemberEntity = 3096 DirectMember ? InitializedEntity::InitializeMember(DirectMember, nullptr) 3097 : InitializedEntity::InitializeMember(IndirectMember, 3098 nullptr); 3099 InitializationKind Kind = 3100 InitList ? InitializationKind::CreateDirectList(IdLoc) 3101 : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(), 3102 InitRange.getEnd()); 3103 3104 InitializationSequence InitSeq(*this, MemberEntity, Kind, Args); 3105 ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind, Args, 3106 nullptr); 3107 if (MemberInit.isInvalid()) 3108 return true; 3109 3110 CheckForDanglingReferenceOrPointer(*this, Member, MemberInit.get(), IdLoc); 3111 3112 // C++11 [class.base.init]p7: 3113 // The initialization of each base and member constitutes a 3114 // full-expression. 3115 MemberInit = ActOnFinishFullExpr(MemberInit.get(), InitRange.getBegin()); 3116 if (MemberInit.isInvalid()) 3117 return true; 3118 3119 Init = MemberInit.get(); 3120 } 3121 3122 if (DirectMember) { 3123 return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc, 3124 InitRange.getBegin(), Init, 3125 InitRange.getEnd()); 3126 } else { 3127 return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc, 3128 InitRange.getBegin(), Init, 3129 InitRange.getEnd()); 3130 } 3131 } 3132 3133 MemInitResult 3134 Sema::BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, 3135 CXXRecordDecl *ClassDecl) { 3136 SourceLocation NameLoc = TInfo->getTypeLoc().getLocalSourceRange().getBegin(); 3137 if (!LangOpts.CPlusPlus11) 3138 return Diag(NameLoc, diag::err_delegating_ctor) 3139 << TInfo->getTypeLoc().getLocalSourceRange(); 3140 Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor); 3141 3142 bool InitList = true; 3143 MultiExprArg Args = Init; 3144 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) { 3145 InitList = false; 3146 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs()); 3147 } 3148 3149 SourceRange InitRange = Init->getSourceRange(); 3150 // Initialize the object. 3151 InitializedEntity DelegationEntity = InitializedEntity::InitializeDelegation( 3152 QualType(ClassDecl->getTypeForDecl(), 0)); 3153 InitializationKind Kind = 3154 InitList ? InitializationKind::CreateDirectList(NameLoc) 3155 : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(), 3156 InitRange.getEnd()); 3157 InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args); 3158 ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind, 3159 Args, nullptr); 3160 if (DelegationInit.isInvalid()) 3161 return true; 3162 3163 assert(cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() && 3164 "Delegating constructor with no target?"); 3165 3166 // C++11 [class.base.init]p7: 3167 // The initialization of each base and member constitutes a 3168 // full-expression. 3169 DelegationInit = ActOnFinishFullExpr(DelegationInit.get(), 3170 InitRange.getBegin()); 3171 if (DelegationInit.isInvalid()) 3172 return true; 3173 3174 // If we are in a dependent context, template instantiation will 3175 // perform this type-checking again. Just save the arguments that we 3176 // received in a ParenListExpr. 3177 // FIXME: This isn't quite ideal, since our ASTs don't capture all 3178 // of the information that we have about the base 3179 // initializer. However, deconstructing the ASTs is a dicey process, 3180 // and this approach is far more likely to get the corner cases right. 3181 if (CurContext->isDependentContext()) 3182 DelegationInit = Init; 3183 3184 return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(), 3185 DelegationInit.getAs<Expr>(), 3186 InitRange.getEnd()); 3187 } 3188 3189 MemInitResult 3190 Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo, 3191 Expr *Init, CXXRecordDecl *ClassDecl, 3192 SourceLocation EllipsisLoc) { 3193 SourceLocation BaseLoc 3194 = BaseTInfo->getTypeLoc().getLocalSourceRange().getBegin(); 3195 3196 if (!BaseType->isDependentType() && !BaseType->isRecordType()) 3197 return Diag(BaseLoc, diag::err_base_init_does_not_name_class) 3198 << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange(); 3199 3200 // C++ [class.base.init]p2: 3201 // [...] Unless the mem-initializer-id names a nonstatic data 3202 // member of the constructor's class or a direct or virtual base 3203 // of that class, the mem-initializer is ill-formed. A 3204 // mem-initializer-list can initialize a base class using any 3205 // name that denotes that base class type. 3206 bool Dependent = BaseType->isDependentType() || Init->isTypeDependent(); 3207 3208 SourceRange InitRange = Init->getSourceRange(); 3209 if (EllipsisLoc.isValid()) { 3210 // This is a pack expansion. 3211 if (!BaseType->containsUnexpandedParameterPack()) { 3212 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) 3213 << SourceRange(BaseLoc, InitRange.getEnd()); 3214 3215 EllipsisLoc = SourceLocation(); 3216 } 3217 } else { 3218 // Check for any unexpanded parameter packs. 3219 if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer)) 3220 return true; 3221 3222 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) 3223 return true; 3224 } 3225 3226 // Check for direct and virtual base classes. 3227 const CXXBaseSpecifier *DirectBaseSpec = nullptr; 3228 const CXXBaseSpecifier *VirtualBaseSpec = nullptr; 3229 if (!Dependent) { 3230 if (Context.hasSameUnqualifiedType(QualType(ClassDecl->getTypeForDecl(),0), 3231 BaseType)) 3232 return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl); 3233 3234 FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec, 3235 VirtualBaseSpec); 3236 3237 // C++ [base.class.init]p2: 3238 // Unless the mem-initializer-id names a nonstatic data member of the 3239 // constructor's class or a direct or virtual base of that class, the 3240 // mem-initializer is ill-formed. 3241 if (!DirectBaseSpec && !VirtualBaseSpec) { 3242 // If the class has any dependent bases, then it's possible that 3243 // one of those types will resolve to the same type as 3244 // BaseType. Therefore, just treat this as a dependent base 3245 // class initialization. FIXME: Should we try to check the 3246 // initialization anyway? It seems odd. 3247 if (ClassDecl->hasAnyDependentBases()) 3248 Dependent = true; 3249 else 3250 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual) 3251 << BaseType << Context.getTypeDeclType(ClassDecl) 3252 << BaseTInfo->getTypeLoc().getLocalSourceRange(); 3253 } 3254 } 3255 3256 if (Dependent) { 3257 DiscardCleanupsInEvaluationContext(); 3258 3259 return new (Context) CXXCtorInitializer(Context, BaseTInfo, 3260 /*IsVirtual=*/false, 3261 InitRange.getBegin(), Init, 3262 InitRange.getEnd(), EllipsisLoc); 3263 } 3264 3265 // C++ [base.class.init]p2: 3266 // If a mem-initializer-id is ambiguous because it designates both 3267 // a direct non-virtual base class and an inherited virtual base 3268 // class, the mem-initializer is ill-formed. 3269 if (DirectBaseSpec && VirtualBaseSpec) 3270 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual) 3271 << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange(); 3272 3273 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec; 3274 if (!BaseSpec) 3275 BaseSpec = VirtualBaseSpec; 3276 3277 // Initialize the base. 3278 bool InitList = true; 3279 MultiExprArg Args = Init; 3280 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) { 3281 InitList = false; 3282 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs()); 3283 } 3284 3285 InitializedEntity BaseEntity = 3286 InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec); 3287 InitializationKind Kind = 3288 InitList ? InitializationKind::CreateDirectList(BaseLoc) 3289 : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(), 3290 InitRange.getEnd()); 3291 InitializationSequence InitSeq(*this, BaseEntity, Kind, Args); 3292 ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind, Args, nullptr); 3293 if (BaseInit.isInvalid()) 3294 return true; 3295 3296 // C++11 [class.base.init]p7: 3297 // The initialization of each base and member constitutes a 3298 // full-expression. 3299 BaseInit = ActOnFinishFullExpr(BaseInit.get(), InitRange.getBegin()); 3300 if (BaseInit.isInvalid()) 3301 return true; 3302 3303 // If we are in a dependent context, template instantiation will 3304 // perform this type-checking again. Just save the arguments that we 3305 // received in a ParenListExpr. 3306 // FIXME: This isn't quite ideal, since our ASTs don't capture all 3307 // of the information that we have about the base 3308 // initializer. However, deconstructing the ASTs is a dicey process, 3309 // and this approach is far more likely to get the corner cases right. 3310 if (CurContext->isDependentContext()) 3311 BaseInit = Init; 3312 3313 return new (Context) CXXCtorInitializer(Context, BaseTInfo, 3314 BaseSpec->isVirtual(), 3315 InitRange.getBegin(), 3316 BaseInit.getAs<Expr>(), 3317 InitRange.getEnd(), EllipsisLoc); 3318 } 3319 3320 // Create a static_cast\<T&&>(expr). 3321 static Expr *CastForMoving(Sema &SemaRef, Expr *E, QualType T = QualType()) { 3322 if (T.isNull()) T = E->getType(); 3323 QualType TargetType = SemaRef.BuildReferenceType( 3324 T, /*SpelledAsLValue*/false, SourceLocation(), DeclarationName()); 3325 SourceLocation ExprLoc = E->getLocStart(); 3326 TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo( 3327 TargetType, ExprLoc); 3328 3329 return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E, 3330 SourceRange(ExprLoc, ExprLoc), 3331 E->getSourceRange()).get(); 3332 } 3333 3334 /// ImplicitInitializerKind - How an implicit base or member initializer should 3335 /// initialize its base or member. 3336 enum ImplicitInitializerKind { 3337 IIK_Default, 3338 IIK_Copy, 3339 IIK_Move, 3340 IIK_Inherit 3341 }; 3342 3343 static bool 3344 BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, 3345 ImplicitInitializerKind ImplicitInitKind, 3346 CXXBaseSpecifier *BaseSpec, 3347 bool IsInheritedVirtualBase, 3348 CXXCtorInitializer *&CXXBaseInit) { 3349 InitializedEntity InitEntity 3350 = InitializedEntity::InitializeBase(SemaRef.Context, BaseSpec, 3351 IsInheritedVirtualBase); 3352 3353 ExprResult BaseInit; 3354 3355 switch (ImplicitInitKind) { 3356 case IIK_Inherit: { 3357 const CXXRecordDecl *Inherited = 3358 Constructor->getInheritedConstructor()->getParent(); 3359 const CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl(); 3360 if (Base && Inherited->getCanonicalDecl() == Base->getCanonicalDecl()) { 3361 // C++11 [class.inhctor]p8: 3362 // Each expression in the expression-list is of the form 3363 // static_cast<T&&>(p), where p is the name of the corresponding 3364 // constructor parameter and T is the declared type of p. 3365 SmallVector<Expr*, 16> Args; 3366 for (unsigned I = 0, E = Constructor->getNumParams(); I != E; ++I) { 3367 ParmVarDecl *PD = Constructor->getParamDecl(I); 3368 ExprResult ArgExpr = 3369 SemaRef.BuildDeclRefExpr(PD, PD->getType().getNonReferenceType(), 3370 VK_LValue, SourceLocation()); 3371 if (ArgExpr.isInvalid()) 3372 return true; 3373 Args.push_back(CastForMoving(SemaRef, ArgExpr.get(), PD->getType())); 3374 } 3375 3376 InitializationKind InitKind = InitializationKind::CreateDirect( 3377 Constructor->getLocation(), SourceLocation(), SourceLocation()); 3378 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, Args); 3379 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, Args); 3380 break; 3381 } 3382 } 3383 // Fall through. 3384 case IIK_Default: { 3385 InitializationKind InitKind 3386 = InitializationKind::CreateDefault(Constructor->getLocation()); 3387 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None); 3388 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, None); 3389 break; 3390 } 3391 3392 case IIK_Move: 3393 case IIK_Copy: { 3394 bool Moving = ImplicitInitKind == IIK_Move; 3395 ParmVarDecl *Param = Constructor->getParamDecl(0); 3396 QualType ParamType = Param->getType().getNonReferenceType(); 3397 3398 Expr *CopyCtorArg = 3399 DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(), 3400 SourceLocation(), Param, false, 3401 Constructor->getLocation(), ParamType, 3402 VK_LValue, nullptr); 3403 3404 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg)); 3405 3406 // Cast to the base class to avoid ambiguities. 3407 QualType ArgTy = 3408 SemaRef.Context.getQualifiedType(BaseSpec->getType().getUnqualifiedType(), 3409 ParamType.getQualifiers()); 3410 3411 if (Moving) { 3412 CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg); 3413 } 3414 3415 CXXCastPath BasePath; 3416 BasePath.push_back(BaseSpec); 3417 CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy, 3418 CK_UncheckedDerivedToBase, 3419 Moving ? VK_XValue : VK_LValue, 3420 &BasePath).get(); 3421 3422 InitializationKind InitKind 3423 = InitializationKind::CreateDirect(Constructor->getLocation(), 3424 SourceLocation(), SourceLocation()); 3425 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, CopyCtorArg); 3426 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, CopyCtorArg); 3427 break; 3428 } 3429 } 3430 3431 BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit); 3432 if (BaseInit.isInvalid()) 3433 return true; 3434 3435 CXXBaseInit = 3436 new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, 3437 SemaRef.Context.getTrivialTypeSourceInfo(BaseSpec->getType(), 3438 SourceLocation()), 3439 BaseSpec->isVirtual(), 3440 SourceLocation(), 3441 BaseInit.getAs<Expr>(), 3442 SourceLocation(), 3443 SourceLocation()); 3444 3445 return false; 3446 } 3447 3448 static bool RefersToRValueRef(Expr *MemRef) { 3449 ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl(); 3450 return Referenced->getType()->isRValueReferenceType(); 3451 } 3452 3453 static bool 3454 BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, 3455 ImplicitInitializerKind ImplicitInitKind, 3456 FieldDecl *Field, IndirectFieldDecl *Indirect, 3457 CXXCtorInitializer *&CXXMemberInit) { 3458 if (Field->isInvalidDecl()) 3459 return true; 3460 3461 SourceLocation Loc = Constructor->getLocation(); 3462 3463 if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) { 3464 bool Moving = ImplicitInitKind == IIK_Move; 3465 ParmVarDecl *Param = Constructor->getParamDecl(0); 3466 QualType ParamType = Param->getType().getNonReferenceType(); 3467 3468 // Suppress copying zero-width bitfields. 3469 if (Field->isBitField() && Field->getBitWidthValue(SemaRef.Context) == 0) 3470 return false; 3471 3472 Expr *MemberExprBase = 3473 DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(), 3474 SourceLocation(), Param, false, 3475 Loc, ParamType, VK_LValue, nullptr); 3476 3477 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase)); 3478 3479 if (Moving) { 3480 MemberExprBase = CastForMoving(SemaRef, MemberExprBase); 3481 } 3482 3483 // Build a reference to this field within the parameter. 3484 CXXScopeSpec SS; 3485 LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc, 3486 Sema::LookupMemberName); 3487 MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect) 3488 : cast<ValueDecl>(Field), AS_public); 3489 MemberLookup.resolveKind(); 3490 ExprResult CtorArg 3491 = SemaRef.BuildMemberReferenceExpr(MemberExprBase, 3492 ParamType, Loc, 3493 /*IsArrow=*/false, 3494 SS, 3495 /*TemplateKWLoc=*/SourceLocation(), 3496 /*FirstQualifierInScope=*/nullptr, 3497 MemberLookup, 3498 /*TemplateArgs=*/nullptr, 3499 /*S*/nullptr); 3500 if (CtorArg.isInvalid()) 3501 return true; 3502 3503 // C++11 [class.copy]p15: 3504 // - if a member m has rvalue reference type T&&, it is direct-initialized 3505 // with static_cast<T&&>(x.m); 3506 if (RefersToRValueRef(CtorArg.get())) { 3507 CtorArg = CastForMoving(SemaRef, CtorArg.get()); 3508 } 3509 3510 // When the field we are copying is an array, create index variables for 3511 // each dimension of the array. We use these index variables to subscript 3512 // the source array, and other clients (e.g., CodeGen) will perform the 3513 // necessary iteration with these index variables. 3514 SmallVector<VarDecl *, 4> IndexVariables; 3515 QualType BaseType = Field->getType(); 3516 QualType SizeType = SemaRef.Context.getSizeType(); 3517 bool InitializingArray = false; 3518 while (const ConstantArrayType *Array 3519 = SemaRef.Context.getAsConstantArrayType(BaseType)) { 3520 InitializingArray = true; 3521 // Create the iteration variable for this array index. 3522 IdentifierInfo *IterationVarName = nullptr; 3523 { 3524 SmallString<8> Str; 3525 llvm::raw_svector_ostream OS(Str); 3526 OS << "__i" << IndexVariables.size(); 3527 IterationVarName = &SemaRef.Context.Idents.get(OS.str()); 3528 } 3529 VarDecl *IterationVar 3530 = VarDecl::Create(SemaRef.Context, SemaRef.CurContext, Loc, Loc, 3531 IterationVarName, SizeType, 3532 SemaRef.Context.getTrivialTypeSourceInfo(SizeType, Loc), 3533 SC_None); 3534 IndexVariables.push_back(IterationVar); 3535 3536 // Create a reference to the iteration variable. 3537 ExprResult IterationVarRef 3538 = SemaRef.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc); 3539 assert(!IterationVarRef.isInvalid() && 3540 "Reference to invented variable cannot fail!"); 3541 IterationVarRef = SemaRef.DefaultLvalueConversion(IterationVarRef.get()); 3542 assert(!IterationVarRef.isInvalid() && 3543 "Conversion of invented variable cannot fail!"); 3544 3545 // Subscript the array with this iteration variable. 3546 CtorArg = SemaRef.CreateBuiltinArraySubscriptExpr(CtorArg.get(), Loc, 3547 IterationVarRef.get(), 3548 Loc); 3549 if (CtorArg.isInvalid()) 3550 return true; 3551 3552 BaseType = Array->getElementType(); 3553 } 3554 3555 // The array subscript expression is an lvalue, which is wrong for moving. 3556 if (Moving && InitializingArray) 3557 CtorArg = CastForMoving(SemaRef, CtorArg.get()); 3558 3559 // Construct the entity that we will be initializing. For an array, this 3560 // will be first element in the array, which may require several levels 3561 // of array-subscript entities. 3562 SmallVector<InitializedEntity, 4> Entities; 3563 Entities.reserve(1 + IndexVariables.size()); 3564 if (Indirect) 3565 Entities.push_back(InitializedEntity::InitializeMember(Indirect)); 3566 else 3567 Entities.push_back(InitializedEntity::InitializeMember(Field)); 3568 for (unsigned I = 0, N = IndexVariables.size(); I != N; ++I) 3569 Entities.push_back(InitializedEntity::InitializeElement(SemaRef.Context, 3570 0, 3571 Entities.back())); 3572 3573 // Direct-initialize to use the copy constructor. 3574 InitializationKind InitKind = 3575 InitializationKind::CreateDirect(Loc, SourceLocation(), SourceLocation()); 3576 3577 Expr *CtorArgE = CtorArg.getAs<Expr>(); 3578 InitializationSequence InitSeq(SemaRef, Entities.back(), InitKind, 3579 CtorArgE); 3580 3581 ExprResult MemberInit 3582 = InitSeq.Perform(SemaRef, Entities.back(), InitKind, 3583 MultiExprArg(&CtorArgE, 1)); 3584 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit); 3585 if (MemberInit.isInvalid()) 3586 return true; 3587 3588 if (Indirect) { 3589 assert(IndexVariables.size() == 0 && 3590 "Indirect field improperly initialized"); 3591 CXXMemberInit 3592 = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Indirect, 3593 Loc, Loc, 3594 MemberInit.getAs<Expr>(), 3595 Loc); 3596 } else 3597 CXXMemberInit = CXXCtorInitializer::Create(SemaRef.Context, Field, Loc, 3598 Loc, MemberInit.getAs<Expr>(), 3599 Loc, 3600 IndexVariables.data(), 3601 IndexVariables.size()); 3602 return false; 3603 } 3604 3605 assert((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) && 3606 "Unhandled implicit init kind!"); 3607 3608 QualType FieldBaseElementType = 3609 SemaRef.Context.getBaseElementType(Field->getType()); 3610 3611 if (FieldBaseElementType->isRecordType()) { 3612 InitializedEntity InitEntity 3613 = Indirect? InitializedEntity::InitializeMember(Indirect) 3614 : InitializedEntity::InitializeMember(Field); 3615 InitializationKind InitKind = 3616 InitializationKind::CreateDefault(Loc); 3617 3618 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None); 3619 ExprResult MemberInit = 3620 InitSeq.Perform(SemaRef, InitEntity, InitKind, None); 3621 3622 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit); 3623 if (MemberInit.isInvalid()) 3624 return true; 3625 3626 if (Indirect) 3627 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, 3628 Indirect, Loc, 3629 Loc, 3630 MemberInit.get(), 3631 Loc); 3632 else 3633 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, 3634 Field, Loc, Loc, 3635 MemberInit.get(), 3636 Loc); 3637 return false; 3638 } 3639 3640 if (!Field->getParent()->isUnion()) { 3641 if (FieldBaseElementType->isReferenceType()) { 3642 SemaRef.Diag(Constructor->getLocation(), 3643 diag::err_uninitialized_member_in_ctor) 3644 << (int)Constructor->isImplicit() 3645 << SemaRef.Context.getTagDeclType(Constructor->getParent()) 3646 << 0 << Field->getDeclName(); 3647 SemaRef.Diag(Field->getLocation(), diag::note_declared_at); 3648 return true; 3649 } 3650 3651 if (FieldBaseElementType.isConstQualified()) { 3652 SemaRef.Diag(Constructor->getLocation(), 3653 diag::err_uninitialized_member_in_ctor) 3654 << (int)Constructor->isImplicit() 3655 << SemaRef.Context.getTagDeclType(Constructor->getParent()) 3656 << 1 << Field->getDeclName(); 3657 SemaRef.Diag(Field->getLocation(), diag::note_declared_at); 3658 return true; 3659 } 3660 } 3661 3662 if (SemaRef.getLangOpts().ObjCAutoRefCount && 3663 FieldBaseElementType->isObjCRetainableType() && 3664 FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_None && 3665 FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_ExplicitNone) { 3666 // ARC: 3667 // Default-initialize Objective-C pointers to NULL. 3668 CXXMemberInit 3669 = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field, 3670 Loc, Loc, 3671 new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()), 3672 Loc); 3673 return false; 3674 } 3675 3676 // Nothing to initialize. 3677 CXXMemberInit = nullptr; 3678 return false; 3679 } 3680 3681 namespace { 3682 struct BaseAndFieldInfo { 3683 Sema &S; 3684 CXXConstructorDecl *Ctor; 3685 bool AnyErrorsInInits; 3686 ImplicitInitializerKind IIK; 3687 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields; 3688 SmallVector<CXXCtorInitializer*, 8> AllToInit; 3689 llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember; 3690 3691 BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits) 3692 : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) { 3693 bool Generated = Ctor->isImplicit() || Ctor->isDefaulted(); 3694 if (Generated && Ctor->isCopyConstructor()) 3695 IIK = IIK_Copy; 3696 else if (Generated && Ctor->isMoveConstructor()) 3697 IIK = IIK_Move; 3698 else if (Ctor->getInheritedConstructor()) 3699 IIK = IIK_Inherit; 3700 else 3701 IIK = IIK_Default; 3702 } 3703 3704 bool isImplicitCopyOrMove() const { 3705 switch (IIK) { 3706 case IIK_Copy: 3707 case IIK_Move: 3708 return true; 3709 3710 case IIK_Default: 3711 case IIK_Inherit: 3712 return false; 3713 } 3714 3715 llvm_unreachable("Invalid ImplicitInitializerKind!"); 3716 } 3717 3718 bool addFieldInitializer(CXXCtorInitializer *Init) { 3719 AllToInit.push_back(Init); 3720 3721 // Check whether this initializer makes the field "used". 3722 if (Init->getInit()->HasSideEffects(S.Context)) 3723 S.UnusedPrivateFields.remove(Init->getAnyMember()); 3724 3725 return false; 3726 } 3727 3728 bool isInactiveUnionMember(FieldDecl *Field) { 3729 RecordDecl *Record = Field->getParent(); 3730 if (!Record->isUnion()) 3731 return false; 3732 3733 if (FieldDecl *Active = 3734 ActiveUnionMember.lookup(Record->getCanonicalDecl())) 3735 return Active != Field->getCanonicalDecl(); 3736 3737 // In an implicit copy or move constructor, ignore any in-class initializer. 3738 if (isImplicitCopyOrMove()) 3739 return true; 3740 3741 // If there's no explicit initialization, the field is active only if it 3742 // has an in-class initializer... 3743 if (Field->hasInClassInitializer()) 3744 return false; 3745 // ... or it's an anonymous struct or union whose class has an in-class 3746 // initializer. 3747 if (!Field->isAnonymousStructOrUnion()) 3748 return true; 3749 CXXRecordDecl *FieldRD = Field->getType()->getAsCXXRecordDecl(); 3750 return !FieldRD->hasInClassInitializer(); 3751 } 3752 3753 /// \brief Determine whether the given field is, or is within, a union member 3754 /// that is inactive (because there was an initializer given for a different 3755 /// member of the union, or because the union was not initialized at all). 3756 bool isWithinInactiveUnionMember(FieldDecl *Field, 3757 IndirectFieldDecl *Indirect) { 3758 if (!Indirect) 3759 return isInactiveUnionMember(Field); 3760 3761 for (auto *C : Indirect->chain()) { 3762 FieldDecl *Field = dyn_cast<FieldDecl>(C); 3763 if (Field && isInactiveUnionMember(Field)) 3764 return true; 3765 } 3766 return false; 3767 } 3768 }; 3769 } 3770 3771 /// \brief Determine whether the given type is an incomplete or zero-lenfgth 3772 /// array type. 3773 static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T) { 3774 if (T->isIncompleteArrayType()) 3775 return true; 3776 3777 while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) { 3778 if (!ArrayT->getSize()) 3779 return true; 3780 3781 T = ArrayT->getElementType(); 3782 } 3783 3784 return false; 3785 } 3786 3787 static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info, 3788 FieldDecl *Field, 3789 IndirectFieldDecl *Indirect = nullptr) { 3790 if (Field->isInvalidDecl()) 3791 return false; 3792 3793 // Overwhelmingly common case: we have a direct initializer for this field. 3794 if (CXXCtorInitializer *Init = 3795 Info.AllBaseFields.lookup(Field->getCanonicalDecl())) 3796 return Info.addFieldInitializer(Init); 3797 3798 // C++11 [class.base.init]p8: 3799 // if the entity is a non-static data member that has a 3800 // brace-or-equal-initializer and either 3801 // -- the constructor's class is a union and no other variant member of that 3802 // union is designated by a mem-initializer-id or 3803 // -- the constructor's class is not a union, and, if the entity is a member 3804 // of an anonymous union, no other member of that union is designated by 3805 // a mem-initializer-id, 3806 // the entity is initialized as specified in [dcl.init]. 3807 // 3808 // We also apply the same rules to handle anonymous structs within anonymous 3809 // unions. 3810 if (Info.isWithinInactiveUnionMember(Field, Indirect)) 3811 return false; 3812 3813 if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) { 3814 ExprResult DIE = 3815 SemaRef.BuildCXXDefaultInitExpr(Info.Ctor->getLocation(), Field); 3816 if (DIE.isInvalid()) 3817 return true; 3818 CXXCtorInitializer *Init; 3819 if (Indirect) 3820 Init = new (SemaRef.Context) 3821 CXXCtorInitializer(SemaRef.Context, Indirect, SourceLocation(), 3822 SourceLocation(), DIE.get(), SourceLocation()); 3823 else 3824 Init = new (SemaRef.Context) 3825 CXXCtorInitializer(SemaRef.Context, Field, SourceLocation(), 3826 SourceLocation(), DIE.get(), SourceLocation()); 3827 return Info.addFieldInitializer(Init); 3828 } 3829 3830 // Don't initialize incomplete or zero-length arrays. 3831 if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType())) 3832 return false; 3833 3834 // Don't try to build an implicit initializer if there were semantic 3835 // errors in any of the initializers (and therefore we might be 3836 // missing some that the user actually wrote). 3837 if (Info.AnyErrorsInInits) 3838 return false; 3839 3840 CXXCtorInitializer *Init = nullptr; 3841 if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field, 3842 Indirect, Init)) 3843 return true; 3844 3845 if (!Init) 3846 return false; 3847 3848 return Info.addFieldInitializer(Init); 3849 } 3850 3851 bool 3852 Sema::SetDelegatingInitializer(CXXConstructorDecl *Constructor, 3853 CXXCtorInitializer *Initializer) { 3854 assert(Initializer->isDelegatingInitializer()); 3855 Constructor->setNumCtorInitializers(1); 3856 CXXCtorInitializer **initializer = 3857 new (Context) CXXCtorInitializer*[1]; 3858 memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*)); 3859 Constructor->setCtorInitializers(initializer); 3860 3861 if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) { 3862 MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor); 3863 DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation()); 3864 } 3865 3866 DelegatingCtorDecls.push_back(Constructor); 3867 3868 DiagnoseUninitializedFields(*this, Constructor); 3869 3870 return false; 3871 } 3872 3873 bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, 3874 ArrayRef<CXXCtorInitializer *> Initializers) { 3875 if (Constructor->isDependentContext()) { 3876 // Just store the initializers as written, they will be checked during 3877 // instantiation. 3878 if (!Initializers.empty()) { 3879 Constructor->setNumCtorInitializers(Initializers.size()); 3880 CXXCtorInitializer **baseOrMemberInitializers = 3881 new (Context) CXXCtorInitializer*[Initializers.size()]; 3882 memcpy(baseOrMemberInitializers, Initializers.data(), 3883 Initializers.size() * sizeof(CXXCtorInitializer*)); 3884 Constructor->setCtorInitializers(baseOrMemberInitializers); 3885 } 3886 3887 // Let template instantiation know whether we had errors. 3888 if (AnyErrors) 3889 Constructor->setInvalidDecl(); 3890 3891 return false; 3892 } 3893 3894 BaseAndFieldInfo Info(*this, Constructor, AnyErrors); 3895 3896 // We need to build the initializer AST according to order of construction 3897 // and not what user specified in the Initializers list. 3898 CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition(); 3899 if (!ClassDecl) 3900 return true; 3901 3902 bool HadError = false; 3903 3904 for (unsigned i = 0; i < Initializers.size(); i++) { 3905 CXXCtorInitializer *Member = Initializers[i]; 3906 3907 if (Member->isBaseInitializer()) 3908 Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member; 3909 else { 3910 Info.AllBaseFields[Member->getAnyMember()->getCanonicalDecl()] = Member; 3911 3912 if (IndirectFieldDecl *F = Member->getIndirectMember()) { 3913 for (auto *C : F->chain()) { 3914 FieldDecl *FD = dyn_cast<FieldDecl>(C); 3915 if (FD && FD->getParent()->isUnion()) 3916 Info.ActiveUnionMember.insert(std::make_pair( 3917 FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl())); 3918 } 3919 } else if (FieldDecl *FD = Member->getMember()) { 3920 if (FD->getParent()->isUnion()) 3921 Info.ActiveUnionMember.insert(std::make_pair( 3922 FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl())); 3923 } 3924 } 3925 } 3926 3927 // Keep track of the direct virtual bases. 3928 llvm::SmallPtrSet<CXXBaseSpecifier *, 16> DirectVBases; 3929 for (auto &I : ClassDecl->bases()) { 3930 if (I.isVirtual()) 3931 DirectVBases.insert(&I); 3932 } 3933 3934 // Push virtual bases before others. 3935 for (auto &VBase : ClassDecl->vbases()) { 3936 if (CXXCtorInitializer *Value 3937 = Info.AllBaseFields.lookup(VBase.getType()->getAs<RecordType>())) { 3938 // [class.base.init]p7, per DR257: 3939 // A mem-initializer where the mem-initializer-id names a virtual base 3940 // class is ignored during execution of a constructor of any class that 3941 // is not the most derived class. 3942 if (ClassDecl->isAbstract()) { 3943 // FIXME: Provide a fixit to remove the base specifier. This requires 3944 // tracking the location of the associated comma for a base specifier. 3945 Diag(Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored) 3946 << VBase.getType() << ClassDecl; 3947 DiagnoseAbstractType(ClassDecl); 3948 } 3949 3950 Info.AllToInit.push_back(Value); 3951 } else if (!AnyErrors && !ClassDecl->isAbstract()) { 3952 // [class.base.init]p8, per DR257: 3953 // If a given [...] base class is not named by a mem-initializer-id 3954 // [...] and the entity is not a virtual base class of an abstract 3955 // class, then [...] the entity is default-initialized. 3956 bool IsInheritedVirtualBase = !DirectVBases.count(&VBase); 3957 CXXCtorInitializer *CXXBaseInit; 3958 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK, 3959 &VBase, IsInheritedVirtualBase, 3960 CXXBaseInit)) { 3961 HadError = true; 3962 continue; 3963 } 3964 3965 Info.AllToInit.push_back(CXXBaseInit); 3966 } 3967 } 3968 3969 // Non-virtual bases. 3970 for (auto &Base : ClassDecl->bases()) { 3971 // Virtuals are in the virtual base list and already constructed. 3972 if (Base.isVirtual()) 3973 continue; 3974 3975 if (CXXCtorInitializer *Value 3976 = Info.AllBaseFields.lookup(Base.getType()->getAs<RecordType>())) { 3977 Info.AllToInit.push_back(Value); 3978 } else if (!AnyErrors) { 3979 CXXCtorInitializer *CXXBaseInit; 3980 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK, 3981 &Base, /*IsInheritedVirtualBase=*/false, 3982 CXXBaseInit)) { 3983 HadError = true; 3984 continue; 3985 } 3986 3987 Info.AllToInit.push_back(CXXBaseInit); 3988 } 3989 } 3990 3991 // Fields. 3992 for (auto *Mem : ClassDecl->decls()) { 3993 if (auto *F = dyn_cast<FieldDecl>(Mem)) { 3994 // C++ [class.bit]p2: 3995 // A declaration for a bit-field that omits the identifier declares an 3996 // unnamed bit-field. Unnamed bit-fields are not members and cannot be 3997 // initialized. 3998 if (F->isUnnamedBitfield()) 3999 continue; 4000 4001 // If we're not generating the implicit copy/move constructor, then we'll 4002 // handle anonymous struct/union fields based on their individual 4003 // indirect fields. 4004 if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove()) 4005 continue; 4006 4007 if (CollectFieldInitializer(*this, Info, F)) 4008 HadError = true; 4009 continue; 4010 } 4011 4012 // Beyond this point, we only consider default initialization. 4013 if (Info.isImplicitCopyOrMove()) 4014 continue; 4015 4016 if (auto *F = dyn_cast<IndirectFieldDecl>(Mem)) { 4017 if (F->getType()->isIncompleteArrayType()) { 4018 assert(ClassDecl->hasFlexibleArrayMember() && 4019 "Incomplete array type is not valid"); 4020 continue; 4021 } 4022 4023 // Initialize each field of an anonymous struct individually. 4024 if (CollectFieldInitializer(*this, Info, F->getAnonField(), F)) 4025 HadError = true; 4026 4027 continue; 4028 } 4029 } 4030 4031 unsigned NumInitializers = Info.AllToInit.size(); 4032 if (NumInitializers > 0) { 4033 Constructor->setNumCtorInitializers(NumInitializers); 4034 CXXCtorInitializer **baseOrMemberInitializers = 4035 new (Context) CXXCtorInitializer*[NumInitializers]; 4036 memcpy(baseOrMemberInitializers, Info.AllToInit.data(), 4037 NumInitializers * sizeof(CXXCtorInitializer*)); 4038 Constructor->setCtorInitializers(baseOrMemberInitializers); 4039 4040 // Constructors implicitly reference the base and member 4041 // destructors. 4042 MarkBaseAndMemberDestructorsReferenced(Constructor->getLocation(), 4043 Constructor->getParent()); 4044 } 4045 4046 return HadError; 4047 } 4048 4049 static void PopulateKeysForFields(FieldDecl *Field, SmallVectorImpl<const void*> &IdealInits) { 4050 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) { 4051 const RecordDecl *RD = RT->getDecl(); 4052 if (RD->isAnonymousStructOrUnion()) { 4053 for (auto *Field : RD->fields()) 4054 PopulateKeysForFields(Field, IdealInits); 4055 return; 4056 } 4057 } 4058 IdealInits.push_back(Field->getCanonicalDecl()); 4059 } 4060 4061 static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) { 4062 return Context.getCanonicalType(BaseType).getTypePtr(); 4063 } 4064 4065 static const void *GetKeyForMember(ASTContext &Context, 4066 CXXCtorInitializer *Member) { 4067 if (!Member->isAnyMemberInitializer()) 4068 return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0)); 4069 4070 return Member->getAnyMember()->getCanonicalDecl(); 4071 } 4072 4073 static void DiagnoseBaseOrMemInitializerOrder( 4074 Sema &SemaRef, const CXXConstructorDecl *Constructor, 4075 ArrayRef<CXXCtorInitializer *> Inits) { 4076 if (Constructor->getDeclContext()->isDependentContext()) 4077 return; 4078 4079 // Don't check initializers order unless the warning is enabled at the 4080 // location of at least one initializer. 4081 bool ShouldCheckOrder = false; 4082 for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) { 4083 CXXCtorInitializer *Init = Inits[InitIndex]; 4084 if (!SemaRef.Diags.isIgnored(diag::warn_initializer_out_of_order, 4085 Init->getSourceLocation())) { 4086 ShouldCheckOrder = true; 4087 break; 4088 } 4089 } 4090 if (!ShouldCheckOrder) 4091 return; 4092 4093 // Build the list of bases and members in the order that they'll 4094 // actually be initialized. The explicit initializers should be in 4095 // this same order but may be missing things. 4096 SmallVector<const void*, 32> IdealInitKeys; 4097 4098 const CXXRecordDecl *ClassDecl = Constructor->getParent(); 4099 4100 // 1. Virtual bases. 4101 for (const auto &VBase : ClassDecl->vbases()) 4102 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase.getType())); 4103 4104 // 2. Non-virtual bases. 4105 for (const auto &Base : ClassDecl->bases()) { 4106 if (Base.isVirtual()) 4107 continue; 4108 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base.getType())); 4109 } 4110 4111 // 3. Direct fields. 4112 for (auto *Field : ClassDecl->