clang  14.0.0git
SemaDeclCXX.cpp
Go to the documentation of this file.
1 //===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements semantic analysis for C++ declarations.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/AST/ASTConsumer.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/ASTLambda.h"
18 #include "clang/AST/CharUnits.h"
21 #include "clang/AST/ExprCXX.h"
22 #include "clang/AST/RecordLayout.h"
24 #include "clang/AST/StmtVisitor.h"
25 #include "clang/AST/TypeLoc.h"
26 #include "clang/AST/TypeOrdering.h"
29 #include "clang/Basic/TargetInfo.h"
31 #include "clang/Lex/Preprocessor.h"
33 #include "clang/Sema/DeclSpec.h"
35 #include "clang/Sema/Lookup.h"
37 #include "clang/Sema/Scope.h"
38 #include "clang/Sema/ScopeInfo.h"
40 #include "clang/Sema/Template.h"
41 #include "llvm/ADT/ScopeExit.h"
42 #include "llvm/ADT/SmallString.h"
43 #include "llvm/ADT/STLExtras.h"
44 #include "llvm/ADT/StringExtras.h"
45 #include <map>
46 #include <set>
47 
48 using namespace clang;
49 
50 //===----------------------------------------------------------------------===//
51 // CheckDefaultArgumentVisitor
52 //===----------------------------------------------------------------------===//
53 
54 namespace {
55 /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
56 /// the default argument of a parameter to determine whether it
57 /// contains any ill-formed subexpressions. For example, this will
58 /// diagnose the use of local variables or parameters within the
59 /// default argument expression.
60 class CheckDefaultArgumentVisitor
61  : public ConstStmtVisitor<CheckDefaultArgumentVisitor, bool> {
62  Sema &S;
63  const Expr *DefaultArg;
64 
65 public:
66  CheckDefaultArgumentVisitor(Sema &S, const Expr *DefaultArg)
67  : S(S), DefaultArg(DefaultArg) {}
68 
69  bool VisitExpr(const Expr *Node);
70  bool VisitDeclRefExpr(const DeclRefExpr *DRE);
71  bool VisitCXXThisExpr(const CXXThisExpr *ThisE);
72  bool VisitLambdaExpr(const LambdaExpr *Lambda);
73  bool VisitPseudoObjectExpr(const PseudoObjectExpr *POE);
74 };
75 
76 /// VisitExpr - Visit all of the children of this expression.
77 bool CheckDefaultArgumentVisitor::VisitExpr(const Expr *Node) {
78  bool IsInvalid = false;
79  for (const Stmt *SubStmt : Node->children())
80  IsInvalid |= Visit(SubStmt);
81  return IsInvalid;
82 }
83 
84 /// VisitDeclRefExpr - Visit a reference to a declaration, to
85 /// determine whether this declaration can be used in the default
86 /// argument expression.
87 bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(const DeclRefExpr *DRE) {
88  const NamedDecl *Decl = DRE->getDecl();
89  if (const auto *Param = dyn_cast<ParmVarDecl>(Decl)) {
90  // C++ [dcl.fct.default]p9:
91  // [...] parameters of a function shall not be used in default
92  // argument expressions, even if they are not evaluated. [...]
93  //
94  // C++17 [dcl.fct.default]p9 (by CWG 2082):
95  // [...] A parameter shall not appear as a potentially-evaluated
96  // expression in a default argument. [...]
97  //
98  if (DRE->isNonOdrUse() != NOUR_Unevaluated)
99  return S.Diag(DRE->getBeginLoc(),
100  diag::err_param_default_argument_references_param)
101  << Param->getDeclName() << DefaultArg->getSourceRange();
102  } else if (const auto *VDecl = dyn_cast<VarDecl>(Decl)) {
103  // C++ [dcl.fct.default]p7:
104  // Local variables shall not be used in default argument
105  // expressions.
106  //
107  // C++17 [dcl.fct.default]p7 (by CWG 2082):
108  // A local variable shall not appear as a potentially-evaluated
109  // expression in a default argument.
110  //
111  // C++20 [dcl.fct.default]p7 (DR as part of P0588R1, see also CWG 2346):
112  // Note: A local variable cannot be odr-used (6.3) in a default argument.
113  //
114  if (VDecl->isLocalVarDecl() && !DRE->isNonOdrUse())
115  return S.Diag(DRE->getBeginLoc(),
116  diag::err_param_default_argument_references_local)
117  << VDecl->getDeclName() << DefaultArg->getSourceRange();
118  }
119 
120  return false;
121 }
122 
123 /// VisitCXXThisExpr - Visit a C++ "this" expression.
124 bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(const CXXThisExpr *ThisE) {
125  // C++ [dcl.fct.default]p8:
126  // The keyword this shall not be used in a default argument of a
127  // member function.
128  return S.Diag(ThisE->getBeginLoc(),
129  diag::err_param_default_argument_references_this)
130  << ThisE->getSourceRange();
131 }
132 
133 bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(
134  const PseudoObjectExpr *POE) {
135  bool Invalid = false;
136  for (const Expr *E : POE->semantics()) {
137  // Look through bindings.
138  if (const auto *OVE = dyn_cast<OpaqueValueExpr>(E)) {
139  E = OVE->getSourceExpr();
140  assert(E && "pseudo-object binding without source expression?");
141  }
142 
143  Invalid |= Visit(E);
144  }
145  return Invalid;
146 }
147 
148 bool CheckDefaultArgumentVisitor::VisitLambdaExpr(const LambdaExpr *Lambda) {
149  // C++11 [expr.lambda.prim]p13:
150  // A lambda-expression appearing in a default argument shall not
151  // implicitly or explicitly capture any entity.
152  if (Lambda->capture_begin() == Lambda->capture_end())
153  return false;
154 
155  return S.Diag(Lambda->getBeginLoc(), diag::err_lambda_capture_default_arg);
156 }
157 } // namespace
158 
159 void
161  const CXXMethodDecl *Method) {
162  // If we have an MSAny spec already, don't bother.
163  if (!Method || ComputedEST == EST_MSAny)
164  return;
165 
166  const FunctionProtoType *Proto
167  = Method->getType()->getAs<FunctionProtoType>();
168  Proto = Self->ResolveExceptionSpec(CallLoc, Proto);
169  if (!Proto)
170  return;
171 
173 
174  // If we have a throw-all spec at this point, ignore the function.
175  if (ComputedEST == EST_None)
176  return;
177 
178  if (EST == EST_None && Method->hasAttr<NoThrowAttr>())
179  EST = EST_BasicNoexcept;
180 
181  switch (EST) {
182  case EST_Unparsed:
183  case EST_Uninstantiated:
184  case EST_Unevaluated:
185  llvm_unreachable("should not see unresolved exception specs here");
186 
187  // If this function can throw any exceptions, make a note of that.
188  case EST_MSAny:
189  case EST_None:
190  // FIXME: Whichever we see last of MSAny and None determines our result.
191  // We should make a consistent, order-independent choice here.
192  ClearExceptions();
193  ComputedEST = EST;
194  return;
195  case EST_NoexceptFalse:
196  ClearExceptions();
197  ComputedEST = EST_None;
198  return;
199  // FIXME: If the call to this decl is using any of its default arguments, we
200  // need to search them for potentially-throwing calls.
201  // If this function has a basic noexcept, it doesn't affect the outcome.
202  case EST_BasicNoexcept:
203  case EST_NoexceptTrue:
204  case EST_NoThrow:
205  return;
206  // If we're still at noexcept(true) and there's a throw() callee,
207  // change to that specification.
208  case EST_DynamicNone:
209  if (ComputedEST == EST_BasicNoexcept)
210  ComputedEST = EST_DynamicNone;
211  return;
213  llvm_unreachable(
214  "should not generate implicit declarations for dependent cases");
215  case EST_Dynamic:
216  break;
217  }
218  assert(EST == EST_Dynamic && "EST case not considered earlier.");
219  assert(ComputedEST != EST_None &&
220  "Shouldn't collect exceptions when throw-all is guaranteed.");
221  ComputedEST = EST_Dynamic;
222  // Record the exceptions in this function's exception specification.
223  for (const auto &E : Proto->exceptions())
224  if (ExceptionsSeen.insert(Self->Context.getCanonicalType(E)).second)
225  Exceptions.push_back(E);
226 }
227 
229  if (!S || ComputedEST == EST_MSAny)
230  return;
231 
232  // FIXME:
233  //
234  // C++0x [except.spec]p14:
235  // [An] implicit exception-specification specifies the type-id T if and
236  // only if T is allowed by the exception-specification of a function directly
237  // invoked by f's implicit definition; f shall allow all exceptions if any
238  // function it directly invokes allows all exceptions, and f shall allow no
239  // exceptions if every function it directly invokes allows no exceptions.
240  //
241  // Note in particular that if an implicit exception-specification is generated
242  // for a function containing a throw-expression, that specification can still
243  // be noexcept(true).
244  //
245  // Note also that 'directly invoked' is not defined in the standard, and there
246  // is no indication that we should only consider potentially-evaluated calls.
247  //
248  // Ultimately we should implement the intent of the standard: the exception
249  // specification should be the set of exceptions which can be thrown by the
250  // implicit definition. For now, we assume that any non-nothrow expression can
251  // throw any exception.
252 
253  if (Self->canThrow(S))
254  ComputedEST = EST_None;
255 }
256 
258  SourceLocation EqualLoc) {
259  if (RequireCompleteType(Param->getLocation(), Param->getType(),
260  diag::err_typecheck_decl_incomplete_type))
261  return true;
262 
263  // C++ [dcl.fct.default]p5
264  // A default argument expression is implicitly converted (clause
265  // 4) to the parameter type. The default argument expression has
266  // the same semantic constraints as the initializer expression in
267  // a declaration of a variable of the parameter type, using the
268  // copy-initialization semantics (8.5).
270  Param);
272  EqualLoc);
273  InitializationSequence InitSeq(*this, Entity, Kind, Arg);
274  ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg);
275  if (Result.isInvalid())
276  return true;
277  Arg = Result.getAs<Expr>();
278 
279  CheckCompletedExpr(Arg, EqualLoc);
280  Arg = MaybeCreateExprWithCleanups(Arg);
281 
282  return Arg;
283 }
284 
286  SourceLocation EqualLoc) {
287  // Add the default argument to the parameter
288  Param->setDefaultArg(Arg);
289 
290  // We have already instantiated this parameter; provide each of the
291  // instantiations with the uninstantiated default argument.
292  UnparsedDefaultArgInstantiationsMap::iterator InstPos
293  = UnparsedDefaultArgInstantiations.find(Param);
294  if (InstPos != UnparsedDefaultArgInstantiations.end()) {
295  for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
296  InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
297 
298  // We're done tracking this parameter's instantiations.
299  UnparsedDefaultArgInstantiations.erase(InstPos);
300  }
301 }
302 
303 /// ActOnParamDefaultArgument - Check whether the default argument
304 /// provided for a function parameter is well-formed. If so, attach it
305 /// to the parameter declaration.
306 void
308  Expr *DefaultArg) {
309  if (!param || !DefaultArg)
310  return;
311 
312  ParmVarDecl *Param = cast<ParmVarDecl>(param);
313  UnparsedDefaultArgLocs.erase(Param);
314 
315  auto Fail = [&] {
316  Param->setInvalidDecl();
318  EqualLoc, Param->getType().getNonReferenceType(), VK_PRValue));
319  };
320 
321  // Default arguments are only permitted in C++
322  if (!getLangOpts().CPlusPlus) {
323  Diag(EqualLoc, diag::err_param_default_argument)
324  << DefaultArg->getSourceRange();
325  return Fail();
326  }
327 
328  // Check for unexpanded parameter packs.
330  return Fail();
331  }
332 
333  // C++11 [dcl.fct.default]p3
334  // A default argument expression [...] shall not be specified for a
335  // parameter pack.
336  if (Param->isParameterPack()) {
337  Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
338  << DefaultArg->getSourceRange();
339  // Recover by discarding the default argument.
340  Param->setDefaultArg(nullptr);
341  return;
342  }
343 
344  ExprResult Result = ConvertParamDefaultArgument(Param, DefaultArg, EqualLoc);
345  if (Result.isInvalid())
346  return Fail();
347 
348  DefaultArg = Result.getAs<Expr>();
349 
350  // Check that the default argument is well-formed
351  CheckDefaultArgumentVisitor DefaultArgChecker(*this, DefaultArg);
352  if (DefaultArgChecker.Visit(DefaultArg))
353  return Fail();
354 
355  SetParamDefaultArgument(Param, DefaultArg, EqualLoc);
356 }
357 
358 /// ActOnParamUnparsedDefaultArgument - We've seen a default
359 /// argument for a function parameter, but we can't parse it yet
360 /// because we're inside a class definition. Note that this default
361 /// argument will be parsed later.
363  SourceLocation EqualLoc,
364  SourceLocation ArgLoc) {
365  if (!param)
366  return;
367 
368  ParmVarDecl *Param = cast<ParmVarDecl>(param);
369  Param->setUnparsedDefaultArg();
370  UnparsedDefaultArgLocs[Param] = ArgLoc;
371 }
372 
373 /// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
374 /// the default argument for the parameter param failed.
376  SourceLocation EqualLoc) {
377  if (!param)
378  return;
379 
380  ParmVarDecl *Param = cast<ParmVarDecl>(param);
381  Param->setInvalidDecl();
382  UnparsedDefaultArgLocs.erase(Param);
384  EqualLoc, Param->getType().getNonReferenceType(), VK_PRValue));
385 }
386 
387 /// CheckExtraCXXDefaultArguments - Check for any extra default
388 /// arguments in the declarator, which is not a function declaration
389 /// or definition and therefore is not permitted to have default
390 /// arguments. This routine should be invoked for every declarator
391 /// that is not a function declaration or definition.
393  // C++ [dcl.fct.default]p3
394  // A default argument expression shall be specified only in the
395  // parameter-declaration-clause of a function declaration or in a
396  // template-parameter (14.1). It shall not be specified for a
397  // parameter pack. If it is specified in a
398  // parameter-declaration-clause, it shall not occur within a
399  // declarator or abstract-declarator of a parameter-declaration.
400  bool MightBeFunction = D.isFunctionDeclarationContext();
401  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
402  DeclaratorChunk &chunk = D.getTypeObject(i);
403  if (chunk.Kind == DeclaratorChunk::Function) {
404  if (MightBeFunction) {
405  // This is a function declaration. It can have default arguments, but
406  // keep looking in case its return type is a function type with default
407  // arguments.
408  MightBeFunction = false;
409  continue;
410  }
411  for (unsigned argIdx = 0, e = chunk.Fun.NumParams; argIdx != e;
412  ++argIdx) {
413  ParmVarDecl *Param = cast<ParmVarDecl>(chunk.Fun.Params[argIdx].Param);
414  if (Param->hasUnparsedDefaultArg()) {
415  std::unique_ptr<CachedTokens> Toks =
416  std::move(chunk.Fun.Params[argIdx].DefaultArgTokens);
417  SourceRange SR;
418  if (Toks->size() > 1)
419  SR = SourceRange((*Toks)[1].getLocation(),
420  Toks->back().getLocation());
421  else
422  SR = UnparsedDefaultArgLocs[Param];
423  Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
424  << SR;
425  } else if (Param->getDefaultArg()) {
426  Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
427  << Param->getDefaultArg()->getSourceRange();
428  Param->setDefaultArg(nullptr);
429  }
430  }
431  } else if (chunk.Kind != DeclaratorChunk::Paren) {
432  MightBeFunction = false;
433  }
434  }
435 }
436 
438  return std::any_of(FD->param_begin(), FD->param_end(), [](ParmVarDecl *P) {
439  return P->hasDefaultArg() && !P->hasInheritedDefaultArg();
440  });
441 }
442 
443 /// MergeCXXFunctionDecl - Merge two declarations of the same C++
444 /// function, once we already know that they have the same
445 /// type. Subroutine of MergeFunctionDecl. Returns true if there was an
446 /// error, false otherwise.
448  Scope *S) {
449  bool Invalid = false;
450 
451  // The declaration context corresponding to the scope is the semantic
452  // parent, unless this is a local function declaration, in which case
453  // it is that surrounding function.
454  DeclContext *ScopeDC = New->isLocalExternDecl()
455  ? New->getLexicalDeclContext()
456  : New->getDeclContext();
457 
458  // Find the previous declaration for the purpose of default arguments.
459  FunctionDecl *PrevForDefaultArgs = Old;
460  for (/**/; PrevForDefaultArgs;
461  // Don't bother looking back past the latest decl if this is a local
462  // extern declaration; nothing else could work.
463  PrevForDefaultArgs = New->isLocalExternDecl()
464  ? nullptr
465  : PrevForDefaultArgs->getPreviousDecl()) {
466  // Ignore hidden declarations.
467  if (!LookupResult::isVisible(*this, PrevForDefaultArgs))
468  continue;
469 
470  if (S && !isDeclInScope(PrevForDefaultArgs, ScopeDC, S) &&
471  !New->isCXXClassMember()) {
472  // Ignore default arguments of old decl if they are not in
473  // the same scope and this is not an out-of-line definition of
474  // a member function.
475  continue;
476  }
477 
478  if (PrevForDefaultArgs->isLocalExternDecl() != New->isLocalExternDecl()) {
479  // If only one of these is a local function declaration, then they are
480  // declared in different scopes, even though isDeclInScope may think
481  // they're in the same scope. (If both are local, the scope check is
482  // sufficient, and if neither is local, then they are in the same scope.)
483  continue;
484  }
485 
486  // We found the right previous declaration.
487  break;
488  }
489 
490  // C++ [dcl.fct.default]p4:
491  // For non-template functions, default arguments can be added in
492  // later declarations of a function in the same
493  // scope. Declarations in different scopes have completely
494  // distinct sets of default arguments. That is, declarations in
495  // inner scopes do not acquire default arguments from
496  // declarations in outer scopes, and vice versa. In a given
497  // function declaration, all parameters subsequent to a
498  // parameter with a default argument shall have default
499  // arguments supplied in this or previous declarations. A
500  // default argument shall not be redefined by a later
501  // declaration (not even to the same value).
502  //
503  // C++ [dcl.fct.default]p6:
504  // Except for member functions of class templates, the default arguments
505  // in a member function definition that appears outside of the class
506  // definition are added to the set of default arguments provided by the
507  // member function declaration in the class definition.
508  for (unsigned p = 0, NumParams = PrevForDefaultArgs
509  ? PrevForDefaultArgs->getNumParams()
510  : 0;
511  p < NumParams; ++p) {
512  ParmVarDecl *OldParam = PrevForDefaultArgs->getParamDecl(p);
513  ParmVarDecl *NewParam = New->getParamDecl(p);
514 
515  bool OldParamHasDfl = OldParam ? OldParam->hasDefaultArg() : false;
516  bool NewParamHasDfl = NewParam->hasDefaultArg();
517 
518  if (OldParamHasDfl && NewParamHasDfl) {
519  unsigned DiagDefaultParamID =
520  diag::err_param_default_argument_redefinition;
521 
522  // MSVC accepts that default parameters be redefined for member functions
523  // of template class. The new default parameter's value is ignored.
524  Invalid = true;
525  if (getLangOpts().MicrosoftExt) {
526  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(New);
527  if (MD && MD->getParent()->getDescribedClassTemplate()) {
528  // Merge the old default argument into the new parameter.
529  NewParam->setHasInheritedDefaultArg();
530  if (OldParam->hasUninstantiatedDefaultArg())
531  NewParam->setUninstantiatedDefaultArg(
532  OldParam->getUninstantiatedDefaultArg());
533  else
534  NewParam->setDefaultArg(OldParam->getInit());
535  DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
536  Invalid = false;
537  }
538  }
539 
540  // FIXME: If we knew where the '=' was, we could easily provide a fix-it
541  // hint here. Alternatively, we could walk the type-source information
542  // for NewParam to find the last source location in the type... but it
543  // isn't worth the effort right now. This is the kind of test case that
544  // is hard to get right:
545  // int f(int);
546  // void g(int (*fp)(int) = f);
547  // void g(int (*fp)(int) = &f);
548  Diag(NewParam->getLocation(), DiagDefaultParamID)
549  << NewParam->getDefaultArgRange();
550 
551  // Look for the function declaration where the default argument was
552  // actually written, which may be a declaration prior to Old.
553  for (auto Older = PrevForDefaultArgs;
554  OldParam->hasInheritedDefaultArg(); /**/) {
555  Older = Older->getPreviousDecl();
556  OldParam = Older->getParamDecl(p);
557  }
558 
559  Diag(OldParam->getLocation(), diag::note_previous_definition)
560  << OldParam->getDefaultArgRange();
561  } else if (OldParamHasDfl) {
562  // Merge the old default argument into the new parameter unless the new
563  // function is a friend declaration in a template class. In the latter
564  // case the default arguments will be inherited when the friend
565  // declaration will be instantiated.
566  if (New->getFriendObjectKind() == Decl::FOK_None ||
568  // It's important to use getInit() here; getDefaultArg()
569  // strips off any top-level ExprWithCleanups.
570  NewParam->setHasInheritedDefaultArg();
571  if (OldParam->hasUnparsedDefaultArg())
572  NewParam->setUnparsedDefaultArg();
573  else if (OldParam->hasUninstantiatedDefaultArg())
574  NewParam->setUninstantiatedDefaultArg(
575  OldParam->getUninstantiatedDefaultArg());
576  else
577  NewParam->setDefaultArg(OldParam->getInit());
578  }
579  } else if (NewParamHasDfl) {
580  if (New->getDescribedFunctionTemplate()) {
581  // Paragraph 4, quoted above, only applies to non-template functions.
582  Diag(NewParam->getLocation(),
583  diag::err_param_default_argument_template_redecl)
584  << NewParam->getDefaultArgRange();
585  Diag(PrevForDefaultArgs->getLocation(),
586  diag::note_template_prev_declaration)
587  << false;
588  } else if (New->getTemplateSpecializationKind()
591  // C++ [temp.expr.spec]p21:
592  // Default function arguments shall not be specified in a declaration
593  // or a definition for one of the following explicit specializations:
594  // - the explicit specialization of a function template;
595  // - the explicit specialization of a member function template;
596  // - the explicit specialization of a member function of a class
597  // template where the class template specialization to which the
598  // member function specialization belongs is implicitly
599  // instantiated.
600  Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
602  << New->getDeclName()
603  << NewParam->getDefaultArgRange();
604  } else if (New->getDeclContext()->isDependentContext()) {
605  // C++ [dcl.fct.default]p6 (DR217):
606  // Default arguments for a member function of a class template shall
607  // be specified on the initial declaration of the member function
608  // within the class template.
609  //
610  // Reading the tea leaves a bit in DR217 and its reference to DR205
611  // leads me to the conclusion that one cannot add default function
612  // arguments for an out-of-line definition of a member function of a
613  // dependent type.
614  int WhichKind = 2;
615  if (CXXRecordDecl *Record
616  = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
617  if (Record->getDescribedClassTemplate())
618  WhichKind = 0;
619  else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
620  WhichKind = 1;
621  else
622  WhichKind = 2;
623  }
624 
625  Diag(NewParam->getLocation(),
626  diag::err_param_default_argument_member_template_redecl)
627  << WhichKind
628  << NewParam->getDefaultArgRange();
629  }
630  }
631  }
632 
633  // DR1344: If a default argument is added outside a class definition and that
634  // default argument makes the function a special member function, the program
635  // is ill-formed. This can only happen for constructors.
636  if (isa<CXXConstructorDecl>(New) &&
638  CXXSpecialMember NewSM = getSpecialMember(cast<CXXMethodDecl>(New)),
639  OldSM = getSpecialMember(cast<CXXMethodDecl>(Old));
640  if (NewSM != OldSM) {
641  ParmVarDecl *NewParam = New->getParamDecl(New->getMinRequiredArguments());
642  assert(NewParam->hasDefaultArg());
643  Diag(NewParam->getLocation(), diag::err_default_arg_makes_ctor_special)
644  << NewParam->getDefaultArgRange() << NewSM;
645  Diag(Old->getLocation(), diag::note_previous_declaration);
646  }
647  }
648 
649  const FunctionDecl *Def;
650  // C++11 [dcl.constexpr]p1: If any declaration of a function or function
651  // template has a constexpr specifier then all its declarations shall
652  // contain the constexpr specifier.
653  if (New->getConstexprKind() != Old->getConstexprKind()) {
654  Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
655  << New << static_cast<int>(New->getConstexprKind())
656  << static_cast<int>(Old->getConstexprKind());
657  Diag(Old->getLocation(), diag::note_previous_declaration);
658  Invalid = true;
659  } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
660  Old->isDefined(Def) &&
661  // If a friend function is inlined but does not have 'inline'
662  // specifier, it is a definition. Do not report attribute conflict
663  // in this case, redefinition will be diagnosed later.
664  (New->isInlineSpecified() ||
665  New->getFriendObjectKind() == Decl::FOK_None)) {
666  // C++11 [dcl.fcn.spec]p4:
667  // If the definition of a function appears in a translation unit before its
668  // first declaration as inline, the program is ill-formed.
669  Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
670  Diag(Def->getLocation(), diag::note_previous_definition);
671  Invalid = true;
672  }
673 
674  // C++17 [temp.deduct.guide]p3:
675  // Two deduction guide declarations in the same translation unit
676  // for the same class template shall not have equivalent
677  // parameter-declaration-clauses.
678  if (isa<CXXDeductionGuideDecl>(New) &&
680  Diag(New->getLocation(), diag::err_deduction_guide_redeclared);
681  Diag(Old->getLocation(), diag::note_previous_declaration);
682  }
683 
684  // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
685  // argument expression, that declaration shall be a definition and shall be
686  // the only declaration of the function or function template in the
687  // translation unit.
690  Diag(New->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
691  Diag(Old->getLocation(), diag::note_previous_declaration);
692  Invalid = true;
693  }
694 
695  // C++11 [temp.friend]p4 (DR329):
696  // When a function is defined in a friend function declaration in a class
697  // template, the function is instantiated when the function is odr-used.
698  // The same restrictions on multiple declarations and definitions that
699  // apply to non-template function declarations and definitions also apply
700  // to these implicit definitions.
701  const FunctionDecl *OldDefinition = nullptr;
703  Old->isDefined(OldDefinition, true))
704  CheckForFunctionRedefinition(New, OldDefinition);
705 
706  return Invalid;
707 }
708 
709 NamedDecl *
711  MultiTemplateParamsArg TemplateParamLists) {
712  assert(D.isDecompositionDeclarator());
714 
715  // The syntax only allows a decomposition declarator as a simple-declaration,
716  // a for-range-declaration, or a condition in Clang, but we parse it in more
717  // cases than that.
719  Diag(Decomp.getLSquareLoc(), diag::err_decomp_decl_context)
720  << Decomp.getSourceRange();
721  return nullptr;
722  }
723 
724  if (!TemplateParamLists.empty()) {
725  // FIXME: There's no rule against this, but there are also no rules that
726  // would actually make it usable, so we reject it for now.
727  Diag(TemplateParamLists.front()->getTemplateLoc(),
728  diag::err_decomp_decl_template);
729  return nullptr;
730  }
731 
732  Diag(Decomp.getLSquareLoc(),
734  ? diag::ext_decomp_decl
736  ? diag::ext_decomp_decl_cond
737  : diag::warn_cxx14_compat_decomp_decl)
738  << Decomp.getSourceRange();
739 
740  // The semantic context is always just the current context.
741  DeclContext *const DC = CurContext;
742 
743  // C++17 [dcl.dcl]/8:
744  // The decl-specifier-seq shall contain only the type-specifier auto
745  // and cv-qualifiers.
746  // C++2a [dcl.dcl]/8:
747  // If decl-specifier-seq contains any decl-specifier other than static,
748  // thread_local, auto, or cv-qualifiers, the program is ill-formed.
749  auto &DS = D.getDeclSpec();
750  {
751  SmallVector<StringRef, 8> BadSpecifiers;
752  SmallVector<SourceLocation, 8> BadSpecifierLocs;
753  SmallVector<StringRef, 8> CPlusPlus20Specifiers;
754  SmallVector<SourceLocation, 8> CPlusPlus20SpecifierLocs;
755  if (auto SCS = DS.getStorageClassSpec()) {
756  if (SCS == DeclSpec::SCS_static) {
757  CPlusPlus20Specifiers.push_back(DeclSpec::getSpecifierName(SCS));
758  CPlusPlus20SpecifierLocs.push_back(DS.getStorageClassSpecLoc());
759  } else {
760  BadSpecifiers.push_back(DeclSpec::getSpecifierName(SCS));
761  BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());
762  }
763  }
764  if (auto TSCS = DS.getThreadStorageClassSpec()) {
765  CPlusPlus20Specifiers.push_back(DeclSpec::getSpecifierName(TSCS));
766  CPlusPlus20SpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());
767  }
768  if (DS.hasConstexprSpecifier()) {
769  BadSpecifiers.push_back(
770  DeclSpec::getSpecifierName(DS.getConstexprSpecifier()));
771  BadSpecifierLocs.push_back(DS.getConstexprSpecLoc());
772  }
773  if (DS.isInlineSpecified()) {
774  BadSpecifiers.push_back("inline");
775  BadSpecifierLocs.push_back(DS.getInlineSpecLoc());
776  }
777  if (!BadSpecifiers.empty()) {
778  auto &&Err = Diag(BadSpecifierLocs.front(), diag::err_decomp_decl_spec);
779  Err << (int)BadSpecifiers.size()
780  << llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(), " ");
781  // Don't add FixItHints to remove the specifiers; we do still respect
782  // them when building the underlying variable.
783  for (auto Loc : BadSpecifierLocs)
784  Err << SourceRange(Loc, Loc);
785  } else if (!CPlusPlus20Specifiers.empty()) {
786  auto &&Warn = Diag(CPlusPlus20SpecifierLocs.front(),
788  ? diag::warn_cxx17_compat_decomp_decl_spec
789  : diag::ext_decomp_decl_spec);
790  Warn << (int)CPlusPlus20Specifiers.size()
791  << llvm::join(CPlusPlus20Specifiers.begin(),
792  CPlusPlus20Specifiers.end(), " ");
793  for (auto Loc : CPlusPlus20SpecifierLocs)
794  Warn << SourceRange(Loc, Loc);
795  }
796  // We can't recover from it being declared as a typedef.
797  if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
798  return nullptr;
799  }
800 
801  // C++2a [dcl.struct.bind]p1:
802  // A cv that includes volatile is deprecated
803  if ((DS.getTypeQualifiers() & DeclSpec::TQ_volatile) &&
805  Diag(DS.getVolatileSpecLoc(),
806  diag::warn_deprecated_volatile_structured_binding);
807 
808  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
809  QualType R = TInfo->getType();
810 
813  D.setInvalidType();
814 
815  // The syntax only allows a single ref-qualifier prior to the decomposition
816  // declarator. No other declarator chunks are permitted. Also check the type
817  // specifier here.
818  if (DS.getTypeSpecType() != DeclSpec::TST_auto ||
819  D.hasGroupingParens() || D.getNumTypeObjects() > 1 ||
820  (D.getNumTypeObjects() == 1 &&
822  Diag(Decomp.getLSquareLoc(),
823  (D.hasGroupingParens() ||
824  (D.getNumTypeObjects() &&
826  ? diag::err_decomp_decl_parens
827  : diag::err_decomp_decl_type)
828  << R;
829 
830  // In most cases, there's no actual problem with an explicitly-specified
831  // type, but a function type won't work here, and ActOnVariableDeclarator
832  // shouldn't be called for such a type.
833  if (R->isFunctionType())
834  D.setInvalidType();
835  }
836 
837  // Build the BindingDecls.
839 
840  // Build the BindingDecls.
841  for (auto &B : D.getDecompositionDeclarator().bindings()) {
842  // Check for name conflicts.
843  DeclarationNameInfo NameInfo(B.Name, B.NameLoc);
844  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
846  LookupName(Previous, S,
847  /*CreateBuiltins*/DC->getRedeclContext()->isTranslationUnit());
848 
849  // It's not permitted to shadow a template parameter name.
850  if (Previous.isSingleResult() &&
851  Previous.getFoundDecl()->isTemplateParameter()) {
853  Previous.getFoundDecl());
854  Previous.clear();
855  }
856 
857  auto *BD = BindingDecl::Create(Context, DC, B.NameLoc, B.Name);
858 
859  // Find the shadowed declaration before filtering for scope.
860  NamedDecl *ShadowedDecl = D.getCXXScopeSpec().isEmpty()
862  : nullptr;
863 
864  bool ConsiderLinkage = DC->isFunctionOrMethod() &&
865  DS.getStorageClassSpec() == DeclSpec::SCS_extern;
866  FilterLookupForScope(Previous, DC, S, ConsiderLinkage,
867  /*AllowInlineNamespace*/false);
868 
869  if (!Previous.empty()) {
870  auto *Old = Previous.getRepresentativeDecl();
871  Diag(B.NameLoc, diag::err_redefinition) << B.Name;
872  Diag(Old->getLocation(), diag::note_previous_definition);
873  } else if (ShadowedDecl && !D.isRedeclaration()) {
874  CheckShadow(BD, ShadowedDecl, Previous);
875  }
876  PushOnScopeChains(BD, S, true);
877  Bindings.push_back(BD);
878  ParsingInitForAutoVars.insert(BD);
879  }
880 
881  // There are no prior lookup results for the variable itself, because it
882  // is unnamed.
883  DeclarationNameInfo NameInfo((IdentifierInfo *)nullptr,
884  Decomp.getLSquareLoc());
885  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
887 
888  // Build the variable that holds the non-decomposed object.
889  bool AddToScope = true;
890  NamedDecl *New =
891  ActOnVariableDeclarator(S, D, DC, TInfo, Previous,
892  MultiTemplateParamsArg(), AddToScope, Bindings);
893  if (AddToScope) {
894  S->AddDecl(New);
896  }
897 
899  checkDeclIsAllowedInOpenMPTarget(nullptr, New);
900 
901  return New;
902 }
903 
906  QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType,
907  llvm::function_ref<ExprResult(SourceLocation, Expr *, unsigned)> GetInit) {
908  if ((int64_t)Bindings.size() != NumElems) {
909  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
910  << DecompType << (unsigned)Bindings.size()
911  << (unsigned)NumElems.getLimitedValue(UINT_MAX)
912  << toString(NumElems, 10) << (NumElems < Bindings.size());
913  return true;
914  }
915 
916  unsigned I = 0;
917  for (auto *B : Bindings) {
918  SourceLocation Loc = B->getLocation();
919  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
920  if (E.isInvalid())
921  return true;
922  E = GetInit(Loc, E.get(), I++);
923  if (E.isInvalid())
924  return true;
925  B->setBinding(ElemType, E.get());
926  }
927 
928  return false;
929 }
930 
933  ValueDecl *Src, QualType DecompType,
934  const llvm::APSInt &NumElems,
935  QualType ElemType) {
937  S, Bindings, Src, DecompType, NumElems, ElemType,
938  [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
939  ExprResult E = S.ActOnIntegerConstant(Loc, I);
940  if (E.isInvalid())
941  return ExprError();
942  return S.CreateBuiltinArraySubscriptExpr(Base, Loc, E.get(), Loc);
943  });
944 }
945 
947  ValueDecl *Src, QualType DecompType,
948  const ConstantArrayType *CAT) {
949  return checkArrayLikeDecomposition(S, Bindings, Src, DecompType,
950  llvm::APSInt(CAT->getSize()),
951  CAT->getElementType());
952 }
953 
955  ValueDecl *Src, QualType DecompType,
956  const VectorType *VT) {
958  S, Bindings, Src, DecompType, llvm::APSInt::get(VT->getNumElements()),
960  DecompType.getQualifiers()));
961 }
962 
965  ValueDecl *Src, QualType DecompType,
966  const ComplexType *CT) {
968  S, Bindings, Src, DecompType, llvm::APSInt::get(2),
970  DecompType.getQualifiers()),
971  [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
972  return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
973  });
974 }
975 
978  const TemplateParameterList *Params) {
979  SmallString<128> SS;
980  llvm::raw_svector_ostream OS(SS);
981  bool First = true;
982  unsigned I = 0;
983  for (auto &Arg : Args.arguments()) {
984  if (!First)
985  OS << ", ";
986  Arg.getArgument().print(
987  PrintingPolicy, OS,
989  First = false;
990  I++;
991  }
992  return std::string(OS.str());
993 }
994 
995 static bool lookupStdTypeTraitMember(Sema &S, LookupResult &TraitMemberLookup,
996  SourceLocation Loc, StringRef Trait,
998  unsigned DiagID) {
999  auto DiagnoseMissing = [&] {
1000  if (DiagID)
1001  S.Diag(Loc, DiagID) << printTemplateArgs(S.Context.getPrintingPolicy(),
1002  Args, /*Params*/ nullptr);
1003  return true;
1004  };
1005 
1006  // FIXME: Factor out duplication with lookupPromiseType in SemaCoroutine.
1008  if (!Std)
1009  return DiagnoseMissing();
1010 
1011  // Look up the trait itself, within namespace std. We can diagnose various
1012  // problems with this lookup even if we've been asked to not diagnose a
1013  // missing specialization, because this can only fail if the user has been
1014  // declaring their own names in namespace std or we don't support the
1015  // standard library implementation in use.
1016  LookupResult Result(S, &S.PP.getIdentifierTable().get(Trait),
1018  if (!S.LookupQualifiedName(Result, Std))
1019  return DiagnoseMissing();
1020  if (Result.isAmbiguous())
1021  return true;
1022 
1023  ClassTemplateDecl *TraitTD = Result.getAsSingle<ClassTemplateDecl>();
1024  if (!TraitTD) {
1025  Result.suppressDiagnostics();
1026  NamedDecl *Found = *Result.begin();
1027  S.Diag(Loc, diag::err_std_type_trait_not_class_template) << Trait;
1028  S.Diag(Found->getLocation(), diag::note_declared_at);
1029  return true;
1030  }
1031 
1032  // Build the template-id.
1033  QualType TraitTy = S.CheckTemplateIdType(TemplateName(TraitTD), Loc, Args);
1034  if (TraitTy.isNull())
1035  return true;
1036  if (!S.isCompleteType(Loc, TraitTy)) {
1037  if (DiagID)
1039  Loc, TraitTy, DiagID,
1041  TraitTD->getTemplateParameters()));
1042  return true;
1043  }
1044 
1045  CXXRecordDecl *RD = TraitTy->getAsCXXRecordDecl();
1046  assert(RD && "specialization of class template is not a class?");
1047 
1048  // Look up the member of the trait type.
1049  S.LookupQualifiedName(TraitMemberLookup, RD);
1050  return TraitMemberLookup.isAmbiguous();
1051 }
1052 
1053 static TemplateArgumentLoc
1055  uint64_t I) {
1056  TemplateArgument Arg(S.Context, S.Context.MakeIntValue(I, T), T);
1057  return S.getTrivialTemplateArgumentLoc(Arg, T, Loc);
1058 }
1059 
1060 static TemplateArgumentLoc
1063 }
1064 
1065 namespace { enum class IsTupleLike { TupleLike, NotTupleLike, Error }; }
1066 
1067 static IsTupleLike isTupleLike(Sema &S, SourceLocation Loc, QualType T,
1068  llvm::APSInt &Size) {
1071 
1074 
1075  // Form template argument list for tuple_size<T>.
1076  TemplateArgumentListInfo Args(Loc, Loc);
1078 
1079  // If there's no tuple_size specialization or the lookup of 'value' is empty,
1080  // it's not tuple-like.
1081  if (lookupStdTypeTraitMember(S, R, Loc, "tuple_size", Args, /*DiagID*/ 0) ||
1082  R.empty())
1083  return IsTupleLike::NotTupleLike;
1084 
1085  // If we get this far, we've committed to the tuple interpretation, but
1086  // we can still fail if there actually isn't a usable ::value.
1087 
1088  struct ICEDiagnoser : Sema::VerifyICEDiagnoser {
1089  LookupResult &R;
1091  ICEDiagnoser(LookupResult &R, TemplateArgumentListInfo &Args)
1092  : R(R), Args(Args) {}
1093  Sema::SemaDiagnosticBuilder diagnoseNotICE(Sema &S,
1094  SourceLocation Loc) override {
1095  return S.Diag(Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
1097  /*Params*/ nullptr);
1098  }
1099  } Diagnoser(R, Args);
1100 
1101  ExprResult E =
1102  S.BuildDeclarationNameExpr(CXXScopeSpec(), R, /*NeedsADL*/false);
1103  if (E.isInvalid())
1104  return IsTupleLike::Error;
1105 
1106  E = S.VerifyIntegerConstantExpression(E.get(), &Size, Diagnoser);
1107  if (E.isInvalid())
1108  return IsTupleLike::Error;
1109 
1110  return IsTupleLike::TupleLike;
1111 }
1112 
1113 /// \return std::tuple_element<I, T>::type.
1115  unsigned I, QualType T) {
1116  // Form template argument list for tuple_element<I, T>.
1117  TemplateArgumentListInfo Args(Loc, Loc);
1118  Args.addArgument(
1121 
1122  DeclarationName TypeDN = S.PP.getIdentifierInfo("type");
1123  LookupResult R(S, TypeDN, Loc, Sema::LookupOrdinaryName);
1125  S, R, Loc, "tuple_element", Args,
1126  diag::err_decomp_decl_std_tuple_element_not_specialized))
1127  return QualType();
1128 
1129  auto *TD = R.getAsSingle<TypeDecl>();
1130  if (!TD) {
1131  R.suppressDiagnostics();
1132  S.Diag(Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
1134  /*Params*/ nullptr);
1135  if (!R.empty())
1136  S.Diag(R.getRepresentativeDecl()->getLocation(), diag::note_declared_at);
1137  return QualType();
1138  }
1139 
1140  return S.Context.getTypeDeclType(TD);
1141 }
1142 
1143 namespace {
1144 struct InitializingBinding {
1145  Sema &S;
1146  InitializingBinding(Sema &S, BindingDecl *BD) : S(S) {
1149  Ctx.PointOfInstantiation = BD->getLocation();
1150  Ctx.Entity = BD;
1151  S.pushCodeSynthesisContext(Ctx);
1152  }
1153  ~InitializingBinding() {
1155  }
1156 };
1157 }
1158 
1161  VarDecl *Src, QualType DecompType,
1162  const llvm::APSInt &TupleSize) {
1163  if ((int64_t)Bindings.size() != TupleSize) {
1164  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1165  << DecompType << (unsigned)Bindings.size()
1166  << (unsigned)TupleSize.getLimitedValue(UINT_MAX)
1167  << toString(TupleSize, 10) << (TupleSize < Bindings.size());
1168  return true;
1169  }
1170 
1171  if (Bindings.empty())
1172  return false;
1173 
1174  DeclarationName GetDN = S.PP.getIdentifierInfo("get");
1175 
1176  // [dcl.decomp]p3:
1177  // The unqualified-id get is looked up in the scope of E by class member
1178  // access lookup ...
1179  LookupResult MemberGet(S, GetDN, Src->getLocation(), Sema::LookupMemberName);
1180  bool UseMemberGet = false;
1181  if (S.isCompleteType(Src->getLocation(), DecompType)) {
1182  if (auto *RD = DecompType->getAsCXXRecordDecl())
1183  S.LookupQualifiedName(MemberGet, RD);
1184  if (MemberGet.isAmbiguous())
1185  return true;
1186  // ... and if that finds at least one declaration that is a function
1187  // template whose first template parameter is a non-type parameter ...
1188  for (NamedDecl *D : MemberGet) {
1189  if (FunctionTemplateDecl *FTD =
1190  dyn_cast<FunctionTemplateDecl>(D->getUnderlyingDecl())) {
1191  TemplateParameterList *TPL = FTD->getTemplateParameters();
1192  if (TPL->size() != 0 &&
1193  isa<NonTypeTemplateParmDecl>(TPL->getParam(0))) {
1194  // ... the initializer is e.get<i>().
1195  UseMemberGet = true;
1196  break;
1197  }
1198  }
1199  }
1200  }
1201 
1202  unsigned I = 0;
1203  for (auto *B : Bindings) {
1204  InitializingBinding InitContext(S, B);
1205  SourceLocation Loc = B->getLocation();
1206 
1207  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1208  if (E.isInvalid())
1209  return true;
1210 
1211  // e is an lvalue if the type of the entity is an lvalue reference and
1212  // an xvalue otherwise
1213  if (!Src->getType()->isLValueReferenceType())
1214  E = ImplicitCastExpr::Create(S.Context, E.get()->getType(), CK_NoOp,
1215  E.get(), nullptr, VK_XValue,
1216  FPOptionsOverride());
1217 
1218  TemplateArgumentListInfo Args(Loc, Loc);
1219  Args.addArgument(
1221 
1222  if (UseMemberGet) {
1223  // if [lookup of member get] finds at least one declaration, the
1224  // initializer is e.get<i-1>().
1225  E = S.BuildMemberReferenceExpr(E.get(), DecompType, Loc, false,
1226  CXXScopeSpec(), SourceLocation(), nullptr,
1227  MemberGet, &Args, nullptr);
1228  if (E.isInvalid())
1229  return true;
1230 
1231  E = S.BuildCallExpr(nullptr, E.get(), Loc, None, Loc);
1232  } else {
1233  // Otherwise, the initializer is get<i-1>(e), where get is looked up
1234  // in the associated namespaces.
1237  DeclarationNameInfo(GetDN, Loc), /*RequiresADL*/true, &Args,
1239 
1240  Expr *Arg = E.get();
1241  E = S.BuildCallExpr(nullptr, Get, Loc, Arg, Loc);
1242  }
1243  if (E.isInvalid())
1244  return true;
1245  Expr *Init = E.get();
1246 
1247  // Given the type T designated by std::tuple_element<i - 1, E>::type,
1248  QualType T = getTupleLikeElementType(S, Loc, I, DecompType);
1249  if (T.isNull())
1250  return true;
1251 
1252  // each vi is a variable of type "reference to T" initialized with the
1253  // initializer, where the reference is an lvalue reference if the
1254  // initializer is an lvalue and an rvalue reference otherwise
1255  QualType RefType =
1256  S.BuildReferenceType(T, E.get()->isLValue(), Loc, B->getDeclName());
1257  if (RefType.isNull())
1258  return true;
1259  auto *RefVD = VarDecl::Create(
1260  S.Context, Src->getDeclContext(), Loc, Loc,
1261  B->getDeclName().getAsIdentifierInfo(), RefType,
1263  RefVD->setLexicalDeclContext(Src->getLexicalDeclContext());
1264  RefVD->setTSCSpec(Src->getTSCSpec());
1265  RefVD->setImplicit();
1266  if (Src->isInlineSpecified())
1267  RefVD->setInlineSpecified();
1268  RefVD->getLexicalDeclContext()->addHiddenDecl(RefVD);
1269 
1272  InitializationSequence Seq(S, Entity, Kind, Init);
1273  E = Seq.Perform(S, Entity, Kind, Init);
1274  if (E.isInvalid())
1275  return true;
1276  E = S.ActOnFinishFullExpr(E.get(), Loc, /*DiscardedValue*/ false);
1277  if (E.isInvalid())
1278  return true;
1279  RefVD->setInit(E.get());
1281 
1283  DeclarationNameInfo(B->getDeclName(), Loc),
1284  RefVD);
1285  if (E.isInvalid())
1286  return true;
1287 
1288  B->setBinding(T, E.get());
1289  I++;
1290  }
1291 
1292  return false;
1293 }
1294 
1295 /// Find the base class to decompose in a built-in decomposition of a class type.
1296 /// This base class search is, unfortunately, not quite like any other that we
1297 /// perform anywhere else in C++.
1299  const CXXRecordDecl *RD,
1300  CXXCastPath &BasePath) {
1301  auto BaseHasFields = [](const CXXBaseSpecifier *Specifier,
1302  CXXBasePath &Path) {
1303  return Specifier->getType()->getAsCXXRecordDecl()->hasDirectFields();
1304  };
1305 
1306  const CXXRecordDecl *ClassWithFields = nullptr;
1308  if (RD->hasDirectFields())
1309  // [dcl.decomp]p4:
1310  // Otherwise, all of E's non-static data members shall be public direct
1311  // members of E ...
1312  ClassWithFields = RD;
1313  else {
1314  // ... or of ...
1315  CXXBasePaths Paths;
1316  Paths.setOrigin(const_cast<CXXRecordDecl*>(RD));
1317  if (!RD->lookupInBases(BaseHasFields, Paths)) {
1318  // If no classes have fields, just decompose RD itself. (This will work
1319  // if and only if zero bindings were provided.)
1320  return DeclAccessPair::make(const_cast<CXXRecordDecl*>(RD), AS_public);
1321  }
1322 
1323  CXXBasePath *BestPath = nullptr;
1324  for (auto &P : Paths) {
1325  if (!BestPath)
1326  BestPath = &P;
1327  else if (!S.Context.hasSameType(P.back().Base->getType(),
1328  BestPath->back().Base->getType())) {
1329  // ... the same ...
1330  S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1331  << false << RD << BestPath->back().Base->getType()
1332  << P.back().Base->getType();
1333  return DeclAccessPair();
1334  } else if (P.Access < BestPath->Access) {
1335  BestPath = &P;
1336  }
1337  }
1338 
1339  // ... unambiguous ...
1340  QualType BaseType = BestPath->back().Base->getType();
1341  if (Paths.isAmbiguous(S.Context.getCanonicalType(BaseType))) {
1342  S.Diag(Loc, diag::err_decomp_decl_ambiguous_base)
1343  << RD << BaseType << S.getAmbiguousPathsDisplayString(Paths);
1344  return DeclAccessPair();
1345  }
1346 
1347  // ... [accessible, implied by other rules] base class of E.
1348  S.CheckBaseClassAccess(Loc, BaseType, S.Context.getRecordType(RD),
1349  *BestPath, diag::err_decomp_decl_inaccessible_base);
1350  AS = BestPath->Access;
1351 
1352  ClassWithFields = BaseType->getAsCXXRecordDecl();
1353  S.BuildBasePathArray(Paths, BasePath);
1354  }
1355 
1356  // The above search did not check whether the selected class itself has base
1357  // classes with fields, so check that now.
1358  CXXBasePaths Paths;
1359  if (ClassWithFields->lookupInBases(BaseHasFields, Paths)) {
1360  S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1361  << (ClassWithFields == RD) << RD << ClassWithFields
1362  << Paths.front().back().Base->getType();
1363  return DeclAccessPair();
1364  }
1365 
1366  return DeclAccessPair::make(const_cast<CXXRecordDecl*>(ClassWithFields), AS);
1367 }
1368 
1370  ValueDecl *Src, QualType DecompType,
1371  const CXXRecordDecl *OrigRD) {
1372  if (S.RequireCompleteType(Src->getLocation(), DecompType,
1373  diag::err_incomplete_type))
1374  return true;
1375 
1376  CXXCastPath BasePath;
1377  DeclAccessPair BasePair =
1378  findDecomposableBaseClass(S, Src->getLocation(), OrigRD, BasePath);
1379  const CXXRecordDecl *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
1380  if (!RD)
1381  return true;
1383  DecompType.getQualifiers());
1384 
1385  auto DiagnoseBadNumberOfBindings = [&]() -> bool {
1386  unsigned NumFields =
1387  std::count_if(RD->field_begin(), RD->field_end(),
1388  [](FieldDecl *FD) { return !FD->isUnnamedBitfield(); });
1389  assert(Bindings.size() != NumFields);
1390  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1391  << DecompType << (unsigned)Bindings.size() << NumFields << NumFields
1392  << (NumFields < Bindings.size());
1393  return true;
1394  };
1395 
1396  // all of E's non-static data members shall be [...] well-formed
1397  // when named as e.name in the context of the structured binding,
1398  // E shall not have an anonymous union member, ...
1399  unsigned I = 0;
1400  for (auto *FD : RD->fields()) {
1401  if (FD->isUnnamedBitfield())
1402  continue;
1403 
1404  // All the non-static data members are required to be nameable, so they
1405  // must all have names.
1406  if (!FD->getDeclName()) {
1407  if (RD->isLambda()) {
1408  S.Diag(Src->getLocation(), diag::err_decomp_decl_lambda);
1409  S.Diag(RD->getLocation(), diag::note_lambda_decl);
1410  return true;
1411  }
1412 
1413  if (FD->isAnonymousStructOrUnion()) {
1414  S.Diag(Src->getLocation(), diag::err_decomp_decl_anon_union_member)
1415  << DecompType << FD->getType()->isUnionType();
1416  S.Diag(FD->getLocation(), diag::note_declared_at);
1417  return true;
1418  }
1419 
1420  // FIXME: Are there any other ways we could have an anonymous member?
1421  }
1422 
1423  // We have a real field to bind.
1424  if (I >= Bindings.size())
1425  return DiagnoseBadNumberOfBindings();
1426  auto *B = Bindings[I++];
1427  SourceLocation Loc = B->getLocation();
1428 
1429  // The field must be accessible in the context of the structured binding.
1430  // We already checked that the base class is accessible.
1431  // FIXME: Add 'const' to AccessedEntity's classes so we can remove the
1432  // const_cast here.
1434  Loc, const_cast<CXXRecordDecl *>(OrigRD),
1436  BasePair.getAccess(), FD->getAccess())));
1437 
1438  // Initialize the binding to Src.FD.
1439  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1440  if (E.isInvalid())
1441  return true;
1442  E = S.ImpCastExprToType(E.get(), BaseType, CK_UncheckedDerivedToBase,
1443  VK_LValue, &BasePath);
1444  if (E.isInvalid())
1445  return true;
1446  E = S.BuildFieldReferenceExpr(E.get(), /*IsArrow*/ false, Loc,
1447  CXXScopeSpec(), FD,
1448  DeclAccessPair::make(FD, FD->getAccess()),
1449  DeclarationNameInfo(FD->getDeclName(), Loc));
1450  if (E.isInvalid())
1451  return true;
1452 
1453  // If the type of the member is T, the referenced type is cv T, where cv is
1454  // the cv-qualification of the decomposition expression.
1455  //
1456  // FIXME: We resolve a defect here: if the field is mutable, we do not add
1457  // 'const' to the type of the field.
1458  Qualifiers Q = DecompType.getQualifiers();
1459  if (FD->isMutable())
1460  Q.removeConst();
1461  B->setBinding(S.BuildQualifiedType(FD->getType(), Loc, Q), E.get());
1462  }
1463 
1464  if (I != Bindings.size())
1465  return DiagnoseBadNumberOfBindings();
1466 
1467  return false;
1468 }
1469 
1471  QualType DecompType = DD->getType();
1472 
1473  // If the type of the decomposition is dependent, then so is the type of
1474  // each binding.
1475  if (DecompType->isDependentType()) {
1476  for (auto *B : DD->bindings())
1477  B->setType(Context.DependentTy);
1478  return;
1479  }
1480 
1481  DecompType = DecompType.getNonReferenceType();
1483 
1484  // C++1z [dcl.decomp]/2:
1485  // If E is an array type [...]
1486  // As an extension, we also support decomposition of built-in complex and
1487  // vector types.
1488  if (auto *CAT = Context.getAsConstantArrayType(DecompType)) {
1489  if (checkArrayDecomposition(*this, Bindings, DD, DecompType, CAT))
1490  DD->setInvalidDecl();
1491  return;
1492  }
1493  if (auto *VT = DecompType->getAs<VectorType>()) {
1494  if (checkVectorDecomposition(*this, Bindings, DD, DecompType, VT))
1495  DD->setInvalidDecl();
1496  return;
1497  }
1498  if (auto *CT = DecompType->getAs<ComplexType>()) {
1499  if (checkComplexDecomposition(*this, Bindings, DD, DecompType, CT))
1500  DD->setInvalidDecl();
1501  return;
1502  }
1503 
1504  // C++1z [dcl.decomp]/3:
1505  // if the expression std::tuple_size<E>::value is a well-formed integral
1506  // constant expression, [...]
1507  llvm::APSInt TupleSize(32);
1508  switch (isTupleLike(*this, DD->getLocation(), DecompType, TupleSize)) {
1509  case IsTupleLike::Error:
1510  DD->setInvalidDecl();
1511  return;
1512 
1513  case IsTupleLike::TupleLike:
1514  if (checkTupleLikeDecomposition(*this, Bindings, DD, DecompType, TupleSize))
1515  DD->setInvalidDecl();
1516  return;
1517 
1518  case IsTupleLike::NotTupleLike:
1519  break;
1520  }
1521 
1522  // C++1z [dcl.dcl]/8:
1523  // [E shall be of array or non-union class type]
1524  CXXRecordDecl *RD = DecompType->getAsCXXRecordDecl();
1525  if (!RD || RD->isUnion()) {
1526  Diag(DD->getLocation(), diag::err_decomp_decl_unbindable_type)
1527  << DD << !RD << DecompType;
1528  DD->setInvalidDecl();
1529  return;
1530  }
1531 
1532  // C++1z [dcl.decomp]/4:
1533  // all of E's non-static data members shall be [...] direct members of
1534  // E or of the same unambiguous public base class of E, ...
1535  if (checkMemberDecomposition(*this, Bindings, DD, DecompType, RD))
1536  DD->setInvalidDecl();
1537 }
1538 
1539 /// Merge the exception specifications of two variable declarations.
1540 ///
1541 /// This is called when there's a redeclaration of a VarDecl. The function
1542 /// checks if the redeclaration might have an exception specification and
1543 /// validates compatibility and merges the specs if necessary.
1545  // Shortcut if exceptions are disabled.
1546  if (!getLangOpts().CXXExceptions)
1547  return;
1548 
1549  assert(Context.hasSameType(New->getType(), Old->getType()) &&
1550  "Should only be called if types are otherwise the same.");
1551 
1552  QualType NewType = New->getType();
1553  QualType OldType = Old->getType();
1554 
1555  // We're only interested in pointers and references to functions, as well
1556  // as pointers to member functions.
1557  if (const ReferenceType *R = NewType->getAs<ReferenceType>()) {
1558  NewType = R->getPointeeType();
1559  OldType = OldType->castAs<ReferenceType>()->getPointeeType();
1560  } else if (const PointerType *P = NewType->getAs<PointerType>()) {
1561  NewType = P->getPointeeType();
1562  OldType = OldType->castAs<PointerType>()->getPointeeType();
1563  } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) {
1564  NewType = M->getPointeeType();
1565  OldType = OldType->castAs<MemberPointerType>()->getPointeeType();
1566  }
1567 
1568  if (!NewType->isFunctionProtoType())
1569  return;
1570 
1571  // There's lots of special cases for functions. For function pointers, system
1572  // libraries are hopefully not as broken so that we don't need these
1573  // workarounds.
1575  OldType->getAs<FunctionProtoType>(), Old->getLocation(),
1576  NewType->getAs<FunctionProtoType>(), New->getLocation())) {
1577  New->setInvalidDecl();
1578  }
1579 }
1580 
1581 /// CheckCXXDefaultArguments - Verify that the default arguments for a
1582 /// function declaration are well-formed according to C++
1583 /// [dcl.fct.default].
1585  unsigned NumParams = FD->getNumParams();
1586  unsigned ParamIdx = 0;
1587 
1588  // This checking doesn't make sense for explicit specializations; their
1589  // default arguments are determined by the declaration we're specializing,
1590  // not by FD.
1592  return;
1593  if (auto *FTD = FD->getDescribedFunctionTemplate())
1594  if (FTD->isMemberSpecialization())
1595  return;
1596 
1597  // Find first parameter with a default argument
1598  for (; ParamIdx < NumParams; ++ParamIdx) {
1599  ParmVarDecl *Param = FD->getParamDecl(ParamIdx);
1600  if (Param->hasDefaultArg())
1601  break;
1602  }
1603 
1604  // C++20 [dcl.fct.default]p4:
1605  // In a given function declaration, each parameter subsequent to a parameter
1606  // with a default argument shall have a default argument supplied in this or
1607  // a previous declaration, unless the parameter was expanded from a
1608  // parameter pack, or shall be a function parameter pack.
1609  for (; ParamIdx < NumParams; ++ParamIdx) {
1610  ParmVarDecl *Param = FD->getParamDecl(ParamIdx);
1611  if (!Param->hasDefaultArg() && !Param->isParameterPack() &&
1614  if (Param->isInvalidDecl())
1615  /* We already complained about this parameter. */;
1616  else if (Param->getIdentifier())
1617  Diag(Param->getLocation(),
1618  diag::err_param_default_argument_missing_name)
1619  << Param->getIdentifier();
1620  else
1621  Diag(Param->getLocation(),
1622  diag::err_param_default_argument_missing);
1623  }
1624  }
1625 }
1626 
1627 /// Check that the given type is a literal type. Issue a diagnostic if not,
1628 /// if Kind is Diagnose.
1629 /// \return \c true if a problem has been found (and optionally diagnosed).
1630 template <typename... Ts>
1632  SourceLocation Loc, QualType T, unsigned DiagID,
1633  Ts &&...DiagArgs) {
1634  if (T->isDependentType())
1635  return false;
1636 
1637  switch (Kind) {
1639  return SemaRef.RequireLiteralType(Loc, T, DiagID,
1640  std::forward<Ts>(DiagArgs)...);
1641 
1643  return !T->isLiteralType(SemaRef.Context);
1644  }
1645 
1646  llvm_unreachable("unknown CheckConstexprKind");
1647 }
1648 
1649 /// Determine whether a destructor cannot be constexpr due to
1651  const CXXDestructorDecl *DD,
1653  auto Check = [&](SourceLocation Loc, QualType T, const FieldDecl *FD) {
1654  const CXXRecordDecl *RD =
1655  T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
1656  if (!RD || RD->hasConstexprDestructor())
1657  return true;
1658 
1660  SemaRef.Diag(DD->getLocation(), diag::err_constexpr_dtor_subobject)
1661  << static_cast<int>(DD->getConstexprKind()) << !FD
1662  << (FD ? FD->getDeclName() : DeclarationName()) << T;
1663  SemaRef.Diag(Loc, diag::note_constexpr_dtor_subobject)
1664  << !FD << (FD ? FD->getDeclName() : DeclarationName()) << T;
1665  }
1666  return false;
1667  };
1668 
1669  const CXXRecordDecl *RD = DD->getParent();
1670  for (const CXXBaseSpecifier &B : RD->bases())
1671  if (!Check(B.getBaseTypeLoc(), B.getType(), nullptr))
1672  return false;
1673  for (const FieldDecl *FD : RD->fields())
1674  if (!Check(FD->getLocation(), FD->getType(), FD))
1675  return false;
1676  return true;
1677 }
1678 
1679 /// Check whether a function's parameter types are all literal types. If so,
1680 /// return true. If not, produce a suitable diagnostic and return false.
1681 static bool CheckConstexprParameterTypes(Sema &SemaRef,
1682  const FunctionDecl *FD,
1684  unsigned ArgIndex = 0;
1685  const auto *FT = FD->getType()->castAs<FunctionProtoType>();
1686  for (FunctionProtoType::param_type_iterator i = FT->param_type_begin(),
1687  e = FT->param_type_end();
1688  i != e; ++i, ++ArgIndex) {
1689  const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
1690  SourceLocation ParamLoc = PD->getLocation();
1691  if (CheckLiteralType(SemaRef, Kind, ParamLoc, *i,
1692  diag::err_constexpr_non_literal_param, ArgIndex + 1,
1693  PD->getSourceRange(), isa<CXXConstructorDecl>(FD),
1694  FD->isConsteval()))
1695  return false;
1696  }
1697  return true;
1698 }
1699 
1700 /// Check whether a function's return type is a literal type. If so, return
1701 /// true. If not, produce a suitable diagnostic and return false.
1702 static bool CheckConstexprReturnType(Sema &SemaRef, const FunctionDecl *FD,
1704  if (CheckLiteralType(SemaRef, Kind, FD->getLocation(), FD->getReturnType(),
1705  diag::err_constexpr_non_literal_return,
1706  FD->isConsteval()))
1707  return false;
1708  return true;
1709 }
1710 
1711 /// Get diagnostic %select index for tag kind for
1712 /// record diagnostic message.
1713 /// WARNING: Indexes apply to particular diagnostics only!
1714 ///
1715 /// \returns diagnostic %select index.
1717  switch (Tag) {
1718  case TTK_Struct: return 0;
1719  case TTK_Interface: return 1;
1720  case TTK_Class: return 2;
1721  default: llvm_unreachable("Invalid tag kind for record diagnostic!");
1722  }
1723 }
1724 
1725 static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl,
1726  Stmt *Body,
1728 
1729 // Check whether a function declaration satisfies the requirements of a
1730 // constexpr function definition or a constexpr constructor definition. If so,
1731 // return true. If not, produce appropriate diagnostics (unless asked not to by
1732 // Kind) and return false.
1733 //
1734 // This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360.
1737  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
1738  if (MD && MD->isInstance()) {
1739  // C++11 [dcl.constexpr]p4:
1740  // The definition of a constexpr constructor shall satisfy the following
1741  // constraints:
1742  // - the class shall not have any virtual base classes;
1743  //
1744  // FIXME: This only applies to constructors and destructors, not arbitrary
1745  // member functions.
1746  const CXXRecordDecl *RD = MD->getParent();
1747  if (RD->getNumVBases()) {
1749  return false;
1750 
1751  Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base)
1752  << isa<CXXConstructorDecl>(NewFD)
1754  for (const auto &I : RD->vbases())
1755  Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
1756  << I.getSourceRange();
1757  return false;
1758  }
1759  }
1760 
1761  if (!isa<CXXConstructorDecl>(NewFD)) {
1762  // C++11 [dcl.constexpr]p3:
1763  // The definition of a constexpr function shall satisfy the following
1764  // constraints:
1765  // - it shall not be virtual; (removed in C++20)
1766  const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
1767  if (Method && Method->isVirtual()) {
1768  if (getLangOpts().CPlusPlus20) {
1770  Diag(Method->getLocation(), diag::warn_cxx17_compat_constexpr_virtual);
1771  } else {
1773  return false;
1774 
1775  Method = Method->getCanonicalDecl();
1776  Diag(Method->getLocation(), diag::err_constexpr_virtual);
1777 
1778  // If it's not obvious why this function is virtual, find an overridden
1779  // function which uses the 'virtual' keyword.
1780  const CXXMethodDecl *WrittenVirtual = Method;
1781  while (!WrittenVirtual->isVirtualAsWritten())
1782  WrittenVirtual = *WrittenVirtual->begin_overridden_methods();
1783  if (WrittenVirtual != Method)
1784  Diag(WrittenVirtual->getLocation(),
1785  diag::note_overridden_virtual_function);
1786  return false;
1787  }
1788  }
1789 
1790  // - its return type shall be a literal type;
1791  if (!CheckConstexprReturnType(*this, NewFD, Kind))
1792  return false;
1793  }
1794 
1795  if (auto *Dtor = dyn_cast<CXXDestructorDecl>(NewFD)) {
1796  // A destructor can be constexpr only if the defaulted destructor could be;
1797  // we don't need to check the members and bases if we already know they all
1798  // have constexpr destructors.
1799  if (!Dtor->getParent()->defaultedDestructorIsConstexpr()) {
1801  return false;
1802  if (!CheckConstexprDestructorSubobjects(*this, Dtor, Kind))
1803  return false;
1804  }
1805  }
1806 
1807  // - each of its parameter types shall be a literal type;
1808  if (!CheckConstexprParameterTypes(*this, NewFD, Kind))
1809  return false;
1810 
1811  Stmt *Body = NewFD->getBody();
1812  assert(Body &&
1813  "CheckConstexprFunctionDefinition called on function with no body");
1814  return CheckConstexprFunctionBody(*this, NewFD, Body, Kind);
1815 }
1816 
1817 /// Check the given declaration statement is legal within a constexpr function
1818 /// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.
1819 ///
1820 /// \return true if the body is OK (maybe only as an extension), false if we
1821 /// have diagnosed a problem.
1822 static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
1823  DeclStmt *DS, SourceLocation &Cxx1yLoc,
1825  // C++11 [dcl.constexpr]p3 and p4:
1826  // The definition of a constexpr function(p3) or constructor(p4) [...] shall
1827  // contain only
1828  for (const auto *DclIt : DS->decls()) {
1829  switch (DclIt->getKind()) {
1830  case Decl::StaticAssert:
1831  case Decl::Using:
1832  case Decl::UsingShadow:
1833  case Decl::UsingDirective:
1834  case Decl::UnresolvedUsingTypename:
1835  case Decl::UnresolvedUsingValue:
1836  case Decl::UsingEnum:
1837  // - static_assert-declarations
1838  // - using-declarations,
1839  // - using-directives,
1840  // - using-enum-declaration
1841  continue;
1842 
1843  case Decl::Typedef:
1844  case Decl::TypeAlias: {
1845  // - typedef declarations and alias-declarations that do not define
1846  // classes or enumerations,
1847  const auto *TN = cast<TypedefNameDecl>(DclIt);
1848  if (TN->getUnderlyingType()->isVariablyModifiedType()) {
1849  // Don't allow variably-modified types in constexpr functions.
1851  TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
1852  SemaRef.Diag(TL.getBeginLoc(), diag::err_constexpr_vla)
1853  << TL.getSourceRange() << TL.getType()
1854  << isa<CXXConstructorDecl>(Dcl);
1855  }
1856  return false;
1857  }
1858  continue;
1859  }
1860 
1861  case Decl::Enum:
1862  case Decl::CXXRecord:
1863  // C++1y allows types to be defined, not just declared.
1864  if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition()) {
1866  SemaRef.Diag(DS->getBeginLoc(),
1867  SemaRef.getLangOpts().CPlusPlus14
1868  ? diag::warn_cxx11_compat_constexpr_type_definition
1869  : diag::ext_constexpr_type_definition)
1870  << isa<CXXConstructorDecl>(Dcl);
1871  } else if (!SemaRef.getLangOpts().CPlusPlus14) {
1872  return false;
1873  }
1874  }
1875  continue;
1876 
1877  case Decl::EnumConstant:
1878  case Decl::IndirectField:
1879  case Decl::ParmVar:
1880  // These can only appear with other declarations which are banned in
1881  // C++11 and permitted in C++1y, so ignore them.
1882  continue;
1883 
1884  case Decl::Var:
1885  case Decl::Decomposition: {
1886  // C++1y [dcl.constexpr]p3 allows anything except:
1887  // a definition of a variable of non-literal type or of static or
1888  // thread storage duration or [before C++2a] for which no
1889  // initialization is performed.
1890  const auto *VD = cast<VarDecl>(DclIt);
1891  if (VD->isThisDeclarationADefinition()) {
1892  if (VD->isStaticLocal()) {
1894  SemaRef.Diag(VD->getLocation(),
1895  diag::err_constexpr_local_var_static)
1896  << isa<CXXConstructorDecl>(Dcl)
1897  << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
1898  }
1899  return false;
1900  }
1901  if (CheckLiteralType(SemaRef, Kind, VD->getLocation(), VD->getType(),
1902  diag::err_constexpr_local_var_non_literal_type,
1903  isa<CXXConstructorDecl>(Dcl)))
1904  return false;
1905  if (!VD->getType()->isDependentType() &&
1906  !VD->hasInit() && !VD->isCXXForRangeDecl()) {
1908  SemaRef.Diag(
1909  VD->getLocation(),
1910  SemaRef.getLangOpts().CPlusPlus20
1911  ? diag::warn_cxx17_compat_constexpr_local_var_no_init
1912  : diag::ext_constexpr_local_var_no_init)
1913  << isa<CXXConstructorDecl>(Dcl);
1914  } else if (!SemaRef.getLangOpts().CPlusPlus20) {
1915  return false;
1916  }
1917  continue;
1918  }
1919  }
1921  SemaRef.Diag(VD->getLocation(),
1922  SemaRef.getLangOpts().CPlusPlus14
1923  ? diag::warn_cxx11_compat_constexpr_local_var
1924  : diag::ext_constexpr_local_var)
1925  << isa<CXXConstructorDecl>(Dcl);
1926  } else if (!SemaRef.getLangOpts().CPlusPlus14) {
1927  return false;
1928  }
1929  continue;
1930  }
1931 
1932  case Decl::NamespaceAlias:
1933  case Decl::Function:
1934  // These are disallowed in C++11 and permitted in C++1y. Allow them
1935  // everywhere as an extension.
1936  if (!Cxx1yLoc.isValid())
1937  Cxx1yLoc = DS->getBeginLoc();
1938  continue;
1939 
1940  default:
1942  SemaRef.Diag(DS->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
1943  << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval();
1944  }
1945  return false;
1946  }
1947  }
1948 
1949  return true;
1950 }
1951 
1952 /// Check that the given field is initialized within a constexpr constructor.
1953 ///
1954 /// \param Dcl The constexpr constructor being checked.
1955 /// \param Field The field being checked. This may be a member of an anonymous
1956 /// struct or union nested within the class being checked.
1957 /// \param Inits All declarations, including anonymous struct/union members and
1958 /// indirect members, for which any initialization was provided.
1959 /// \param Diagnosed Whether we've emitted the error message yet. Used to attach
1960 /// multiple notes for different members to the same error.
1961 /// \param Kind Whether we're diagnosing a constructor as written or determining
1962 /// whether the formal requirements are satisfied.
1963 /// \return \c false if we're checking for validity and the constructor does
1964 /// not satisfy the requirements on a constexpr constructor.
1966  const FunctionDecl *Dcl,
1967  FieldDecl *Field,
1968  llvm::SmallSet<Decl*, 16> &Inits,
1969  bool &Diagnosed,
1971  // In C++20 onwards, there's nothing to check for validity.
1973  SemaRef.getLangOpts().CPlusPlus20)
1974  return true;
1975 
1976  if (Field->isInvalidDecl())
1977  return true;
1978 
1979  if (Field->isUnnamedBitfield())
1980  return true;
1981 
1982  // Anonymous unions with no variant members and empty anonymous structs do not
1983  // need to be explicitly initialized. FIXME: Anonymous structs that contain no
1984  // indirect fields don't need initializing.
1985  if (Field->isAnonymousStructOrUnion() &&
1986  (Field->getType()->isUnionType()
1987  ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
1988  : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
1989  return true;
1990 
1991  if (!Inits.count(Field)) {
1993  if (!Diagnosed) {
1994  SemaRef.Diag(Dcl->getLocation(),
1995  SemaRef.getLangOpts().CPlusPlus20
1996  ? diag::warn_cxx17_compat_constexpr_ctor_missing_init
1997  : diag::ext_constexpr_ctor_missing_init);
1998  Diagnosed = true;
1999  }
2000  SemaRef.Diag(Field->getLocation(),
2001  diag::note_constexpr_ctor_missing_init);
2002  } else if (!SemaRef.getLangOpts().CPlusPlus20) {
2003  return false;
2004  }
2005  } else if (Field->isAnonymousStructOrUnion()) {
2006  const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
2007  for (auto *I : RD->fields())
2008  // If an anonymous union contains an anonymous struct of which any member
2009  // is initialized, all members must be initialized.
2010  if (!RD->isUnion() || Inits.count(I))
2011  if (!CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed,
2012  Kind))
2013  return false;
2014  }
2015  return true;
2016 }
2017 
2018 /// Check the provided statement is allowed in a constexpr function
2019 /// definition.
2020 static bool
2022  SmallVectorImpl<SourceLocation> &ReturnStmts,
2023  SourceLocation &Cxx1yLoc, SourceLocation &Cxx2aLoc,
2025  // - its function-body shall be [...] a compound-statement that contains only
2026  switch (S->getStmtClass()) {
2027  case Stmt::NullStmtClass:
2028  // - null statements,
2029  return true;
2030 
2031  case Stmt::DeclStmtClass:
2032  // - static_assert-declarations
2033  // - using-declarations,
2034  // - using-directives,
2035  // - typedef declarations and alias-declarations that do not define
2036  // classes or enumerations,
2037  if (!CheckConstexprDeclStmt(SemaRef, Dcl, cast<DeclStmt>(S), Cxx1yLoc, Kind))
2038  return false;
2039  return true;
2040 
2041  case Stmt::ReturnStmtClass:
2042  // - and exactly one return statement;
2043  if (isa<CXXConstructorDecl>(Dcl)) {
2044  // C++1y allows return statements in constexpr constructors.
2045  if (!Cxx1yLoc.isValid())
2046  Cxx1yLoc = S->getBeginLoc();
2047  return true;
2048  }
2049 
2050  ReturnStmts.push_back(S->getBeginLoc());
2051  return true;
2052 
2053  case Stmt::CompoundStmtClass: {
2054  // C++1y allows compound-statements.
2055  if (!Cxx1yLoc.isValid())
2056  Cxx1yLoc = S->getBeginLoc();
2057 
2058  CompoundStmt *CompStmt = cast<CompoundStmt>(S);
2059  for (auto *BodyIt : CompStmt->body()) {
2060  if (!CheckConstexprFunctionStmt(SemaRef, Dcl, BodyIt, ReturnStmts,
2061  Cxx1yLoc, Cxx2aLoc, Kind))
2062  return false;
2063  }
2064  return true;
2065  }
2066 
2067  case Stmt::AttributedStmtClass:
2068  if (!Cxx1yLoc.isValid())
2069  Cxx1yLoc = S->getBeginLoc();
2070  return true;
2071 
2072  case Stmt::IfStmtClass: {
2073  // C++1y allows if-statements.
2074  if (!Cxx1yLoc.isValid())
2075  Cxx1yLoc = S->getBeginLoc();
2076 
2077  IfStmt *If = cast<IfStmt>(S);
2078  if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
2079  Cxx1yLoc, Cxx2aLoc, Kind))
2080  return false;
2081  if (If->getElse() &&
2082  !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
2083  Cxx1yLoc, Cxx2aLoc, Kind))
2084  return false;
2085  return true;
2086  }
2087 
2088  case Stmt::WhileStmtClass:
2089  case Stmt::DoStmtClass:
2090  case Stmt::ForStmtClass:
2091  case Stmt::CXXForRangeStmtClass:
2092  case Stmt::ContinueStmtClass:
2093  // C++1y allows all of these. We don't allow them as extensions in C++11,
2094  // because they don't make sense without variable mutation.
2095  if (!SemaRef.getLangOpts().CPlusPlus14)
2096  break;
2097  if (!Cxx1yLoc.isValid())
2098  Cxx1yLoc = S->getBeginLoc();
2099  for (Stmt *SubStmt : S->children())
2100  if (SubStmt &&
2101  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2102  Cxx1yLoc, Cxx2aLoc, Kind))
2103  return false;
2104  return true;
2105 
2106  case Stmt::SwitchStmtClass:
2107  case Stmt::CaseStmtClass:
2108  case Stmt::DefaultStmtClass:
2109  case Stmt::BreakStmtClass:
2110  // C++1y allows switch-statements, and since they don't need variable
2111  // mutation, we can reasonably allow them in C++11 as an extension.
2112  if (!Cxx1yLoc.isValid())
2113  Cxx1yLoc = S->getBeginLoc();
2114  for (Stmt *SubStmt : S->children())
2115  if (SubStmt &&
2116  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2117  Cxx1yLoc, Cxx2aLoc, Kind))
2118  return false;
2119  return true;
2120 
2121  case Stmt::GCCAsmStmtClass:
2122  case Stmt::MSAsmStmtClass:
2123  // C++2a allows inline assembly statements.
2124  case Stmt::CXXTryStmtClass:
2125  if (Cxx2aLoc.isInvalid())
2126  Cxx2aLoc = S->getBeginLoc();
2127  for (Stmt *SubStmt : S->children()) {
2128  if (SubStmt &&
2129  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2130  Cxx1yLoc, Cxx2aLoc, Kind))
2131  return false;
2132  }
2133  return true;
2134 
2135  case Stmt::CXXCatchStmtClass:
2136  // Do not bother checking the language mode (already covered by the
2137  // try block check).
2138  if (!CheckConstexprFunctionStmt(SemaRef, Dcl,
2139  cast<CXXCatchStmt>(S)->getHandlerBlock(),
2140  ReturnStmts, Cxx1yLoc, Cxx2aLoc, Kind))
2141  return false;
2142  return true;
2143 
2144  default:
2145  if (!isa<Expr>(S))
2146  break;
2147 
2148  // C++1y allows expression-statements.
2149  if (!Cxx1yLoc.isValid())
2150  Cxx1yLoc = S->getBeginLoc();
2151  return true;
2152  }
2153 
2155  SemaRef.Diag(S->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
2156  << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval();
2157  }
2158  return false;
2159 }
2160 
2161 /// Check the body for the given constexpr function declaration only contains
2162 /// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.
2163 ///
2164 /// \return true if the body is OK, false if we have found or diagnosed a
2165 /// problem.
2166 static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl,
2167  Stmt *Body,
2169  SmallVector<SourceLocation, 4> ReturnStmts;
2170 
2171  if (isa<CXXTryStmt>(Body)) {
2172  // C++11 [dcl.constexpr]p3:
2173  // The definition of a constexpr function shall satisfy the following
2174  // constraints: [...]
2175  // - its function-body shall be = delete, = default, or a
2176  // compound-statement
2177  //
2178  // C++11 [dcl.constexpr]p4:
2179  // In the definition of a constexpr constructor, [...]
2180  // - its function-body shall not be a function-try-block;
2181  //
2182  // This restriction is lifted in C++2a, as long as inner statements also
2183  // apply the general constexpr rules.
2184  switch (Kind) {
2186  if (!SemaRef.getLangOpts().CPlusPlus20)
2187  return false;
2188  break;
2189 
2191  SemaRef.Diag(Body->getBeginLoc(),
2192  !SemaRef.getLangOpts().CPlusPlus20
2193  ? diag::ext_constexpr_function_try_block_cxx20
2194  : diag::warn_cxx17_compat_constexpr_function_try_block)
2195  << isa<CXXConstructorDecl>(Dcl);
2196  break;
2197  }
2198  }
2199 
2200  // - its function-body shall be [...] a compound-statement that contains only
2201  // [... list of cases ...]
2202  //
2203  // Note that walking the children here is enough to properly check for
2204  // CompoundStmt and CXXTryStmt body.
2205  SourceLocation Cxx1yLoc, Cxx2aLoc;
2206  for (Stmt *SubStmt : Body->children()) {
2207  if (SubStmt &&
2208  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2209  Cxx1yLoc, Cxx2aLoc, Kind))
2210  return false;
2211  }
2212 
2214  // If this is only valid as an extension, report that we don't satisfy the
2215  // constraints of the current language.
2216  if ((Cxx2aLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus20) ||
2217  (Cxx1yLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus17))
2218  return false;
2219  } else if (Cxx2aLoc.isValid()) {
2220  SemaRef.Diag(Cxx2aLoc,
2221  SemaRef.getLangOpts().CPlusPlus20
2222  ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt
2223  : diag::ext_constexpr_body_invalid_stmt_cxx20)
2224  << isa<CXXConstructorDecl>(Dcl);
2225  } else if (Cxx1yLoc.isValid()) {
2226  SemaRef.Diag(Cxx1yLoc,
2227  SemaRef.getLangOpts().CPlusPlus14
2228  ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
2229  : diag::ext_constexpr_body_invalid_stmt)
2230  << isa<CXXConstructorDecl>(Dcl);
2231  }
2232 
2233  if (const CXXConstructorDecl *Constructor
2234  = dyn_cast<CXXConstructorDecl>(Dcl)) {
2235  const CXXRecordDecl *RD = Constructor->getParent();
2236  // DR1359:
2237  // - every non-variant non-static data member and base class sub-object
2238  // shall be initialized;
2239  // DR1460:
2240  // - if the class is a union having variant members, exactly one of them
2241  // shall be initialized;
2242  if (RD->isUnion()) {
2243  if (Constructor->getNumCtorInitializers() == 0 &&
2244  RD->hasVariantMembers()) {
2246  SemaRef.Diag(
2247  Dcl->getLocation(),
2248  SemaRef.getLangOpts().CPlusPlus20
2249  ? diag::warn_cxx17_compat_constexpr_union_ctor_no_init
2250  : diag::ext_constexpr_union_ctor_no_init);
2251  } else if (!SemaRef.getLangOpts().CPlusPlus20) {
2252  return false;
2253  }
2254  }
2255  } else if (!Constructor->isDependentContext() &&
2256  !Constructor->isDelegatingConstructor()) {
2257  assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases");
2258 
2259  // Skip detailed checking if we have enough initializers, and we would
2260  // allow at most one initializer per member.
2261  bool AnyAnonStructUnionMembers = false;
2262  unsigned Fields = 0;
2264  E = RD->field_end(); I != E; ++I, ++Fields) {
2265  if (I->isAnonymousStructOrUnion()) {
2266  AnyAnonStructUnionMembers = true;
2267  break;
2268  }
2269  }
2270  // DR1460:
2271  // - if the class is a union-like class, but is not a union, for each of
2272  // its anonymous union members having variant members, exactly one of
2273  // them shall be initialized;
2274  if (AnyAnonStructUnionMembers ||
2275  Constructor->getNumCtorInitializers() != RD->getNumBases() + Fields) {
2276  // Check initialization of non-static data members. Base classes are
2277  // always initialized so do not need to be checked. Dependent bases
2278  // might not have initializers in the member initializer list.
2279  llvm::SmallSet<Decl*, 16> Inits;
2280  for (const auto *I: Constructor->inits()) {
2281  if (FieldDecl *FD = I->getMember())
2282  Inits.insert(FD);
2283  else if (IndirectFieldDecl *ID = I->getIndirectMember())
2284  Inits.insert(ID->chain_begin(), ID->chain_end());
2285  }
2286 
2287  bool Diagnosed = false;
2288  for (auto *I : RD->fields())
2289  if (!CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed,
2290  Kind))
2291  return false;
2292  }
2293  }
2294  } else {
2295  if (ReturnStmts.empty()) {
2296  // C++1y doesn't require constexpr functions to contain a 'return'
2297  // statement. We still do, unless the return type might be void, because
2298  // otherwise if there's no return statement, the function cannot
2299  // be used in a core constant expression.
2300  bool OK = SemaRef.getLangOpts().CPlusPlus14 &&
2301  (Dcl->getReturnType()->isVoidType() ||
2302  Dcl->getReturnType()->isDependentType());
2303  switch (Kind) {
2305  SemaRef.Diag(Dcl->getLocation(),
2306  OK ? diag::warn_cxx11_compat_constexpr_body_no_return
2307  : diag::err_constexpr_body_no_return)
2308  << Dcl->isConsteval();
2309  if (!OK)
2310  return false;
2311  break;
2312 
2314  // The formal requirements don't include this rule in C++14, even
2315  // though the "must be able to produce a constant expression" rules
2316  // still imply it in some cases.
2317  if (!SemaRef.getLangOpts().CPlusPlus14)
2318  return false;
2319  break;
2320  }
2321  } else if (ReturnStmts.size() > 1) {
2322  switch (Kind) {
2324  SemaRef.Diag(
2325  ReturnStmts.back(),
2326  SemaRef.getLangOpts().CPlusPlus14
2327  ? diag::warn_cxx11_compat_constexpr_body_multiple_return
2328  : diag::ext_constexpr_body_multiple_return);
2329  for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
2330  SemaRef.Diag(ReturnStmts[I],
2331  diag::note_constexpr_body_previous_return);
2332  break;
2333 
2335  if (!SemaRef.getLangOpts().CPlusPlus14)
2336  return false;
2337  break;
2338  }
2339  }
2340  }
2341 
2342  // C++11 [dcl.constexpr]p5:
2343  // if no function argument values exist such that the function invocation
2344  // substitution would produce a constant expression, the program is
2345  // ill-formed; no diagnostic required.
2346  // C++11 [dcl.constexpr]p3:
2347  // - every constructor call and implicit conversion used in initializing the
2348  // return value shall be one of those allowed in a constant expression.
2349  // C++11 [dcl.constexpr]p4:
2350  // - every constructor involved in initializing non-static data members and
2351  // base class sub-objects shall be a constexpr constructor.
2352  //
2353  // Note that this rule is distinct from the "requirements for a constexpr
2354  // function", so is not checked in CheckValid mode.
2358  SemaRef.Diag(Dcl->getLocation(),
2359  diag::ext_constexpr_function_never_constant_expr)
2360  << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval();
2361  for (size_t I = 0, N = Diags.size(); I != N; ++I)
2362  SemaRef.Diag(Diags[I].first, Diags[I].second);
2363  // Don't return false here: we allow this for compatibility in
2364  // system headers.
2365  }
2366 
2367  return true;
2368 }
2369 
2370 /// Get the class that is directly named by the current context. This is the
2371 /// class for which an unqualified-id in this scope could name a constructor
2372 /// or destructor.
2373 ///
2374 /// If the scope specifier denotes a class, this will be that class.
2375 /// If the scope specifier is empty, this will be the class whose
2376 /// member-specification we are currently within. Otherwise, there
2377 /// is no such class.
2379  assert(getLangOpts().CPlusPlus && "No class names in C!");
2380 
2381  if (SS && SS->isInvalid())
2382  return nullptr;
2383 
2384  if (SS && SS->isNotEmpty()) {
2385  DeclContext *DC = computeDeclContext(*SS, true);
2386  return dyn_cast_or_null<CXXRecordDecl>(DC);
2387  }
2388 
2389  return dyn_cast_or_null<CXXRecordDecl>(CurContext);
2390 }
2391 
2392 /// isCurrentClassName - Determine whether the identifier II is the
2393 /// name of the class type currently being defined. In the case of
2394 /// nested classes, this will only return true if II is the name of
2395 /// the innermost class.
2397  const CXXScopeSpec *SS) {
2398  CXXRecordDecl *CurDecl = getCurrentClass(S, SS);
2399  return CurDecl && &II == CurDecl->getIdentifier();
2400 }
2401 
2402 /// Determine whether the identifier II is a typo for the name of
2403 /// the class type currently being defined. If so, update it to the identifier
2404 /// that should have been used.
2406  assert(getLangOpts().CPlusPlus && "No class names in C!");
2407 
2408  if (!getLangOpts().SpellChecking)
2409  return false;
2410 
2411  CXXRecordDecl *CurDecl;
2412  if (SS && SS->isSet() && !SS->isInvalid()) {
2413  DeclContext *DC = computeDeclContext(*SS, true);
2414  CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
2415  } else
2416  CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
2417 
2418  if (CurDecl && CurDecl->getIdentifier() && II != CurDecl->getIdentifier() &&
2419  3 * II->getName().edit_distance(CurDecl->getIdentifier()->getName())
2420  < II->getLength()) {
2421  II = CurDecl->getIdentifier();
2422  return true;
2423  }
2424 
2425  return false;
2426 }
2427 
2428 /// Determine whether the given class is a base class of the given
2429 /// class, including looking at dependent bases.
2430 static bool findCircularInheritance(const CXXRecordDecl *Class,
2431  const CXXRecordDecl *Current) {
2433 
2434  Class = Class->getCanonicalDecl();
2435  while (true) {
2436  for (const auto &I : Current->bases()) {
2437  CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl();
2438  if (!Base)
2439  continue;
2440 
2441  Base = Base->getDefinition();
2442  if (!Base)
2443  continue;
2444 
2445  if (Base->getCanonicalDecl() == Class)
2446  return true;
2447 
2448  Queue.push_back(Base);
2449  }
2450 
2451  if (Queue.empty())
2452  return false;
2453 
2454  Current = Queue.pop_back_val();
2455  }
2456 
2457  return false;
2458 }
2459 
2460 /// Check the validity of a C++ base class specifier.
2461 ///
2462 /// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
2463 /// and returns NULL otherwise.
2466  SourceRange SpecifierRange,
2467  bool Virtual, AccessSpecifier Access,
2468  TypeSourceInfo *TInfo,
2469  SourceLocation EllipsisLoc) {
2470  QualType BaseType = TInfo->getType();
2471  if (BaseType->containsErrors()) {
2472  // Already emitted a diagnostic when parsing the error type.
2473  return nullptr;
2474  }
2475  // C++ [class.union]p1:
2476  // A union shall not have base classes.
2477  if (Class->isUnion()) {
2478  Diag(Class->getLocation(), diag::err_base_clause_on_union)
2479  << SpecifierRange;
2480  return nullptr;
2481  }
2482 
2483  if (EllipsisLoc.isValid() &&
2485  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
2486  << TInfo->getTypeLoc().getSourceRange();
2487  EllipsisLoc = SourceLocation();
2488  }
2489 
2490  SourceLocation BaseLoc = TInfo->getTypeLoc().getBeginLoc();
2491 
2492  if (BaseType->isDependentType()) {
2493  // Make sure that we don't have circular inheritance among our dependent
2494  // bases. For non-dependent bases, the check for completeness below handles
2495  // this.
2496  if (CXXRecordDecl *BaseDecl = BaseType->getAsCXXRecordDecl()) {
2497  if (BaseDecl->getCanonicalDecl() == Class->getCanonicalDecl() ||
2498  ((BaseDecl = BaseDecl->getDefinition()) &&
2499  findCircularInheritance(Class, BaseDecl))) {
2500  Diag(BaseLoc, diag::err_circular_inheritance)
2501  << BaseType << Context.getTypeDeclType(Class);
2502 
2503  if (BaseDecl->getCanonicalDecl() != Class->getCanonicalDecl())
2504  Diag(BaseDecl->getLocation(), diag::note_previous_decl)
2505  << BaseType;
2506 
2507  return nullptr;
2508  }
2509  }
2510 
2511  // Make sure that we don't make an ill-formed AST where the type of the
2512  // Class is non-dependent and its attached base class specifier is an
2513  // dependent type, which violates invariants in many clang code paths (e.g.
2514  // constexpr evaluator). If this case happens (in errory-recovery mode), we
2515  // explicitly mark the Class decl invalid. The diagnostic was already
2516  // emitted.
2517  if (!Class->getTypeForDecl()->isDependentType())
2518  Class->setInvalidDecl();
2519  return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
2520  Class->getTagKind() == TTK_Class,
2521  Access, TInfo, EllipsisLoc);
2522  }
2523 
2524  // Base specifiers must be record types.
2525  if (!BaseType->isRecordType()) {
2526  Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
2527  return nullptr;
2528  }
2529 
2530  // C++ [class.union]p1:
2531  // A union shall not be used as a base class.
2532  if (BaseType->isUnionType()) {
2533  Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
2534  return nullptr;
2535  }
2536 
2537  // For the MS ABI, propagate DLL attributes to base class templates.
2539  if (Attr *ClassAttr = getDLLAttr(Class)) {
2540  if (auto *BaseTemplate = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
2541  BaseType->getAsCXXRecordDecl())) {
2542  propagateDLLAttrToBaseClassTemplate(Class, ClassAttr, BaseTemplate,
2543  BaseLoc);
2544  }
2545  }
2546  }
2547 
2548  // C++ [class.derived]p2:
2549  // The class-name in a base-specifier shall not be an incompletely
2550  // defined class.
2551  if (RequireCompleteType(BaseLoc, BaseType,
2552  diag::err_incomplete_base_class, SpecifierRange)) {
2553  Class->setInvalidDecl();
2554  return nullptr;
2555  }
2556 
2557  // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
2558  RecordDecl *BaseDecl = BaseType->castAs<RecordType>()->getDecl();
2559  assert(BaseDecl && "Record type has no declaration");
2560  BaseDecl = BaseDecl->getDefinition();
2561  assert(BaseDecl && "Base type is not incomplete, but has no definition");
2562  CXXRecordDecl *CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
2563  assert(CXXBaseDecl && "Base type is not a C++ type");
2564 
2565  // Microsoft docs say:
2566  // "If a base-class has a code_seg attribute, derived classes must have the
2567  // same attribute."
2568  const auto *BaseCSA = CXXBaseDecl->getAttr<CodeSegAttr>();
2569  const auto *DerivedCSA = Class->getAttr<CodeSegAttr>();
2570  if ((DerivedCSA || BaseCSA) &&
2571  (!BaseCSA || !DerivedCSA || BaseCSA->getName() != DerivedCSA->getName())) {
2572  Diag(Class->getLocation(), diag::err_mismatched_code_seg_base);
2573  Diag(CXXBaseDecl->getLocation(), diag::note_base_class_specified_here)
2574  << CXXBaseDecl;
2575  return nullptr;
2576  }
2577 
2578  // A class which contains a flexible array member is not suitable for use as a
2579  // base class:
2580  // - If the layout determines that a base comes before another base,
2581  // the flexible array member would index into the subsequent base.
2582  // - If the layout determines that base comes before the derived class,
2583  // the flexible array member would index into the derived class.
2584  if (CXXBaseDecl->hasFlexibleArrayMember()) {
2585  Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
2586  << CXXBaseDecl->getDeclName();
2587  return nullptr;
2588  }
2589 
2590  // C++ [class]p3:
2591  // If a class is marked final and it appears as a base-type-specifier in
2592  // base-clause, the program is ill-formed.
2593  if (FinalAttr *FA = CXXBaseDecl->getAttr<FinalAttr>()) {
2594  Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
2595  << CXXBaseDecl->getDeclName()
2596  << FA->isSpelledAsSealed();
2597  Diag(CXXBaseDecl->getLocation(), diag::note_entity_declared_at)
2598  << CXXBaseDecl->getDeclName() << FA->getRange();
2599  return nullptr;
2600  }
2601 
2602  if (BaseDecl->isInvalidDecl())
2603  Class->setInvalidDecl();
2604 
2605  // Create the base specifier.
2606  return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
2607  Class->getTagKind() == TTK_Class,
2608  Access, TInfo, EllipsisLoc);
2609 }
2610 
2611 /// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
2612 /// one entry in the base class list of a class specifier, for
2613 /// example:
2614 /// class foo : public bar, virtual private baz {
2615 /// 'public bar' and 'virtual private baz' are each base-specifiers.
2616 BaseResult
2617 Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange,
2618  ParsedAttributes &Attributes,
2619  bool Virtual, AccessSpecifier Access,
2620  ParsedType basetype, SourceLocation BaseLoc,
2621  SourceLocation EllipsisLoc) {
2622  if (!classdecl)
2623  return true;
2624 
2625  AdjustDeclIfTemplate(classdecl);
2626  CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl);
2627  if (!Class)
2628  return true;
2629 
2630  // We haven't yet attached the base specifiers.
2631  Class->setIsParsingBaseSpecifiers();
2632 
2633  // We do not support any C++11 attributes on base-specifiers yet.
2634  // Diagnose any attributes we see.
2635  for (const ParsedAttr &AL : Attributes) {
2636  if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute)
2637  continue;
2638  Diag(AL.getLoc(), AL.getKind() == ParsedAttr::UnknownAttribute
2639  ? (unsigned)diag::warn_unknown_attribute_ignored
2640  : (unsigned)diag::err_base_specifier_attribute)
2641  << AL << AL.getRange();
2642  }
2643 
2644  TypeSourceInfo *TInfo = nullptr;
2645  GetTypeFromParser(basetype, &TInfo);
2646 
2647  if (EllipsisLoc.isInvalid() &&
2648  DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo,
2649  UPPC_BaseType))
2650  return true;
2651 
2652  if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
2653  Virtual, Access, TInfo,
2654  EllipsisLoc))
2655  return BaseSpec;
2656  else
2657  Class->setInvalidDecl();
2658 
2659  return true;
2660 }
2661 
2662 /// Use small set to collect indirect bases. As this is only used
2663 /// locally, there's no need to abstract the small size parameter.
2665 
2666 /// Recursively add the bases of Type. Don't add Type itself.
2667 static void
2669  const QualType &Type)
2670 {
2671  // Even though the incoming type is a base, it might not be
2672  // a class -- it could be a template parm, for instance.
2673  if (auto Rec = Type->getAs<RecordType>()) {
2674  auto Decl = Rec->getAsCXXRecordDecl();
2675 
2676  // Iterate over its bases.
2677  for (const auto &BaseSpec : Decl->bases()) {
2678  QualType Base = Context.getCanonicalType(BaseSpec.getType())
2679  .getUnqualifiedType();
2680  if (Set.insert(Base).second)
2681  // If we've not already seen it, recurse.
2683  }
2684  }
2685 }
2686 
2687 /// Performs the actual work of attaching the given base class
2688 /// specifiers to a C++ class.
2691  if (Bases.empty())
2692  return false;
2693 
2694  // Used to keep track of which base types we have already seen, so
2695  // that we can properly diagnose redundant direct base types. Note
2696  // that the key is always the unqualified canonical type of the base
2697  // class.
2698  std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
2699 
2700  // Used to track indirect bases so we can see if a direct base is
2701  // ambiguous.
2702  IndirectBaseSet IndirectBaseTypes;
2703 
2704  // Copy non-redundant base specifiers into permanent storage.
2705  unsigned NumGoodBases = 0;
2706  bool Invalid = false;
2707  for (unsigned idx = 0; idx < Bases.size(); ++idx) {
2708  QualType NewBaseType
2709  = Context.getCanonicalType(Bases[idx]->getType());
2710  NewBaseType = NewBaseType.getLocalUnqualifiedType();
2711 
2712  CXXBaseSpecifier *&KnownBase = KnownBaseTypes[NewBaseType];
2713  if (KnownBase) {
2714  // C++ [class.mi]p3:
2715  // A class shall not be specified as a direct base class of a
2716  // derived class more than once.
2717  Diag(Bases[idx]->getBeginLoc(), diag::err_duplicate_base_class)
2718  << KnownBase->getType() << Bases[idx]->getSourceRange();
2719 
2720  // Delete the duplicate base class specifier; we're going to
2721  // overwrite its pointer later.
2722  Context.Deallocate(Bases[idx]);
2723 
2724  Invalid = true;
2725  } else {
2726  // Okay, add this new base class.
2727  KnownBase = Bases[idx];
2728  Bases[NumGoodBases++] = Bases[idx];
2729 
2730  // Note this base's direct & indirect bases, if there could be ambiguity.
2731  if (Bases.size() > 1)
2732  NoteIndirectBases(Context, IndirectBaseTypes, NewBaseType);
2733 
2734  if (const RecordType *Record = NewBaseType->getAs<RecordType>()) {
2735  const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
2736  if (Class->isInterface() &&
2737  (!RD->isInterfaceLike() ||
2738  KnownBase->getAccessSpecifier() != AS_public)) {
2739  // The Microsoft extension __interface does not permit bases that
2740  // are not themselves public interfaces.
2741  Diag(KnownBase->getBeginLoc(), diag::err_invalid_base_in_interface)
2742  << getRecordDiagFromTagKind(RD->getTagKind()) << RD
2743  << RD->getSourceRange();
2744  Invalid = true;
2745  }
2746  if (RD->hasAttr<WeakAttr>())
2747  Class->addAttr(WeakAttr::CreateImplicit(Context));
2748  }
2749  }
2750  }
2751 
2752  // Attach the remaining base class specifiers to the derived class.
2753  Class->setBases(Bases.data(), NumGoodBases);
2754 
2755  // Check that the only base classes that are duplicate are virtual.
2756  for (unsigned idx = 0; idx < NumGoodBases; ++idx) {
2757  // Check whether this direct base is inaccessible due to ambiguity.
2758  QualType BaseType = Bases[idx]->getType();
2759 
2760  // Skip all dependent types in templates being used as base specifiers.
2761  // Checks below assume that the base specifier is a CXXRecord.
2762  if (BaseType->isDependentType())
2763  continue;
2764 
2765  CanQualType CanonicalBase = Context.getCanonicalType(BaseType)
2766  .getUnqualifiedType();
2767 
2768  if (IndirectBaseTypes.count(CanonicalBase)) {
2769  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2770  /*DetectVirtual=*/true);
2771  bool found
2772  = Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
2773  assert(found);
2774  (void)found;
2775 
2776  if (Paths.isAmbiguous(CanonicalBase))
2777  Diag(Bases[idx]->getBeginLoc(), diag::warn_inaccessible_base_class)
2778  << BaseType << getAmbiguousPathsDisplayString(Paths)
2779  << Bases[idx]->getSourceRange();
2780  else
2781  assert(Bases[idx]->isVirtual());
2782  }
2783 
2784  // Delete the base class specifier, since its data has been copied
2785  // into the CXXRecordDecl.
2786  Context.Deallocate(Bases[idx]);
2787  }
2788 
2789  return Invalid;
2790 }
2791 
2792 /// ActOnBaseSpecifiers - Attach the given base specifiers to the
2793 /// class, after checking whether there are any duplicate base
2794 /// classes.
2797  if (!ClassDecl || Bases.empty())
2798  return;
2799 
2800  AdjustDeclIfTemplate(ClassDecl);
2801  AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), Bases);
2802 }
2803 
2804 /// Determine whether the type \p Derived is a C++ class that is
2805 /// derived from the type \p Base.
2807  if (!getLangOpts().CPlusPlus)
2808  return false;
2809 
2810  CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
2811  if (!DerivedRD)
2812  return false;
2813 
2814  CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
2815  if (!BaseRD)
2816  return false;
2817 
2818  // If either the base or the derived type is invalid, don't try to
2819  // check whether one is derived from the other.
2820  if (BaseRD->isInvalidDecl() || DerivedRD->isInvalidDecl())
2821  return false;
2822 
2823  // FIXME: In a modules build, do we need the entire path to be visible for us
2824  // to be able to use the inheritance relationship?
2825  if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
2826  return false;
2827 
2828  return DerivedRD->isDerivedFrom(BaseRD);
2829 }
2830 
2831 /// Determine whether the type \p Derived is a C++ class that is
2832 /// derived from the type \p Base.
2834  CXXBasePaths &Paths) {
2835  if (!getLangOpts().CPlusPlus)
2836  return false;
2837 
2838  CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
2839  if (!DerivedRD)
2840  return false;
2841 
2842  CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
2843  if (!BaseRD)
2844  return false;
2845 
2846  if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
2847  return false;
2848 
2849  return DerivedRD->isDerivedFrom(BaseRD, Paths);
2850 }
2851 
2852 static void BuildBasePathArray(const CXXBasePath &Path,
2853  CXXCastPath &BasePathArray) {
2854  // We first go backward and check if we have a virtual base.
2855  // FIXME: It would be better if CXXBasePath had the base specifier for
2856  // the nearest virtual base.
2857  unsigned Start = 0;
2858  for (unsigned I = Path.size(); I != 0; --I) {
2859  if (Path[I - 1].Base->isVirtual()) {
2860  Start = I - 1;
2861  break;
2862  }
2863  }
2864 
2865  // Now add all bases.
2866  for (unsigned I = Start, E = Path.size(); I != E; ++I)
2867  BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
2868 }
2869 
2870 
2872  CXXCastPath &BasePathArray) {
2873  assert(BasePathArray.empty() && "Base path array must be empty!");
2874  assert(Paths.isRecordingPaths() && "Must record paths!");
2875  return ::BuildBasePathArray(Paths.front(), BasePathArray);
2876 }
2877 /// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
2878 /// conversion (where Derived and Base are class types) is
2879 /// well-formed, meaning that the conversion is unambiguous (and
2880 /// that all of the base classes are accessible). Returns true
2881 /// and emits a diagnostic if the code is ill-formed, returns false
2882 /// otherwise. Loc is the location where this routine should point to
2883 /// if there is an error, and Range is the source range to highlight
2884 /// if there is an error.
2885 ///
2886 /// If either InaccessibleBaseID or AmbiguousBaseConvID are 0, then the
2887 /// diagnostic for the respective type of error will be suppressed, but the
2888 /// check for ill-formed code will still be performed.
2889 bool
2891  unsigned InaccessibleBaseID,
2892  unsigned AmbiguousBaseConvID,
2893  SourceLocation Loc, SourceRange Range,
2894  DeclarationName Name,
2895  CXXCastPath *BasePath,
2896  bool IgnoreAccess) {
2897  // First, determine whether the path from Derived to Base is
2898  // ambiguous. This is slightly more expensive than checking whether
2899  // the Derived to Base conversion exists, because here we need to
2900  // explore multiple paths to determine if there is an ambiguity.
2901  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2902  /*DetectVirtual=*/false);
2903  bool DerivationOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
2904  if (!DerivationOkay)
2905  return true;
2906 
2907  const CXXBasePath *Path = nullptr;
2908  if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType()))
2909  Path = &Paths.front();
2910 
2911  // For MSVC compatibility, check if Derived directly inherits from Base. Clang
2912  // warns about this hierarchy under -Winaccessible-base, but MSVC allows the
2913  // user to access such bases.
2914  if (!Path && getLangOpts().MSVCCompat) {
2915  for (const CXXBasePath &PossiblePath : Paths) {
2916  if (PossiblePath.size() == 1) {
2917  Path = &PossiblePath;
2918  if (AmbiguousBaseConvID)
2919  Diag(Loc, diag::ext_ms_ambiguous_direct_base)
2920  << Base << Derived << Range;
2921  break;
2922  }
2923  }
2924  }
2925 
2926  if (Path) {
2927  if (!IgnoreAccess) {
2928  // Check that the base class can be accessed.
2929  switch (
2930  CheckBaseClassAccess(Loc, Base, Derived, *Path, InaccessibleBaseID)) {
2931  case AR_inaccessible:
2932  return true;
2933  case AR_accessible:
2934  case AR_dependent:
2935  case AR_delayed:
2936  break;
2937  }
2938  }
2939 
2940  // Build a base path if necessary.
2941  if (BasePath)
2942  ::BuildBasePathArray(*Path, *BasePath);
2943  return false;
2944  }
2945 
2946  if (AmbiguousBaseConvID) {
2947  // We know that the derived-to-base conversion is ambiguous, and
2948  // we're going to produce a diagnostic. Perform the derived-to-base
2949  // search just one more time to compute all of the possible paths so
2950  // that we can print them out. This is more expensive than any of
2951  // the previous derived-to-base checks we've done, but at this point
2952  // performance isn't as much of an issue.
2953  Paths.clear();
2954  Paths.setRecordingPaths(true);
2955  bool StillOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
2956  assert(StillOkay && "Can only be used with a derived-to-base conversion");
2957  (void)StillOkay;
2958 
2959  // Build up a textual representation of the ambiguous paths, e.g.,
2960  // D -> B -> A, that will be used to illustrate the ambiguous
2961  // conversions in the diagnostic. We only print one of the paths
2962  // to each base class subobject.
2963  std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
2964 
2965  Diag(Loc, AmbiguousBaseConvID)
2966  << Derived << Base << PathDisplayStr << Range << Name;
2967  }
2968  return true;
2969 }
2970 
2971 bool
2973  SourceLocation Loc, SourceRange Range,
2974  CXXCastPath *BasePath,
2975  bool IgnoreAccess) {
2977  Derived, Base, diag::err_upcast_to_inaccessible_base,
2978  diag::err_ambiguous_derived_to_base_conv, Loc, Range, DeclarationName(),
2979  BasePath, IgnoreAccess);
2980 }
2981 
2982 
2983 /// Builds a string representing ambiguous paths from a
2984 /// specific derived class to different subobjects of the same base
2985 /// class.
2986 ///
2987 /// This function builds a string that can be used in error messages
2988 /// to show the different paths that one can take through the
2989 /// inheritance hierarchy to go from the derived class to different
2990 /// subobjects of a base class. The result looks something like this:
2991 /// @code
2992 /// struct D -> struct B -> struct A
2993 /// struct D -> struct C -> struct A
2994 /// @endcode
2996  std::string PathDisplayStr;
2997  std::set<unsigned> DisplayedPaths;
2998  for (CXXBasePaths::paths_iterator Path = Paths.begin();
2999  Path != Paths.end(); ++Path) {
3000  if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
3001  // We haven't displayed a path to this particular base
3002  // class subobject yet.
3003  PathDisplayStr += "\n ";
3004  PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
3005  for (CXXBasePath::const_iterator Element = Path->begin();
3006  Element != Path->end(); ++Element)
3007  PathDisplayStr += " -> " + Element->Base->getType().getAsString();
3008  }
3009  }
3010 
3011  return PathDisplayStr;
3012 }
3013 
3014 //===----------------------------------------------------------------------===//
3015 // C++ class member Handling
3016 //===----------------------------------------------------------------------===//
3017 
3018 /// ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
3020  SourceLocation ColonLoc,
3021  const ParsedAttributesView &Attrs) {
3022  assert(Access != AS_none && "Invalid kind for syntactic access specifier!");
3024  ASLoc, ColonLoc);
3025  CurContext->addHiddenDecl(ASDecl);
3026  return ProcessAccessDeclAttributeList(ASDecl, Attrs);
3027 }
3028 
3029 /// CheckOverrideControl - Check C++11 override control semantics.
3031  if (D->isInvalidDecl())
3032  return;
3033 
3034  // We only care about "override" and "final" declarations.
3035  if (!D->hasAttr<OverrideAttr>() && !D->hasAttr<FinalAttr>())
3036  return;
3037 
3038  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
3039 
3040  // We can't check dependent instance methods.
3041  if (MD && MD->isInstance() &&
3042  (MD->getParent()->hasAnyDependentBases() ||
3043  MD->getType()->isDependentType()))
3044  return;
3045 
3046  if (MD && !MD->isVirtual()) {
3047  // If we have a non-virtual method, check if if hides a virtual method.
3048  // (In that case, it's most likely the method has the wrong type.)
3049  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
3050  FindHiddenVirtualMethods(MD, OverloadedMethods);
3051 
3052  if (!OverloadedMethods.empty()) {
3053  if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
3054  Diag(OA->getLocation(),
3055  diag::override_keyword_hides_virtual_member_function)
3056  << "override" << (OverloadedMethods.size() > 1);
3057  } else if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
3058  Diag(FA->getLocation(),
3059  diag::override_keyword_hides_virtual_member_function)
3060  << (FA->isSpelledAsSealed() ? "sealed" : "final")
3061  << (OverloadedMethods.size() > 1);
3062  }
3063  NoteHiddenVirtualMethods(MD, OverloadedMethods);
3064  MD->setInvalidDecl();
3065  return;
3066  }
3067  // Fall through into the general case diagnostic.
3068  // FIXME: We might want to attempt typo correction here.
3069  }
3070 
3071  if (!MD || !MD->isVirtual()) {
3072  if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
3073  Diag(OA->getLocation(),
3074  diag::override_keyword_only_allowed_on_virtual_member_functions)
3075  << "override" << FixItHint::CreateRemoval(OA->getLocation());
3076  D->dropAttr<OverrideAttr>();
3077  }
3078  if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
3079  Diag(FA->getLocation(),
3080  diag::override_keyword_only_allowed_on_virtual_member_functions)
3081  << (FA->isSpelledAsSealed() ? "sealed" : "final")
3082  << FixItHint::CreateRemoval(FA->getLocation());
3083  D->dropAttr<FinalAttr>();
3084  }
3085  return;
3086  }
3087 
3088  // C++11 [class.virtual]p5:
3089  // If a function is marked with the virt-specifier override and
3090  // does not override a member function of a base class, the program is
3091  // ill-formed.
3092  bool HasOverriddenMethods = MD->size_overridden_methods() != 0;
3093  if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)
3094  Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding)
3095  << MD->getDeclName();
3096 }
3097 
3099  if (D->isInvalidDecl() || D->hasAttr<OverrideAttr>())
3100  return;
3101  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
3102  if (!MD || MD->isImplicit() || MD->hasAttr<FinalAttr>())
3103  return;
3104 
3105  SourceLocation Loc = MD->getLocation();
3106  SourceLocation SpellingLoc = Loc;
3107  if (getSourceManager().isMacroArgExpansion(Loc))
3108  SpellingLoc = getSourceManager().getImmediateExpansionRange(Loc).getBegin();
3109  SpellingLoc = getSourceManager().getSpellingLoc(SpellingLoc);
3110  if (SpellingLoc.isValid() && getSourceManager().isInSystemHeader(SpellingLoc))
3111  return;
3112 
3113  if (MD->size_overridden_methods() > 0) {
3114  auto EmitDiag = [&](unsigned DiagInconsistent, unsigned DiagSuggest) {
3115  unsigned DiagID =
3116  Inconsistent && !Diags.isIgnored(DiagInconsistent, MD->getLocation())
3117  ? DiagInconsistent
3118  : DiagSuggest;
3119  Diag(MD->getLocation(), DiagID) << MD->getDeclName();
3120  const CXXMethodDecl *OMD = *MD->begin_overridden_methods();
3121  Diag(OMD->getLocation(), diag::note_overridden_virtual_function);
3122  };
3123  if (isa<CXXDestructorDecl>(MD))
3124  EmitDiag(
3125  diag::warn_inconsistent_destructor_marked_not_override_overriding,
3126  diag::warn_suggest_destructor_marked_not_override_overriding);
3127  else
3128  EmitDiag(diag::warn_inconsistent_function_marked_not_override_overriding,
3129  diag::warn_suggest_function_marked_not_override_overriding);
3130  }
3131 }
3132 
3133 /// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member
3134 /// function overrides a virtual member function marked 'final', according to
3135 /// C++11 [class.virtual]p4.
3137  const CXXMethodDecl *Old) {
3138  FinalAttr *FA = Old->getAttr<FinalAttr>();
3139  if (!FA)
3140  return false;
3141 
3142  Diag(New->getLocation(), diag::err_final_function_overridden)
3143  << New->getDeclName()
3144  << FA->isSpelledAsSealed();
3145  Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3146  return true;
3147 }
3148 
3149 static bool InitializationHasSideEffects(const FieldDecl &FD) {
3150  const Type *T = FD.getType()->getBaseElementTypeUnsafe();
3151  // FIXME: Destruction of ObjC lifetime types has side-effects.
3152  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3153  return !RD->isCompleteDefinition() ||
3154  !RD->hasTrivialDefaultConstructor() ||
3155  !RD->hasTrivialDestructor();
3156  return false;
3157 }
3158 
3161  llvm::find_if(list, [](const ParsedAttr &AL) {
3162  return AL.isDeclspecPropertyAttribute();
3163  });
3164  if (Itr != list.end())
3165  return &*Itr;
3166  return nullptr;
3167 }
3168 
3169 // Check if there is a field shadowing.
3170 void Sema::CheckShadowInheritedFields(const SourceLocation &Loc,
3171  DeclarationName FieldName,
3172  const CXXRecordDecl *RD,
3173  bool DeclIsField) {
3174  if (Diags.isIgnored(diag::warn_shadow_field, Loc))
3175  return;
3176 
3177  // To record a shadowed field in a base
3178  std::map<CXXRecordDecl*, NamedDecl*> Bases;
3179  auto FieldShadowed = [&](const CXXBaseSpecifier *Specifier,
3180  CXXBasePath &Path) {
3181  const auto Base = Specifier->getType()->getAsCXXRecordDecl();
3182  // Record an ambiguous path directly
3183  if (Bases.find(Base) != Bases.end())
3184  return true;
3185  for (const auto Field : Base->lookup(FieldName)) {
3186  if ((isa<FieldDecl>(Field) || isa<IndirectFieldDecl>(Field)) &&
3187  Field->getAccess() != AS_private) {
3188  assert(Field->getAccess() != AS_none);
3189  assert(Bases.find(Base) == Bases.end());
3190  Bases[Base] = Field;
3191  return true;
3192  }
3193  }
3194  return false;
3195  };
3196 
3197  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3198  /*DetectVirtual=*/true);
3199  if (!RD->lookupInBases(FieldShadowed, Paths))
3200  return;
3201 
3202  for (const auto &P : Paths) {
3203  auto Base = P.back().Base->getType()->getAsCXXRecordDecl();
3204  auto It = Bases.find(Base);
3205  // Skip duplicated bases
3206  if (It == Bases.end())
3207  continue;
3208  auto BaseField = It->second;
3209  assert(BaseField->getAccess() != AS_private);
3210  if (AS_none !=
3211  CXXRecordDecl::MergeAccess(P.Access, BaseField->getAccess())) {
3212  Diag(Loc, diag::warn_shadow_field)
3213  << FieldName << RD << Base << DeclIsField;
3214  Diag(BaseField->getLocation(), diag::note_shadow_field);
3215  Bases.erase(It);
3216  }
3217  }
3218 }
3219 
3220 /// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
3221 /// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
3222 /// bitfield width if there is one, 'InitExpr' specifies the initializer if
3223 /// one has been parsed, and 'InitStyle' is set if an in-class initializer is
3224 /// present (but parsing it has been deferred).
3225 NamedDecl *
3227  MultiTemplateParamsArg TemplateParameterLists,
3228  Expr *BW, const VirtSpecifiers &VS,
3229  InClassInitStyle InitStyle) {
3230  const DeclSpec &DS = D.getDeclSpec();
3232  DeclarationName Name = NameInfo.getName();
3233  SourceLocation Loc = NameInfo.getLoc();
3234 
3235  // For anonymous bitfields, the location should point to the type.
3236  if (Loc.isInvalid())
3237  Loc = D.getBeginLoc();
3238 
3239  Expr *BitWidth = static_cast<Expr*>(BW);
3240 
3241  assert(isa<CXXRecordDecl>(CurContext));
3242  assert(!DS.isFriendSpecified());
3243 
3244  bool isFunc = D.isDeclarationOfFunction();
3245  const ParsedAttr *MSPropertyAttr =
3247 
3248  if (cast<CXXRecordDecl>(CurContext)->isInterface()) {
3249  // The Microsoft extension __interface only permits public member functions
3250  // and prohibits constructors, destructors, operators, non-public member
3251  // functions, static methods and data members.
3252  unsigned InvalidDecl;
3253  bool ShowDeclName = true;
3254  if (!isFunc &&
3255  (DS.getStorageClassSpec() == DeclSpec::SCS_typedef || MSPropertyAttr))
3256  InvalidDecl = 0;
3257  else if (!isFunc)
3258  InvalidDecl = 1;
3259  else if (AS != AS_public)
3260  InvalidDecl = 2;
3261  else if (DS.getStorageClassSpec() == DeclSpec::SCS_static)
3262  InvalidDecl = 3;
3263  else switch (Name.getNameKind()) {
3265  InvalidDecl = 4;
3266  ShowDeclName = false;
3267  break;
3268 
3270  InvalidDecl = 5;
3271  ShowDeclName = false;
3272  break;
3273 
3276  InvalidDecl = 6;
3277  break;
3278 
3279  default:
3280  InvalidDecl = 0;
3281  break;
3282  }
3283 
3284  if (InvalidDecl) {
3285  if (ShowDeclName)
3286  Diag(Loc, diag::err_invalid_member_in_interface)
3287  << (InvalidDecl-1) << Name;
3288  else
3289  Diag(Loc, diag::err_invalid_member_in_interface)
3290  << (InvalidDecl-1) << "";
3291  return nullptr;
3292  }
3293  }
3294 
3295  // C++ 9.2p6: A member shall not be declared to have automatic storage
3296  // duration (auto, register) or with the extern storage-class-specifier.
3297  // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
3298  // data members and cannot be applied to names declared const or static,
3299  // and cannot be applied to reference members.
3300  switch (DS.getStorageClassSpec()) {
3302  case DeclSpec::SCS_typedef:
3303  case DeclSpec::SCS_static:
3304  break;
3305  case DeclSpec::SCS_mutable:
3306  if (isFunc) {
3307  Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
3308 
3309  // FIXME: It would be nicer if the keyword was ignored only for this
3310  // declarator. Otherwise we could get follow-up errors.
3312  }
3313  break;
3314  default:
3316  diag::err_storageclass_invalid_for_member);
3318  break;
3319  }
3320 
3321  bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
3323  !isFunc);
3324 
3325  if (DS.hasConstexprSpecifier() && isInstField) {
3327  Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr_member);
3328  SourceLocation ConstexprLoc = DS.getConstexprSpecLoc();
3329  if (InitStyle == ICIS_NoInit) {
3330  B << 0 << 0;
3332  B << FixItHint::CreateRemoval(ConstexprLoc);
3333  else {
3334  B << FixItHint::CreateReplacement(ConstexprLoc, "const");
3336  const char *PrevSpec;
3337  unsigned DiagID;
3338  bool Failed = D.getMutableDeclSpec().SetTypeQual(
3339  DeclSpec::TQ_const, ConstexprLoc, PrevSpec, DiagID, getLangOpts());
3340  (void)Failed;
3341  assert(!Failed && "Making a constexpr member const shouldn't fail");
3342  }
3343  } else {
3344  B << 1;
3345  const char *PrevSpec;
3346  unsigned DiagID;
3348  *this, DeclSpec::SCS_static, ConstexprLoc, PrevSpec, DiagID,
3350  assert(DS.getStorageClassSpec() == DeclSpec::SCS_mutable &&
3351  "This is the only DeclSpec that should fail to be applied");
3352  B << 1;
3353  } else {
3354  B << 0 << FixItHint::CreateInsertion(ConstexprLoc, "static ");
3355  isInstField = false;
3356  }
3357  }
3358  }
3359 
3360  NamedDecl *Member;
3361  if (isInstField) {
3362  CXXScopeSpec &SS = D.getCXXScopeSpec();
3363 
3364  // Data members must have identifiers for names.
3365  if (!Name.isIdentifier()) {
3366  Diag(Loc, diag::err_bad_variable_name)
3367  << Name;
3368  return nullptr;
3369  }
3370 
3371  IdentifierInfo *II = Name.getAsIdentifierInfo();
3372 
3373  // Member field could not be with "template" keyword.
3374  // So TemplateParameterLists should be empty in this case.
3375  if (TemplateParameterLists.size()) {
3376  TemplateParameterList* TemplateParams = TemplateParameterLists[0];
3377  if (TemplateParams->size()) {
3378  // There is no such thing as a member field template.
3379  Diag(D.getIdentifierLoc(), diag::err_template_member)
3380  << II
3381  << SourceRange(TemplateParams->getTemplateLoc(),
3382  TemplateParams->getRAngleLoc());
3383  } else {
3384  // There is an extraneous 'template<>' for this member.
3385  Diag(TemplateParams->getTemplateLoc(),
3386  diag::err_template_member_noparams)
3387  << II
3388  << SourceRange(TemplateParams->getTemplateLoc(),
3389  TemplateParams->getRAngleLoc());
3390  }
3391  return nullptr;
3392  }
3393 
3394  if (SS.isSet() && !SS.isInvalid()) {
3395  // The user provided a superfluous scope specifier inside a class
3396  // definition:
3397  //
3398  // class X {
3399  // int X::member;
3400  // };
3401  if (DeclContext *DC = computeDeclContext(SS, false))
3403  D.getName().getKind() ==
3405  else
3406  Diag(D.getIdentifierLoc(), diag::err_member_qualification)
3407  << Name << SS.getRange();
3408 
3409  SS.clear();
3410  }
3411 
3412  if (MSPropertyAttr) {
3413  Member = HandleMSProperty(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3414  BitWidth, InitStyle, AS, *MSPropertyAttr);
3415  if (!Member)
3416  return nullptr;
3417  isInstField = false;
3418  } else {
3419  Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3420  BitWidth, InitStyle, AS);
3421  if (!Member)
3422  return nullptr;
3423  }
3424 
3425  CheckShadowInheritedFields(Loc, Name, cast<CXXRecordDecl>(CurContext));
3426  } else {
3427  Member = HandleDeclarator(S, D, TemplateParameterLists);
3428  if (!Member)
3429  return nullptr;
3430 
3431  // Non-instance-fields can't have a bitfield.
3432  if (BitWidth) {
3433  if (Member->isInvalidDecl()) {
3434  // don't emit another diagnostic.
3435  } else if (isa<VarDecl>(Member) || isa<VarTemplateDecl>(Member)) {
3436  // C++ 9.6p3: A bit-field shall not be a static member.
3437  // "static member 'A' cannot be a bit-field"
3438  Diag(Loc, diag::err_static_not_bitfield)
3439  << Name << BitWidth->getSourceRange();
3440  } else if (isa<TypedefDecl>(Member)) {
3441  // "typedef member 'x' cannot be a bit-field"
3442  Diag(Loc, diag::err_typedef_not_bitfield)
3443  << Name << BitWidth->getSourceRange();
3444  } else {
3445  // A function typedef ("typedef int f(); f a;").
3446  // C++ 9.6p3: A bit-field shall have integral or enumeration type.
3447  Diag(Loc, diag::err_not_integral_type_bitfield)
3448  << Name << cast<ValueDecl>(Member)->getType()
3449  << BitWidth->getSourceRange();
3450  }
3451 
3452  BitWidth = nullptr;
3453  Member->setInvalidDecl();
3454  }
3455 
3456  NamedDecl *NonTemplateMember = Member;
3457  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
3458  NonTemplateMember = FunTmpl->getTemplatedDecl();
3459  else if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(Member))
3460  NonTemplateMember = VarTmpl->getTemplatedDecl();
3461 
3462  Member->setAccess(AS);
3463 
3464  // If we have declared a member function template or static data member
3465  // template, set the access of the templated declaration as well.
3466  if (NonTemplateMember != Member)
3467  NonTemplateMember->setAccess(AS);
3468 
3469  // C++ [temp.deduct.guide]p3:
3470  // A deduction guide [...] for a member class template [shall be
3471  // declared] with the same access [as the template].
3472  if (auto *DG = dyn_cast<CXXDeductionGuideDecl>(NonTemplateMember)) {
3473  auto *TD = DG->getDeducedTemplate();
3474  // Access specifiers are only meaningful if both the template and the
3475  // deduction guide are from the same scope.
3476  if (AS != TD->getAccess() &&
3477  TD->getDeclContext()->getRedeclContext()->Equals(
3478  DG->getDeclContext()->getRedeclContext())) {
3479  Diag(DG->getBeginLoc(), diag::err_deduction_guide_wrong_access);
3480  Diag(TD->getBeginLoc(), diag::note_deduction_guide_template_access)
3481  << TD->getAccess();
3482  const AccessSpecDecl *LastAccessSpec = nullptr;
3483  for (const auto *D : cast<CXXRecordDecl>(CurContext)->decls()) {
3484  if (const auto *AccessSpec = dyn_cast<AccessSpecDecl>(D))
3485  LastAccessSpec = AccessSpec;
3486  }
3487  assert(LastAccessSpec && "differing access with no access specifier");
3488  Diag(LastAccessSpec->getBeginLoc(), diag::note_deduction_guide_access)
3489  << AS;
3490  }
3491  }
3492  }
3493 
3494  if (VS.isOverrideSpecified())
3495  Member->addAttr(OverrideAttr::Create(Context, VS.getOverrideLoc(),
3497  if (VS.isFinalSpecified())
3498  Member->addAttr(FinalAttr::Create(
3500  static_cast<FinalAttr::Spelling>(VS.isFinalSpelledSealed())));
3501 
3502  if (VS.getLastLocation().isValid()) {
3503  // Update the end location of a method that has a virt-specifiers.
3504  if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member))
3505  MD->setRangeEnd(VS.getLastLocation());
3506  }
3507 
3509 
3510  assert((Name || isInstField) && "No identifier for non-field ?");
3511 
3512  if (isInstField) {
3513  FieldDecl *FD = cast<FieldDecl>(Member);
3514  FieldCollector->Add(FD);
3515 
3516  if (!Diags.isIgnored(diag::warn_unused_private_field, FD->getLocation())) {
3517  // Remember all explicit private FieldDecls that have a name, no side
3518  // effects and are not part of a dependent type declaration.
3519  if (!FD->isImplicit() && FD->getDeclName() &&
3520  FD->getAccess() == AS_private &&
3521  !FD->hasAttr<UnusedAttr>() &&
3522  !FD->getParent()->isDependentContext() &&
3524  UnusedPrivateFields.insert(FD);
3525  }
3526  }
3527 
3528  return Member;
3529 }
3530 
3531 namespace {
3532  class UninitializedFieldVisitor
3533  : public EvaluatedExprVisitor<UninitializedFieldVisitor> {
3534  Sema &S;
3535  // List of Decls to generate a warning on. Also remove Decls that become
3536  // initialized.
3537  llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
3538  // List of base classes of the record. Classes are removed after their
3539  // initializers.
3540  llvm::SmallPtrSetImpl<QualType> &BaseClasses;
3541  // Vector of decls to be removed from the Decl set prior to visiting the
3542  // nodes. These Decls may have been initialized in the prior initializer.
3543  llvm::SmallVector<ValueDecl*, 4> DeclsToRemove;
3544  // If non-null, add a note to the warning pointing back to the constructor.
3545  const CXXConstructorDecl *Constructor;
3546  // Variables to hold state when processing an initializer list. When
3547  // InitList is true, special case initialization of FieldDecls matching
3548  // InitListFieldDecl.
3549  bool InitList;
3550  FieldDecl *InitListFieldDecl;
3551  llvm::SmallVector<unsigned, 4> InitFieldIndex;
3552 
3553  public:
3555  UninitializedFieldVisitor(Sema &S,
3556  llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
3557  llvm::SmallPtrSetImpl<QualType> &BaseClasses)
3558  : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
3559  Constructor(nullptr), InitList(false), InitListFieldDecl(nullptr) {}
3560 
3561  // Returns true if the use of ME is not an uninitialized use.
3562  bool IsInitListMemberExprInitialized(MemberExpr *ME,
3563  bool CheckReferenceOnly) {
3565  bool ReferenceField = false;
3566  while (ME) {
3567  FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
3568  if (!FD)
3569  return false;
3570  Fields.push_back(FD);
3571  if (FD->getType()->isReferenceType())
3572  ReferenceField = true;
3573  ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParenImpCasts());
3574  }
3575 
3576  // Binding a reference to an uninitialized field is not an
3577  // uninitialized use.
3578  if (CheckReferenceOnly && !ReferenceField)
3579  return true;
3580 
3581  llvm::SmallVector<unsigned, 4> UsedFieldIndex;
3582  // Discard the first field since it is the field decl that is being
3583  // initialized.
3584  for (auto I = Fields.rbegin() + 1, E = Fields.rend(); I != E; ++I) {
3585  UsedFieldIndex.push_back((*I)->getFieldIndex());
3586  }
3587 
3588  for (auto UsedIter = UsedFieldIndex.begin(),
3589  UsedEnd = UsedFieldIndex.end(),
3590  OrigIter = InitFieldIndex.begin(),
3591  OrigEnd = InitFieldIndex.end();
3592  UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
3593  if (*UsedIter < *OrigIter)
3594  return true;
3595  if (*UsedIter > *OrigIter)
3596  break;
3597  }
3598 
3599  return false;
3600  }
3601 
3602  void HandleMemberExpr(MemberExpr *ME, bool CheckReferenceOnly,
3603  bool AddressOf) {
3604  if (isa<EnumConstantDecl>(ME->getMemberDecl()))
3605  return;
3606 
3607  // FieldME is the inner-most MemberExpr that is not an anonymous struct
3608  // or union.
3609  MemberExpr *FieldME = ME;
3610 
3611  bool AllPODFields = FieldME->getType().isPODType(S.Context);
3612 
3613  Expr *Base = ME;
3614  while (MemberExpr *SubME =
3615  dyn_cast<MemberExpr>(Base->IgnoreParenImpCasts())) {
3616 
3617  if (isa<VarDecl>(SubME->getMemberDecl()))
3618  return;
3619 
3620  if (FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
3621  if (!FD->isAnonymousStructOrUnion())
3622  FieldME = SubME;
3623 
3624  if (!FieldME->getType().isPODType(S.Context))
3625  AllPODFields = false;
3626 
3627  Base = SubME->getBase();
3628  }
3629 
3630  if (!isa<CXXThisExpr>(Base->IgnoreParenImpCasts())) {
3631  Visit(Base);
3632  return;
3633  }
3634 
3635  if (AddressOf && AllPODFields)
3636  return;
3637 
3638  ValueDecl* FoundVD = FieldME->getMemberDecl();
3639 
3640  if (ImplicitCastExpr *BaseCast = dyn_cast<ImplicitCastExpr>(Base)) {
3641  while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
3642  BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
3643  }
3644 
3645  if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
3646  QualType T = BaseCast->getType();
3647  if (T->isPointerType() &&
3648  BaseClasses.count(T->getPointeeType())) {
3649  S.Diag(FieldME->getExprLoc(), diag::warn_base_class_is_uninit)
3650  << T->getPointeeType() << FoundVD;
3651  }
3652  }
3653  }
3654 
3655  if (!Decls.count(FoundVD))
3656  return;
3657 
3658  const bool IsReference = FoundVD->getType()->isReferenceType();
3659 
3660  if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
3661  // Special checking for initializer lists.
3662  if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
3663  return;
3664  }
3665  } else {
3666  // Prevent double warnings on use of unbounded references.
3667  if (CheckReferenceOnly && !IsReference)
3668  return;
3669  }
3670 
3671  unsigned diag = IsReference
3672  ? diag::warn_reference_field_is_uninit
3673  : diag::warn_field_is_uninit;
3674  S.Diag(FieldME->getExprLoc(), diag) << FoundVD;
3675  if (Constructor)
3676  S.Diag(Constructor->getLocation(),
3677  diag::note_uninit_in_this_constructor)
3678  << (Constructor->isDefaultConstructor() && Constructor->isImplicit());
3679 
3680  }
3681 
3682  void HandleValue(Expr *E, bool AddressOf) {
3683  E = E->IgnoreParens();
3684 
3685  if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
3686  HandleMemberExpr(ME, false /*CheckReferenceOnly*/,
3687  AddressOf /*AddressOf*/);
3688  return;
3689  }
3690 
3691  if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
3692  Visit(CO->getCond());
3693  HandleValue(CO->getTrueExpr(), AddressOf);
3694  HandleValue(CO->getFalseExpr(), AddressOf);
3695  return;
3696  }
3697 
3698  if (BinaryConditionalOperator *BCO =
3699  dyn_cast<BinaryConditionalOperator>(E)) {
3700  Visit(BCO->getCond());
3701  HandleValue(BCO->getFalseExpr(), AddressOf);
3702  return;
3703  }
3704 
3705  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
3706  HandleValue(OVE->getSourceExpr(), AddressOf);
3707  return;
3708  }
3709 
3710  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
3711  switch (BO->getOpcode()) {
3712  default:
3713  break;
3714  case(BO_PtrMemD):
3715  case(BO_PtrMemI):
3716  HandleValue(BO->getLHS(), AddressOf);
3717  Visit(BO->getRHS());
3718  return;
3719  case(BO_Comma):
3720  Visit(BO->getLHS());
3721  HandleValue(BO->getRHS(), AddressOf);
3722  return;
3723  }
3724  }
3725 
3726  Visit(E);
3727  }
3728 
3729  void CheckInitListExpr(InitListExpr *ILE) {
3730  InitFieldIndex.push_back(0);
3731  for (auto Child : ILE->children()) {
3732  if (InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
3733  CheckInitListExpr(SubList);
3734  } else {
3735  Visit(Child);
3736  }
3737  ++InitFieldIndex.back();
3738  }
3739  InitFieldIndex.pop_back();
3740  }
3741 
3742  void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor,
3743  FieldDecl *Field, const Type *BaseClass) {
3744  // Remove Decls that may have been initialized in the previous
3745  // initializer.
3746  for (ValueDecl* VD : DeclsToRemove)
3747  Decls.erase(VD);
3748  DeclsToRemove.clear();
3749 
3750  Constructor = FieldConstructor;
3751  InitListExpr *ILE = dyn_cast<InitListExpr>(E);
3752 
3753  if (ILE && Field) {
3754  InitList = true;
3755  InitListFieldDecl = Field;
3756  InitFieldIndex.clear();
3757  CheckInitListExpr(ILE);
3758  } else {
3759  InitList = false;
3760  Visit(E);
3761  }
3762 
3763  if (Field)
3764  Decls.erase(Field);
3765  if (BaseClass)
3766  BaseClasses.erase(BaseClass->getCanonicalTypeInternal());
3767  }
3768 
3769  void VisitMemberExpr(MemberExpr *ME) {
3770  // All uses of unbounded reference fields will warn.
3771  HandleMemberExpr(ME, true /*CheckReferenceOnly*/, false /*AddressOf*/);
3772  }
3773 
3774  void VisitImplicitCastExpr(ImplicitCastExpr *E) {
3775  if (E->getCastKind() == CK_LValueToRValue) {
3776  HandleValue(E->getSubExpr(), false /*AddressOf*/);
3777  return;
3778  }
3779 
3780  Inherited::VisitImplicitCastExpr(E);
3781  }
3782 
3783  void VisitCXXConstructExpr(CXXConstructExpr *E) {
3784  if (E->getConstructor()->isCopyConstructor()) {
3785  Expr *ArgExpr = E->getArg(0);
3786  if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
3787  if (ILE->getNumInits() == 1)
3788  ArgExpr = ILE->getInit(0);
3789  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
3790  if (ICE->getCastKind() == CK_NoOp)
3791  ArgExpr = ICE->getSubExpr();
3792  HandleValue(ArgExpr, false /*AddressOf*/);
3793  return;
3794  }
3795  Inherited::VisitCXXConstructExpr(E);
3796  }
3797 
3798  void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
3799  Expr *Callee = E->getCallee();
3800  if (isa<MemberExpr>(Callee)) {
3801  HandleValue(Callee, false /*AddressOf*/);
3802  for (auto Arg : E->arguments())
3803  Visit(Arg);
3804  return;
3805  }
3806 
3807  Inherited::VisitCXXMemberCallExpr(E);
3808  }
3809 
3810  void VisitCallExpr(CallExpr *E) {
3811  // Treat std::move as a use.
3812  if (E->isCallToStdMove()) {
3813  HandleValue(E->getArg(0), /*AddressOf=*/false);
3814  return;
3815  }
3816 
3817  Inherited::VisitCallExpr(E);
3818  }
3819 
3820  void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
3821  Expr *Callee = E->getCallee();
3822 
3823  if (isa<UnresolvedLookupExpr>(Callee))
3824  return Inherited::VisitCXXOperatorCallExpr(E);
3825 
3826  Visit(Callee);
3827  for (auto Arg : E->arguments())
3828  HandleValue(Arg->IgnoreParenImpCasts(), false /*AddressOf*/);
3829  }
3830 
3831  void VisitBinaryOperator(BinaryOperator *E) {
3832  // If a field assignment is detected, remove the field from the
3833  // uninitiailized field set.
3834  if (E->getOpcode() == BO_Assign)
3835  if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getLHS()))
3836  if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
3837  if (!FD->getType()->isReferenceType())
3838  DeclsToRemove.push_back(FD);
3839 
3840  if (E->isCompoundAssignmentOp()) {
3841  HandleValue(E->getLHS(), false /*AddressOf*/);
3842  Visit(E->getRHS());
3843  return;
3844  }
3845 
3846  Inherited::VisitBinaryOperator(E);
3847  }
3848 
3849  void VisitUnaryOperator(UnaryOperator *E) {
3850  if (E->isIncrementDecrementOp()) {
3851  HandleValue(E->getSubExpr(), false /*AddressOf*/);
3852  return;
3853  }
3854  if (E->getOpcode() == UO_AddrOf) {
3855  if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getSubExpr())) {
3856  HandleValue(ME->getBase(), true /*AddressOf*/);
3857  return;
3858  }
3859  }
3860 
3861  Inherited::VisitUnaryOperator(E);
3862  }
3863  };
3864 
3865  // Diagnose value-uses of fields to initialize themselves, e.g.
3866  // foo(foo)
3867  // where foo is not also a parameter to the constructor.
3868  // Also diagnose across field uninitialized use such as
3869  // x(y), y(x)
3870  // TODO: implement -Wuninitialized and fold this into that framework.
3871  static void DiagnoseUninitializedFields(
3872  Sema &SemaRef, const CXXConstructorDecl *Constructor) {
3873 
3874  if (SemaRef.getDiagnostics().isIgnored(diag::warn_field_is_uninit,
3875  Constructor->getLocation())) {
3876  return;
3877  }
3878 
3879  if (Constructor->isInvalidDecl())
3880  return;
3881 
3882  const CXXRecordDecl *RD = Constructor->getParent();
3883 
3884  if (RD->isDependentContext())
3885  return;
3886 
3887  // Holds fields that are uninitialized.
3888  llvm::SmallPtrSet<ValueDecl*, 4> UninitializedFields;
3889 
3890  // At the beginning, all fields are uninitialized.
3891  for (auto *I : RD->decls()) {
3892  if (auto *FD = dyn_cast<FieldDecl>(I)) {
3893  UninitializedFields.insert(FD);
3894  } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
3895  UninitializedFields.insert(IFD->getAnonField());
3896  }
3897  }
3898 
3899  llvm::SmallPtrSet<QualType, 4> UninitializedBaseClasses;
3900  for (auto I : RD->bases())
3901  UninitializedBaseClasses.insert(I.getType().getCanonicalType());
3902 
3903  if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
3904  return;
3905 
3906  UninitializedFieldVisitor UninitializedChecker(SemaRef,
3907  UninitializedFields,
3908  UninitializedBaseClasses);
3909 
3910  for (const auto *FieldInit : Constructor->inits()) {
3911  if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
3912  break;
3913 
3914  Expr *InitExpr = FieldInit->getInit();
3915  if (!InitExpr)
3916  continue;
3917 
3918  if (CXXDefaultInitExpr *Default =
3919  dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
3920  InitExpr = Default->getExpr();
3921  if (!InitExpr)
3922  continue;
3923  // In class initializers will point to the constructor.
3924  UninitializedChecker.CheckInitializer(InitExpr, Constructor,
3925  FieldInit->getAnyMember(),
3926  FieldInit->getBaseClass());
3927  } else {
3928  UninitializedChecker.CheckInitializer(InitExpr, nullptr,
3929  FieldInit->getAnyMember(),
3930  FieldInit->getBaseClass());
3931  }
3932  }
3933  }
3934 } // namespace
3935 
3936 /// Enter a new C++ default initializer scope. After calling this, the
3937 /// caller must call \ref ActOnFinishCXXInClassMemberInitializer, even if
3938 /// parsing or instantiating the initializer failed.
3940  // Create a synthetic function scope to represent the call to the constructor
3941  // that notionally surrounds a use of this initializer.
3943 }
3944 
3946  if (!D.isFunctionDeclarator())
3947  return;
3948  auto &FTI = D.getFunctionTypeInfo();
3949  if (!FTI.Params)
3950  return;
3951  for (auto &Param : ArrayRef<DeclaratorChunk::ParamInfo>(FTI.Params,
3952  FTI.NumParams)) {
3953  auto *ParamDecl = cast<NamedDecl>(Param.Param);
3954  if (ParamDecl->getDeclName())
3955  PushOnScopeChains(ParamDecl, S, /*AddToContext=*/false);
3956  }
3957 }
3958 
3960  return ActOnRequiresClause(ConstraintExpr);
3961 }
3962 
3964  if (ConstraintExpr.isInvalid())
3965  return ExprError();
3966 
3967  ConstraintExpr = CorrectDelayedTyposInExpr(ConstraintExpr);
3968  if (ConstraintExpr.isInvalid())
3969  return ExprError();
3970 
3971  if (DiagnoseUnexpandedParameterPack(ConstraintExpr.get(),
3973  return ExprError();
3974 
3975  return ConstraintExpr;
3976 }
3977 
3978 /// This is invoked after parsing an in-class initializer for a
3979 /// non-static C++ class member, and after instantiating an in-class initializer
3980 /// in a class template. Such actions are deferred until the class is complete.
3982  SourceLocation InitLoc,
3983  Expr *InitExpr) {
3984  // Pop the notional constructor scope we created earlier.
3985  PopFunctionScopeInfo(nullptr, D);
3986 
3987  FieldDecl *FD = dyn_cast<FieldDecl>(D);
3988  assert((isa<MSPropertyDecl>(D) || FD->getInClassInitStyle() != ICIS_NoInit) &&
3989  "must set init style when field is created");
3990 
3991  if (!InitExpr) {
3992  D->setInvalidDecl();
3993  if (FD)
3995  return;
3996  }
3997 
3999  FD->setInvalidDecl();
4001  return;
4002  }
4003 
4004  ExprResult Init = InitExpr;
4005  if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent()) {
4006  InitializedEntity Entity =
4011  InitExpr->getBeginLoc(),
4012  InitExpr->getEndLoc())
4013  : InitializationKind::CreateCopy(InitExpr->getBeginLoc(), InitLoc);
4014  InitializationSequence Seq(*this, Entity, Kind, InitExpr);
4015  Init = Seq.Perform(*this, Entity, Kind, InitExpr);
4016  if (Init.isInvalid()) {
4017  FD->setInvalidDecl();
4018  return;
4019  }
4020  }
4021 
4022  // C++11 [class.base.init]p7:
4023  // The initialization of each base and member constitutes a
4024  // full-expression.
4025  Init = ActOnFinishFullExpr(Init.get(), InitLoc, /*DiscardedValue*/ false);
4026  if (Init.isInvalid()) {
4027  FD->setInvalidDecl();
4028  return;
4029  }
4030 
4031  InitExpr = Init.get();
4032 
4033  FD->setInClassInitializer(InitExpr);
4034 }
4035 
4036 /// Find the direct and/or virtual base specifiers that
4037 /// correspond to the given base type, for use in base initialization
4038 /// within a constructor.
4039 static bool FindBaseInitializer(Sema &SemaRef,
4040  CXXRecordDecl *ClassDecl,
4041  QualType BaseType,
4042  const CXXBaseSpecifier *&DirectBaseSpec,
4043  const CXXBaseSpecifier *&VirtualBaseSpec) {
4044  // First, check for a direct base class.
4045  DirectBaseSpec = nullptr;
4046  for (const auto &Base : ClassDecl->bases()) {
4047  if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base.getType())) {
4048  // We found a direct base of this type. That's what we're
4049  // initializing.
4050  DirectBaseSpec = &Base;
4051  break;
4052  }
4053  }
4054 
4055  // Check for a virtual base class.
4056  // FIXME: We might be able to short-circuit this if we know in advance that
4057  // there are no virtual bases.
4058  VirtualBaseSpec = nullptr;
4059  if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
4060  // We haven't found a base yet; search the class hierarchy for a
4061  // virtual base class.
4062  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
4063  /*DetectVirtual=*/false);
4064  if (SemaRef.IsDerivedFrom(ClassDecl->getLocation(),
4065  SemaRef.Context.getTypeDeclType(ClassDecl),
4066  BaseType, Paths)) {
4067  for (CXXBasePaths::paths_iterator Path = Paths.begin();
4068  Path != Paths.end(); ++Path) {
4069  if (Path->back().Base->isVirtual()) {
4070  VirtualBaseSpec = Path->back().Base;
4071  break;
4072  }
4073  }
4074  }
4075  }
4076 
4077  return DirectBaseSpec || VirtualBaseSpec;
4078 }
4079 
4080 /// Handle a C++ member initializer using braced-init-list syntax.
4083  Scope *S,
4084  CXXScopeSpec &SS,
4085  IdentifierInfo *MemberOrBase,
4086  ParsedType TemplateTypeTy,
4087  const DeclSpec &DS,
4088  SourceLocation IdLoc,
4089  Expr *InitList,
4090  SourceLocation EllipsisLoc) {
4091  return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
4092  DS, IdLoc, InitList,
4093  EllipsisLoc);
4094 }
4095 
4096 /// Handle a C++ member initializer using parentheses syntax.
4099  Scope *S,
4100  CXXScopeSpec &SS,
4101  IdentifierInfo *MemberOrBase,
4102  ParsedType TemplateTypeTy,
4103  const DeclSpec &DS,
4104  SourceLocation IdLoc,
4105  SourceLocation LParenLoc,
4106  ArrayRef<Expr *> Args,
4107  SourceLocation RParenLoc,
4108  SourceLocation EllipsisLoc) {
4109  Expr *List = ParenListExpr::Create(Context, LParenLoc, Args, RParenLoc);
4110  return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
4111  DS, IdLoc, List, EllipsisLoc);
4112 }
4113 
4114 namespace {
4115 
4116 // Callback to only accept typo corrections that can be a valid C++ member
4117 // initializer: either a non-static field member or a base class.
4118 class MemInitializerValidatorCCC final : public CorrectionCandidateCallback {
4119 public:
4120  explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl)
4121  : ClassDecl(ClassDecl) {}
4122 
4123  bool ValidateCandidate(const TypoCorrection &candidate) override {
4124  if (NamedDecl *ND = candidate.getCorrectionDecl()) {
4125  if (FieldDecl *Member = dyn_cast<FieldDecl>(ND))
4126  return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
4127  return isa<TypeDecl>(ND);
4128  }
4129  return false;
4130  }
4131 
4132  std::unique_ptr<CorrectionCandidateCallback> clone() override {
4133  return std::make_unique<MemInitializerValidatorCCC>(*this);
4134  }
4135 
4136 private:
4137  CXXRecordDecl *ClassDecl;
4138 };
4139 
4140 }
4141 
4142 ValueDecl *Sema::tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl,
4143  CXXScopeSpec &SS,
4144  ParsedType TemplateTypeTy,
4145  IdentifierInfo *MemberOrBase) {
4146  if (SS.getScopeRep() || TemplateTypeTy)
4147  return nullptr;
4148  for (auto *D : ClassDecl->lookup(MemberOrBase))
4149  if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D))
4150  return cast<ValueDecl>(D);
4151  return nullptr;
4152 }
4153 
4154 /// Handle a C++ member initializer.
4157  Scope *S,
4158  CXXScopeSpec &SS,
4159  IdentifierInfo *MemberOrBase,
4160  ParsedType TemplateTypeTy,
4161  const DeclSpec &DS,
4162  SourceLocation IdLoc,
4163  Expr *Init,
4164  SourceLocation EllipsisLoc) {
4165  ExprResult Res = CorrectDelayedTyposInExpr(Init, /*InitDecl=*/nullptr,
4166  /*RecoverUncorrectedTypos=*/true);
4167  if (!Res.isUsable())
4168  return true;
4169  Init = Res.get();
4170 
4171  if (!ConstructorD)
4172  return true;
4173 
4174  AdjustDeclIfTemplate(ConstructorD);
4175 
4176  CXXConstructorDecl *Constructor
4177  = dyn_cast<CXXConstructorDecl>(ConstructorD);
4178  if (!Constructor) {
4179  // The user wrote a constructor initializer on a function that is
4180  // not a C++ constructor. Ignore the error for now, because we may
4181  // have more member initializers coming; we'll diagnose it just
4182  // once in ActOnMemInitializers.
4183  return true;
4184  }
4185 
4186  CXXRecordDecl *ClassDecl = Constructor->getParent();
4187 
4188  // C++ [class.base.init]p2:
4189  // Names in a mem-initializer-id are looked up in the scope of the
4190  // constructor's class and, if not found in that scope, are looked
4191  // up in the scope containing the constructor's definition.
4192  // [Note: if the constructor's class contains a member with the
4193  // same name as a direct or virtual base class of the class, a
4194  // mem-initializer-id naming the member or base class and composed
4195  // of a single identifier refers to the class member. A
4196  // mem-initializer-id for the hidden base class may be specified
4197  // using a qualified name. ]
4198 
4199  // Look for a member, first.
4200  if (ValueDecl *Member = tryLookupCtorInitMemberDecl(
4201  ClassDecl, SS, TemplateTypeTy, MemberOrBase)) {
4202  if (EllipsisLoc.isValid())
4203  Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
4204  << MemberOrBase
4205  << SourceRange(IdLoc, Init->getSourceRange().getEnd());
4206 
4207  return BuildMemberInitializer(Member, Init, IdLoc);
4208  }
4209  // It didn't name a member, so see if it names a class.
4210  QualType BaseType;
4211  TypeSourceInfo *TInfo = nullptr;
4212 
4213  if (TemplateTypeTy) {
4214  BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
4215  if (BaseType.isNull())
4216  return true;
4217  } else if (DS.getTypeSpecType() == TST_decltype) {
4218  BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
4219  } else if (DS.getTypeSpecType() == TST_decltype_auto) {
4220  Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);
4221  return true;
4222  } else {
4223  LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
4224  LookupParsedName(R, S, &SS);
4225 
4226  TypeDecl *TyD = R.getAsSingle<TypeDecl>();
4227  if (!TyD) {
4228  if (R.isAmbiguous()) return true;
4229 
4230  // We don't want access-control diagnostics here.
4231  R.suppressDiagnostics();
4232 
4233  if (SS.isSet() && isDependentScopeSpecifier(SS)) {
4234  bool NotUnknownSpecialization = false;
4235  DeclContext *DC = computeDeclContext(SS, false);
4236  if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
4237  NotUnknownSpecialization = !Record->hasAnyDependentBases();
4238 
4239  if (!NotUnknownSpecialization) {
4240  // When the scope specifier can refer to a member of an unknown
4241  // specialization, we take it as a type name.
4244  *MemberOrBase, IdLoc);
4245  if (BaseType.isNull())
4246  return true;
4247 
4248  TInfo = Context.CreateTypeSourceInfo(BaseType);
4251  if (!TL.isNull()) {
4252  TL.setNameLoc(IdLoc);
4255  }
4256 
4257  R.clear();
4258  R.setLookupName(MemberOrBase);
4259  }
4260  }
4261 
4262  // If no results were found, try to correct typos.
4263  TypoCorrection Corr;
4264  MemInitializerValidatorCCC CCC(ClassDecl);
4265  if (R.empty() && BaseType.isNull() &&
4266  (Corr = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
4267  CCC, CTK_ErrorRecovery, ClassDecl))) {
4268  if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
4269  // We have found a non-static data member with a similar
4270  // name to what was typed; complain and initialize that
4271  // member.
4272  diagnoseTypo(Corr,
4273  PDiag(diag::err_mem_init_not_member_or_class_suggest)
4274  << MemberOrBase << true);
4275  return BuildMemberInitializer(Member, Init, IdLoc);
4276  } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
4277  const CXXBaseSpecifier *DirectBaseSpec;
4278  const CXXBaseSpecifier *VirtualBaseSpec;
4279  if (FindBaseInitializer(*this, ClassDecl,
4281  DirectBaseSpec, VirtualBaseSpec)) {
4282  // We have found a direct or virtual base class with a
4283  // similar name to what was typed; complain and initialize
4284  // that base class.
4285  diagnoseTypo(Corr,
4286  PDiag(diag::err_mem_init_not_member_or_class_suggest)
4287  << MemberOrBase << false,
4288  PDiag() /*Suppress note, we provide our own.*/);
4289 
4290  const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
4291  : VirtualBaseSpec;
4292  Diag(BaseSpec->getBeginLoc(), diag::note_base_class_specified_here)
4293  << BaseSpec->getType() << BaseSpec->getSourceRange();
4294 
4295  TyD = Type;
4296  }
4297  }
4298  }
4299 
4300  if (!TyD && BaseType.isNull()) {
4301  Diag(IdLoc, diag::err_mem_init_not_member_or_class)
4302  << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
4303  return true;
4304  }
4305  }
4306 
4307  if (BaseType.isNull()) {
4308  BaseType = Context.getTypeDeclType(TyD);
4309  MarkAnyDeclReferenced(TyD->getLocation(), TyD, /*OdrUse=*/false);
4310  if (SS.isSet()) {
4311  BaseType = Context.getElaboratedType(ETK_None, SS.getScopeRep(),
4312  BaseType);
4313  TInfo = Context.CreateTypeSourceInfo(BaseType);
4315  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
4318  }
4319  }
4320  }
4321 
4322  if (!TInfo)
4323  TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
4324 
4325  return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc);
4326 }
4327 
4330  SourceLocation IdLoc) {
4331  FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member);
4332  IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member);
4333  assert((DirectMember || IndirectMember) &&
4334  "Member must be a FieldDecl or IndirectFieldDecl");
4335 
4337  return true;
4338 
4339  if (Member->isInvalidDecl())
4340  return true;
4341 
4342  MultiExprArg Args;
4343  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4344  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4345  } else if (InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
4346  Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
4347  } else {
4348  // Template instantiation doesn't reconstruct ParenListExprs for us.
4349  Args = Init;
4350  }
4351 
4352  SourceRange InitRange = Init->getSourceRange();
4353 
4354  if (Member->getType()->isDependentType() || Init->isTypeDependent()) {
4355  // Can't check initialization for a member of dependent type or when
4356  // any of the arguments are type-dependent expressions.
4358  } else {
4359  bool InitList = false;
4360  if (isa<InitListExpr>(Init)) {
4361  InitList = true;
4362  Args = Init;
4363  }
4364 
4365  // Initialize the member.
4366  InitializedEntity MemberEntity =
4367  DirectMember ? InitializedEntity::InitializeMember(DirectMember, nullptr)
4368  : InitializedEntity::InitializeMember(IndirectMember,
4369  nullptr);
4372  IdLoc, Init->getBeginLoc(), Init->getEndLoc())
4373  : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(),
4374  InitRange.getEnd());
4375 
4376  InitializationSequence InitSeq(*this, MemberEntity, Kind, Args);
4377  ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind, Args,
4378  nullptr);
4379  if (!MemberInit.isInvalid()) {
4380  // C++11 [class.base.init]p7:
4381  // The initialization of each base and member constitutes a
4382  // full-expression.
4383  MemberInit = ActOnFinishFullExpr(MemberInit.get(), InitRange.getBegin(),
4384  /*DiscardedValue*/ false);
4385  }
4386 
4387  if (MemberInit.isInvalid()) {
4388  // Args were sensible expressions but we couldn't initialize the member
4389  // from them. Preserve them in a RecoveryExpr instead.
4390  Init = CreateRecoveryExpr(InitRange.getBegin(), InitRange.getEnd(), Args,
4391  Member->getType())
4392  .get();
4393  if (!Init)
4394  return true;
4395  } else {
4396  Init = MemberInit.get();
4397  }
4398  }
4399 
4400  if (DirectMember) {
4401  return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc,
4402  InitRange.getBegin(), Init,
4403  InitRange.getEnd());
4404  } else {
4405  return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc,
4406  InitRange.getBegin(), Init,
4407  InitRange.getEnd());
4408  }
4409 }
4410 
4413  CXXRecordDecl *ClassDecl) {
4414  SourceLocation NameLoc = TInfo->getTypeLoc().getLocalSourceRange().getBegin();
4415  if (!LangOpts.CPlusPlus11)
4416  return Diag(NameLoc, diag::err_delegating_ctor)
4417  << TInfo->getTypeLoc().getLocalSourceRange();
4418  Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
4419 
4420  bool InitList = true;
4421  MultiExprArg Args = Init;
4422  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4423  InitList = false;
4424  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4425  }
4426 
4427  SourceRange InitRange = Init->getSourceRange();
4428  // Initialize the object.
4430  QualType(ClassDecl->getTypeForDecl(), 0));
4433  NameLoc, Init->getBeginLoc(), Init->getEndLoc())
4434  : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(),
4435  InitRange.getEnd());
4436  InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args);
4437  ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind,
4438  Args, nullptr);
4439  if (!DelegationInit.isInvalid()) {
4440  assert((DelegationInit.get()->containsErrors() ||
4441  cast<CXXConstructExpr>(DelegationInit.get())->getConstructor()) &&
4442  "Delegating constructor with no target?");
4443 
4444  // C++11 [class.base.init]p7:
4445  // The initialization of each base and member constitutes a
4446  // full-expression.
4447  DelegationInit = ActOnFinishFullExpr(
4448  DelegationInit.get(), InitRange.getBegin(), /*DiscardedValue*/ false);
4449  }
4450 
4451  if (DelegationInit.isInvalid()) {
4452  DelegationInit =
4453  CreateRecoveryExpr(InitRange.getBegin(), InitRange.getEnd(), Args,
4454  QualType(ClassDecl->getTypeForDecl(), 0));
4455  if (DelegationInit.isInvalid())
4456  return true;
4457  } else {
4458  // If we are in a dependent context, template instantiation will
4459  // perform this type-checking again. Just save the arguments that we
4460  // received in a ParenListExpr.
4461  // FIXME: This isn't quite ideal, since our ASTs don't capture all
4462  // of the information that we have about the base
4463  // initializer. However, deconstructing the ASTs is a dicey process,
4464  // and this approach is far more likely to get the corner cases right.
4466  DelegationInit = Init;
4467  }
4468 
4469  return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(),
4470  DelegationInit.getAs<Expr>(),
4471  InitRange.getEnd());
4472 }
4473 
4476  Expr *Init, CXXRecordDecl *ClassDecl,
4477  SourceLocation EllipsisLoc) {
4478  SourceLocation BaseLoc
4479  = BaseTInfo->getTypeLoc().getLocalSourceRange().getBegin();
4480 
4481  if (!BaseType->isDependentType() && !BaseType->isRecordType())
4482  return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
4483  << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
4484 
4485  // C++ [class.base.init]p2:
4486  // [...] Unless the mem-initializer-id names a nonstatic data
4487  // member of the constructor's class or a direct or virtual base
4488  // of that class, the mem-initializer is ill-formed. A
4489  // mem-initializer-list can initialize a base class using any
4490  // name that denotes that base class type.
4491 
4492  // We can store the initializers in "as-written" form and delay analysis until
4493  // instantiation if the constructor is dependent. But not for dependent
4494  // (broken) code in a non-template! SetCtorInitializers does not expect this.
4495  bool Dependent = CurContext->isDependentContext() &&
4496  (BaseType->isDependentType() || Init->isTypeDependent());
4497 
4498  SourceRange InitRange = Init->getSourceRange();
4499  if (EllipsisLoc.isValid()) {
4500  // This is a pack expansion.
4501  if (!BaseType->containsUnexpandedParameterPack()) {
4502  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
4503  << SourceRange(BaseLoc, InitRange.getEnd());
4504 
4505  EllipsisLoc = SourceLocation();
4506  }
4507  } else {
4508  // Check for any unexpanded parameter packs.
4509  if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer))
4510  return true;
4511 
4513  return true;
4514  }
4515 
4516  // Check for direct and virtual base classes.
4517  const CXXBaseSpecifier *DirectBaseSpec = nullptr;
4518  const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
4519  if (!Dependent) {
4521  BaseType))
4522  return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl);
4523 
4524  FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
4525  VirtualBaseSpec);
4526 
4527  // C++ [base.class.init]p2:
4528  // Unless the mem-initializer-id names a nonstatic data member of the
4529  // constructor's class or a direct or virtual base of that class, the
4530  // mem-initializer is ill-formed.
4531  if (!DirectBaseSpec && !VirtualBaseSpec) {
4532  // If the class has any dependent bases, then it's possible that
4533  // one of those types will resolve to the same type as
4534  // BaseType. Therefore, just treat this as a dependent base
4535  // class initialization. FIXME: Should we try to check the
4536  // initialization anyway? It seems odd.
4537  if (ClassDecl->hasAnyDependentBases())
4538  Dependent = true;
4539  else
4540  return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
4541  << BaseType << Context.getTypeDeclType(ClassDecl)
4542  << BaseTInfo->getTypeLoc().getLocalSourceRange();
4543  }
4544  }
4545 
4546  if (Dependent) {
4548 
4549  return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4550  /*IsVirtual=*/false,
4551  InitRange.getBegin(), Init,
4552  InitRange.getEnd(), EllipsisLoc);
4553  }
4554 
4555  // C++ [base.class.init]p2:
4556  // If a mem-initializer-id is ambiguous because it designates both
4557  // a direct non-virtual base class and an inherited virtual base
4558  // class, the mem-initializer is ill-formed.
4559  if (DirectBaseSpec && VirtualBaseSpec)
4560  return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
4561  << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
4562 
4563  const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
4564  if (!BaseSpec)
4565  BaseSpec = VirtualBaseSpec;
4566 
4567  // Initialize the base.
4568  bool InitList = true;
4569  MultiExprArg Args = Init;
4570  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4571  InitList = false;
4572  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4573  }
4574 
4575  InitializedEntity BaseEntity =
4576  InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec);
4578  InitList ? InitializationKind::CreateDirectList(BaseLoc)
4579  : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(),
4580  InitRange.getEnd());
4581  InitializationSequence InitSeq(*this, BaseEntity, Kind, Args);
4582  ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind, Args, nullptr);
4583  if (!BaseInit.isInvalid()) {
4584  // C++11 [class.base.init]p7:
4585  // The initialization of each base and member constitutes a
4586  // full-expression.
4587  BaseInit = ActOnFinishFullExpr(BaseInit.get(), InitRange.getBegin(),
4588  /*DiscardedValue*/ false);
4589  }
4590 
4591  if (BaseInit.isInvalid()) {
4592  BaseInit = CreateRecoveryExpr(InitRange.getBegin(), InitRange.getEnd(),
4593  Args, BaseType);
4594  if (BaseInit.isInvalid())
4595  return true;
4596  } else {
4597  // If we are in a dependent context, template instantiation will
4598  // perform this type-checking again. Just save the arguments that we
4599  // received in a ParenListExpr.
4600  // FIXME: This isn't quite ideal, since our ASTs don't capture all
4601  // of the information that we have about the base
4602  // initializer. However, deconstructing the ASTs is a dicey process,
4603  // and this approach is far more likely to get the corner cases right.
4605  BaseInit = Init;
4606  }
4607 
4608  return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4609  BaseSpec->isVirtual(),
4610  InitRange.getBegin(),
4611  BaseInit.getAs<Expr>(),
4612  InitRange.getEnd(), EllipsisLoc);
4613 }
4614 
4615 // Create a static_cast<T&&>(expr).
4616 static Expr *CastForMoving(Sema &SemaRef, Expr *E, QualType T = QualType()) {
4617  if (T.isNull()) T = E->getType();
4618  QualType TargetType = SemaRef.BuildReferenceType(
4619  T, /*SpelledAsLValue*/false, SourceLocation(), DeclarationName());
4620  SourceLocation ExprLoc = E->getBeginLoc();
4621  TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo(
4622  TargetType, ExprLoc);
4623 
4624  return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
4625  SourceRange(ExprLoc, ExprLoc),
4626  E->getSourceRange()).get();
4627 }
4628 
4629 /// ImplicitInitializerKind - How an implicit base or member initializer should
4630 /// initialize its base or member.
4636 };
4637 
4638 static bool
4640  ImplicitInitializerKind ImplicitInitKind,
4641  CXXBaseSpecifier *BaseSpec,
4642  bool IsInheritedVirtualBase,
4643  CXXCtorInitializer *&CXXBaseInit) {
4644  InitializedEntity InitEntity
4645  = InitializedEntity::InitializeBase(SemaRef.Context, BaseSpec,
4646  IsInheritedVirtualBase);
4647 
4648  ExprResult BaseInit;
4649 
4650  switch (ImplicitInitKind) {
4651  case IIK_Inherit:
4652  case IIK_Default: {
4653  InitializationKind InitKind
4654  = InitializationKind::CreateDefault(Constructor->getLocation());
4655  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
4656  BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
4657  break;
4658  }
4659 
4660  case IIK_Move:
4661  case IIK_Copy: {
4662  bool Moving = ImplicitInitKind == IIK_Move;
4663  ParmVarDecl *Param = Constructor->getParamDecl(0);
4664  QualType ParamType = Param->getType().getNonReferenceType();
4665 
4666  Expr *CopyCtorArg =
4668  SourceLocation(), Param, false,
4669  Constructor->getLocation(), ParamType,
4670  VK_LValue, nullptr);
4671 
4672  SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg));
4673 
4674  // Cast to the base class to avoid ambiguities.
4675  QualType ArgTy =
4676  SemaRef.Context.getQualifiedType(BaseSpec->getType().getUnqualifiedType(),
4677  ParamType.getQualifiers());
4678 
4679  if (Moving) {
4680  CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg);
4681  }
4682 
4683  CXXCastPath BasePath;
4684  BasePath.push_back(BaseSpec);
4685  CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy,
4686  CK_UncheckedDerivedToBase,
4687  Moving ? VK_XValue : VK_LValue,
4688  &BasePath).get();
4689 
4690  InitializationKind InitKind
4691  = InitializationKind::CreateDirect(Constructor->getLocation(),
4693  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, CopyCtorArg);
4694  BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, CopyCtorArg);
4695  break;
4696  }
4697  }
4698 
4699  BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit);
4700  if (BaseInit.isInvalid())
4701  return true;
4702 
4703  CXXBaseInit =
4704  new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4705  SemaRef.Context.getTrivialTypeSourceInfo(BaseSpec->getType(),
4706  SourceLocation()),
4707  BaseSpec->isVirtual(),
4708  SourceLocation(),
4709  BaseInit.getAs<Expr>(),
4710  SourceLocation(),
4711  SourceLocation());
4712 
4713  return false;
4714 }
4715 
4716 static bool RefersToRValueRef(Expr *MemRef) {
4717  ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
4718  return Referenced->getType()->isRValueReferenceType();
4719 }
4720 
4721 static bool
4723  ImplicitInitializerKind ImplicitInitKind,
4724  FieldDecl *Field, IndirectFieldDecl *Indirect,
4725  CXXCtorInitializer *&CXXMemberInit) {
4726  if (Field->isInvalidDecl())
4727  return true;
4728 
4729  SourceLocation Loc = Constructor->getLocation();
4730 
4731  if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) {
4732  bool Moving = ImplicitInitKind == IIK_Move;
4733  ParmVarDecl *Param = Constructor->getParamDecl(0);
4734  QualType ParamType = Param->getType().getNonReferenceType();
4735 
4736  // Suppress copying zero-width bitfields.
4737  if (Field->isZeroLengthBitField(SemaRef.Context))
4738  return false;
4739 
4740  Expr *MemberExprBase =
4742  SourceLocation(), Param, false,
4743  Loc, ParamType, VK_LValue, nullptr);
4744 
4745  SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase));
4746 
4747  if (Moving) {
4748  MemberExprBase = CastForMoving(SemaRef, MemberExprBase);
4749  }
4750 
4751  // Build a reference to this field within the parameter.
4752  CXXScopeSpec SS;
4753  LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
4755  MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect)
4756  : cast<ValueDecl>(Field), AS_public);
4757  MemberLookup.resolveKind();
4758  ExprResult CtorArg
4759  = SemaRef.BuildMemberReferenceExpr(MemberExprBase,
4760  ParamType, Loc,
4761  /*IsArrow=*/false,
4762  SS,
4763  /*TemplateKWLoc=*/SourceLocation(),
4764  /*FirstQualifierInScope=*/nullptr,
4765  MemberLookup,
4766  /*TemplateArgs=*/nullptr,
4767  /*S*/nullptr);
4768  if (CtorArg.isInvalid())
4769  return true;
4770 
4771  // C++11 [class.copy]p15:
4772  // - if a member m has rvalue reference type T&&, it is direct-initialized
4773  // with static_cast<T&&>(x.m);
4774  if (RefersToRValueRef(CtorArg.get())) {
4775  CtorArg = CastForMoving(SemaRef, CtorArg.get());
4776  }
4777 
4778  InitializedEntity Entity =
4779  Indirect ? InitializedEntity::InitializeMember(Indirect, nullptr,
4780  /*Implicit*/ true)
4781  : InitializedEntity::InitializeMember(Field, nullptr,
4782  /*Implicit*/ true);
4783 
4784  // Direct-initialize to use the copy constructor.
4785  InitializationKind InitKind =
4787 
4788  Expr *CtorArgE = CtorArg.getAs<Expr>();
4789  InitializationSequence InitSeq(SemaRef, Entity, InitKind, CtorArgE);
4790  ExprResult MemberInit =
4791  InitSeq.Perform(SemaRef, Entity, InitKind, MultiExprArg(&CtorArgE, 1));
4792  MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
4793  if (MemberInit.isInvalid())
4794  return true;
4795 
4796  if (Indirect)
4797  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
4798  SemaRef.Context, Indirect, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
4799  else
4800  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
4801  SemaRef.Context, Field, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
4802  return false;
4803  }
4804 
4805  assert((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) &&
4806  "Unhandled implicit init kind!");
4807 
4808  QualType FieldBaseElementType =
4809  SemaRef.Context.getBaseElementType(Field->getType());
4810 
4811  if (FieldBaseElementType->isRecordType()) {
4812  InitializedEntity InitEntity =
4813  Indirect ? InitializedEntity::InitializeMember(Indirect, nullptr,
4814  /*Implicit*/ true)
4815  : InitializedEntity::InitializeMember(Field, nullptr,
4816  /*Implicit*/ true);
4817  InitializationKind InitKind =
4819 
4820  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
4821  ExprResult MemberInit =
4822  InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
4823 
4824  MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
4825  if (MemberInit.isInvalid())
4826  return true;
4827 
4828  if (Indirect)
4829  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4830  Indirect, Loc,
4831  Loc,
4832  MemberInit.get(),
4833  Loc);
4834  else
4835  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4836  Field, Loc, Loc,
4837  MemberInit.get(),
4838  Loc);
4839  return false;
4840  }
4841 
4842  if (!Field->getParent()->isUnion()) {
4843  if (FieldBaseElementType->isReferenceType()) {
4844  SemaRef.Diag(Constructor->getLocation(),
4845  diag::err_uninitialized_member_in_ctor)
4846  << (int)Constructor->isImplicit()
4847  << SemaRef.Context.getTagDeclType(Constructor->getParent())
4848  << 0 << Field->getDeclName();
4849  SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
4850  return true;
4851  }
4852 
4853  if (FieldBaseElementType.isConstQualified()) {
4854  SemaRef.Diag(Constructor->getLocation(),
4855  diag::err_uninitialized_member_in_ctor)
4856  << (int)Constructor->isImplicit()
4857  << SemaRef.Context.getTagDeclType(Constructor->getParent())
4858  << 1 << Field->getDeclName();
4859  SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
4860  return true;
4861  }
4862  }
4863 
4864  if (FieldBaseElementType.hasNonTrivialObjCLifetime()) {
4865  // ARC and Weak:
4866  // Default-initialize Objective-C pointers to NULL.
4867  CXXMemberInit
4868  = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
4869  Loc, Loc,
4870  new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()),
4871  Loc);
4872  return false;
4873  }
4874 
4875  // Nothing to initialize.
4876  CXXMemberInit = nullptr;
4877  return false;
4878 }
4879 
4880 namespace {
4881 struct BaseAndFieldInfo {
4882  Sema &S;
4883  CXXConstructorDecl *Ctor;
4884  bool AnyErrorsInInits;
4886  llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
4888  llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
4889 
4890  BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits)
4891  : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
4892  bool Generated = Ctor->isImplicit() || Ctor->isDefaulted();
4893  if (Ctor->getInheritedConstructor())
4894  IIK = IIK_Inherit;
4895  else if (Generated && Ctor->isCopyConstructor())
4896  IIK = IIK_Copy;
4897  else if (Generated && Ctor->isMoveConstructor())
4898  IIK = IIK_Move;
4899  else
4900  IIK = IIK_Default;
4901  }
4902 
4903  bool isImplicitCopyOrMove() const {
4904  switch (IIK) {
4905  case IIK_Copy:
4906  case IIK_Move:
4907  return true;
4908 
4909  case IIK_Default:
4910  case IIK_Inherit:
4911  return false;
4912  }
4913 
4914  llvm_unreachable("Invalid ImplicitInitializerKind!");
4915  }
4916 
4917  bool addFieldInitializer(CXXCtorInitializer *Init) {
4918  AllToInit.push_back(Init);
4919 
4920  // Check whether this initializer makes the field "used".
4921  if (Init->getInit()->HasSideEffects(S.Context))
4922  S.UnusedPrivateFields.remove(Init->getAnyMember());
4923 
4924  return false;
4925  }
4926 
4927  bool isInactiveUnionMember(FieldDecl *Field) {
4928  RecordDecl *Record = Field->getParent();
4929  if (!Record->isUnion())
4930  return false;
4931 
4932  if (FieldDecl *Active =
4933  ActiveUnionMember.lookup(Record->getCanonicalDecl()))
4934  return Active != Field->getCanonicalDecl();
4935 
4936  // In an implicit copy or move constructor, ignore any in-class initializer.
4937  if (isImplicitCopyOrMove())
4938  return true;
4939 
4940  // If there's no explicit initialization, the field is active only if it
4941  // has an in-class initializer...
4942  if (Field->hasInClassInitializer())
4943  return false;
4944  // ... or it's an anonymous struct or union whose class has an in-class
4945  // initializer.
4946  if (!Field->isAnonymousStructOrUnion())
4947  return true;
4948  CXXRecordDecl *FieldRD = Field->getType()->getAsCXXRecordDecl();
4949  return !FieldRD->hasInClassInitializer();
4950  }
4951 
4952  /// Determine whether the given field is, or is within, a union member
4953  /// that is inactive (because there was an initializer given for a different
4954  /// member of the union, or because the union was not initialized at all).
4955  bool isWithinInactiveUnionMember(FieldDecl *Field,
4956  IndirectFieldDecl *Indirect) {
4957  if (!Indirect)
4958  return isInactiveUnionMember(Field);
4959 
4960  for (auto *C : Indirect->chain()) {
4961  FieldDecl *Field = dyn_cast<FieldDecl>(C);
4962  if (Field && isInactiveUnionMember(Field))
4963  return true;
4964  }
4965  return false;
4966  }
4967 };
4968 }
4969 
4970 /// Determine whether the given type is an incomplete or zero-lenfgth
4971 /// array type.
4973  if (T->isIncompleteArrayType())
4974  return true;
4975 
4976  while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
4977  if (!ArrayT->getSize())
4978  return true;
4979 
4980  T = ArrayT->getElementType();
4981  }
4982 
4983  return false;
4984 }
4985 
4986 static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
4987  FieldDecl *Field,
4988  IndirectFieldDecl *Indirect = nullptr) {
4989  if (Field->isInvalidDecl())
4990  return false;
4991 
4992  // Overwhelmingly common case: we have a direct initializer for this field.
4993  if (CXXCtorInitializer *Init =
4994  Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
4995  return Info.addFieldInitializer(Init);
4996 
4997  // C++11 [class.base.init]p8:
4998  // if the entity is a non-static data member that has a
4999  // brace-or-equal-initializer and either
5000  // -- the constructor's class is a union and no other variant member of that
5001  // union is designated by a mem-initializer-id or
5002  // -- the constructor's class is not a union, and, if the entity is a member
5003  // of an anonymous union, no other member of that union is designated by
5004  // a mem-initializer-id,
5005  // the entity is initialized as specified in [dcl.init].
5006  //
5007  // We also apply the same rules to handle anonymous structs within anonymous
5008  // unions.
5009  if (Info.isWithinInactiveUnionMember(Field, Indirect))
5010  return false;
5011 
5012  if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
5013  ExprResult DIE =
5014  SemaRef.BuildCXXDefaultInitExpr(Info.Ctor->getLocation(), Field);
5015  if (DIE.isInvalid())
5016  return true;
5017 
5018  auto Entity = InitializedEntity::InitializeMember(Field, nullptr, true);
5019  SemaRef.checkInitializerLifetime(Entity, DIE.get());
5020 
5021  CXXCtorInitializer *Init;
5022  if (Indirect)
5023  Init = new (SemaRef.Context)
5024  CXXCtorInitializer(SemaRef.Context, Indirect, SourceLocation(),
5025  SourceLocation(), DIE.get(), SourceLocation());
5026  else
5027  Init = new (SemaRef.Context)
5028  CXXCtorInitializer(SemaRef.Context, Field, SourceLocation(),
5029  SourceLocation(), DIE.get(), SourceLocation());
5030  return Info.addFieldInitializer(Init);
5031  }
5032 
5033  // Don't initialize incomplete or zero-length arrays.
5034  if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType()))
5035  return false;
5036 
5037  // Don't try to build an implicit initializer if there were semantic
5038  // errors in any of the initializers (and therefore we might be
5039  // missing some that the user actually wrote).
5040  if (Info.AnyErrorsInInits)
5041  return false;
5042 
5043  CXXCtorInitializer *Init = nullptr;
5044  if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field,
5045  Indirect, Init))
5046  return true;
5047 
5048  if (!Init)
5049  return false;
5050 
5051  return Info.addFieldInitializer(Init);
5052 }
5053 
5054 bool
5056  CXXCtorInitializer *Initializer) {
5057  assert(Initializer->isDelegatingInitializer());
5058  Constructor->setNumCtorInitializers(1);
5059  CXXCtorInitializer **initializer =
5060  new (Context) CXXCtorInitializer*[1];
5061  memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*));
5062  Constructor->setCtorInitializers(initializer);
5063 
5064  if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) {
5065  MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor);
5066  DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation());
5067  }
5068 
5069  DelegatingCtorDecls.push_back(Constructor);
5070 
5071  DiagnoseUninitializedFields(*this, Constructor);
5072 
5073  return false;
5074 }
5075 
5076 bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
5077  ArrayRef<CXXCtorInitializer *> Initializers) {
5078  if (Constructor->isDependentContext()) {
5079  // Just store the initializers as written, they will be checked during
5080  // instantiation.
5081  if (!Initializers.empty()) {
5082  Constructor->setNumCtorInitializers(Initializers.size());
5083  CXXCtorInitializer **baseOrMemberInitializers =
5084  new (Context) CXXCtorInitializer*[Initializers.size()];
5085  memcpy(baseOrMemberInitializers, Initializers.data(),
5086  Initializers.size() * sizeof(CXXCtorInitializer*));
5087  Constructor->setCtorInitializers(baseOrMemberInitializers);
5088  }
5089 
5090  // Let template instantiation know whether we had errors.
5091  if (AnyErrors)
5092  Constructor->setInvalidDecl();
5093 
5094  return false;
5095  }
5096 
5097  BaseAndFieldInfo Info(*this, Constructor, AnyErrors);
5098 
5099  // We need to build the initializer AST according to order of construction
5100  // and not what user specified in the Initializers list.
5101  CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
5102  if (!ClassDecl)
5103  return true;
5104 
5105  bool HadError = false;
5106 
5107  for (unsigned i = 0; i < Initializers.size(); i++) {
5108  CXXCtorInitializer *Member = Initializers[i];
5109 
5110  if (Member->isBaseInitializer())
5111  Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
5112  else {
5113  Info.AllBaseFields[Member->getAnyMember()->getCanonicalDecl()] = Member;
5114 
5115  if (IndirectFieldDecl *F = Member->getIndirectMember()) {
5116  for (auto *C : F->chain()) {
5117  FieldDecl *FD = dyn_cast<FieldDecl>(C);
5118  if (FD && FD->getParent()->isUnion())
5119  Info.ActiveUnionMember.insert(std::make_pair(
5120  FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
5121  }
5122  } else if (FieldDecl *FD = Member->getMember()) {
5123  if (FD->getParent()->isUnion())
5124  Info.ActiveUnionMember.insert(std::make_pair(
5125  FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
5126  }
5127  }
5128  }
5129 
5130  // Keep track of the direct virtual bases.
5132  for (auto &I : ClassDecl->bases()) {
5133  if (I.isVirtual())
5134  DirectVBases.insert(&I);
5135  }
5136 
5137  // Push virtual bases before others.
5138  for (auto &VBase : ClassDecl->vbases()) {
5140  = Info.AllBaseFields.lookup(VBase.getType()->getAs<RecordType>())) {
5141  // [class.base.init]p7, per DR257:
5142  // A mem-initializer where the mem-initializer-id names a virtual base
5143  // class is ignored during execution of a constructor of any class that
5144  // is not the most derived class.
5145  if (ClassDecl->isAbstract()) {
5146  // FIXME: Provide a fixit to remove the base specifier. This requires
5147  // tracking the location of the associated comma for a base specifier.
5148  Diag(Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
5149  << VBase.getType() << ClassDecl;
5150  DiagnoseAbstractType(ClassDecl);
5151  }
5152 
5153  Info.AllToInit.push_back(Value);
5154  } else if (!AnyErrors && !ClassDecl->isAbstract()) {
5155  // [class.base.init]p8, per DR257:
5156  // If a given [...] base class is not named by a mem-initializer-id
5157  // [...] and the entity is not a virtual base class of an abstract
5158  // class, then [...] the entity is default-initialized.
5159  bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
5160  CXXCtorInitializer *CXXBaseInit;
5161  if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
5162  &VBase, IsInheritedVirtualBase,
5163  CXXBaseInit)) {
5164  HadError = true;
5165  continue;
5166  }
5167 
5168  Info.AllToInit.push_back(CXXBaseInit);
5169  }
5170  }
5171 
5172  // Non-virtual bases.
5173  for (auto &Base : ClassDecl->bases()) {
5174  // Virtuals are in the virtual base list and already constructed.
5175  if (Base.isVirtual())
5176  continue;
5177 
5179  = Info.AllBaseFields.lookup(Base.getType()->getAs<RecordType>())) {
5180  Info.AllToInit.push_back(Value);
5181  } else if (!AnyErrors) {
5182  CXXCtorInitializer *CXXBaseInit;
5183  if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
5184  &Base, /*IsInheritedVirtualBase=*/false,
5185  CXXBaseInit)) {
5186  HadError = true;
5187  continue;
5188  }
5189 
5190  Info.AllToInit.push_back(CXXBaseInit);
5191  }
5192  }
5193 
5194  // Fields.
5195  for (auto *Mem : ClassDecl->decls()) {
5196  if (auto *F = dyn_cast<FieldDecl>(Mem)) {
5197  // C++ [class.bit]p2:
5198  // A declaration for a bit-field that omits the identifier declares an
5199  // unnamed bit-field. Unnamed bit-fields are not members and cannot be
5200  // initialized.
5201  if (F->isUnnamedBitfield())
5202  continue;
5203 
5204  // If we're not generating the implicit copy/move constructor, then we'll
5205  // handle anonymous struct/union fields based on their individual
5206  // indirect fields.
5207  if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
5208  continue;
5209 
5210  if (CollectFieldInitializer(*this, Info, F))
5211  HadError = true;
5212  continue;
5213  }
5214 
5215  // Beyond this point, we only consider default initialization.
5216  if (Info.isImplicitCopyOrMove())
5217  continue;
5218 
5219  if (auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
5220  if (F->getType()->isIncompleteArrayType()) {
5221  assert(ClassDecl->hasFlexibleArrayMember() &&
5222  "Incomplete array type is not valid");
5223  continue;
5224  }
5225 
5226  // Initialize each field of an anonymous struct individually.
5227  if (CollectFieldInitializer(*this, Info, F->getAnonField(), F))
5228  HadError = true;
5229 
5230  continue;
5231  }
5232  }
5233 
5234  unsigned NumInitializers = Info.AllToInit.size();
5235  if (NumInitializers > 0) {
5236  Constructor->setNumCtorInitializers(NumInitializers);
5237  CXXCtorInitializer **baseOrMemberInitializers =
5238  new (Context) CXXCtorInitializer*[NumInitializers];
5239  memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
5240  NumInitializers * sizeof(CXXCtorInitializer*));
5241  Constructor->setCtorInitializers(baseOrMemberInitializers);
5242 
5243  // Constructors implicitly reference the base and member
5244  // destructors.
5245  MarkBaseAndMemberDestructorsReferenced(Constructor->getLocation(),
5246  Constructor->getParent());
5247  }
5248 
5249  return HadError;
5250 }
5251 
5253  if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
5254  const RecordDecl *RD = RT->getDecl();
5255  if (RD->isAnonymousStructOrUnion()) {
5256  for (auto *Field : RD->fields())
5257  PopulateKeysForFields(Field, IdealInits);
5258  return;
5259  }
5260  }
5261  IdealInits.push_back(Field->getCanonicalDecl());
5262 }
5263 
5264 static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
5265  return Context.getCanonicalType(BaseType).getTypePtr();
5266 }
5267 
5268 static const void *GetKeyForMember(ASTContext &Context,
5269  CXXCtorInitializer *Member) {
5270  if (!Member->isAnyMemberInitializer())
5271  return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0));
5272 
5273  return Member->getAnyMember()->getCanonicalDecl();
5274 }
5275 
5278  const CXXCtorInitializer *Current) {
5279  if (Previous->isAnyMemberInitializer())
5280  Diag << 0 << Previous->getAnyMember();
5281  else
5282  Diag << 1 << Previous->getTypeSourceInfo()->getType();
5283 
5284  if (Current->isAnyMemberInitializer())
5285  Diag << 0 << Current->getAnyMember();
5286  else
5287  Diag << 1 << Current->getTypeSourceInfo()->getType();
5288 }
5289 
5291  Sema &SemaRef, const CXXConstructorDecl *Constructor,
5293  if (Constructor->getDeclContext()->isDependentContext())
5294  return;
5295 
5296  // Don't check initializers order unless the warning is enabled at the
5297  // location of at least one initializer.
5298  bool ShouldCheckOrder = false;
5299  for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5300  CXXCtorInitializer *Init = Inits[InitIndex];
5301  if (!SemaRef.Diags.isIgnored(diag::warn_initializer_out_of_order,
5302  Init->getSourceLocation())) {
5303  ShouldCheckOrder = true;
5304  break;
5305  }
5306  }
5307  if (!ShouldCheckOrder)
5308  return;
5309 
5310  // Build the list of bases and members in the order that they'll
5311  // actually be initialized. The explicit initializers should be in
5312  // this same order but may be missing things.
5313  SmallVector<const void*, 32> IdealInitKeys;
5314 
5315  const CXXRecordDecl *ClassDecl = Constructor->getParent();
5316 
5317  // 1. Virtual bases.
5318  for (const auto &VBase : ClassDecl->vbases())
5319  IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase.getType()));
5320 
5321  // 2. Non-virtual bases.
5322  for (const auto &Base : ClassDecl->bases()) {
5323  if (Base.isVirtual())
5324  continue;
5325  IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base.getType()));
5326  }
5327 
5328  // 3. Direct fields.
5329  for (auto *Field : ClassDecl->fields()) {
5330  if (Field->isUnnamedBitfield())
5331  continue;
5332 
5333  PopulateKeysForFields(Field, IdealInitKeys);
5334  }
5335 
5336  unsigned NumIdealInits = IdealInitKeys.size();
5337  unsigned IdealIndex = 0;
5338 
5339  // Track initializers that are in an incorrect order for either a warning or
5340  // note if multiple ones occur.
5341  SmallVector<unsigned> WarnIndexes;
5342  // Correlates the index of an initializer in the init-list to the index of
5343  // the field/base in the class.
5344  SmallVector<std::pair<unsigned, unsigned>, 32> CorrelatedInitOrder;
5345 
5346  for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5347  const void *InitKey = GetKeyForMember(SemaRef.Context, Inits[InitIndex]);
5348 
5349  // Scan forward to try to find this initializer in the idealized
5350  // initializers list.
5351  for (; IdealIndex != NumIdealInits; ++IdealIndex)
5352  if (InitKey == IdealInitKeys[IdealIndex])
5353  break;
5354 
5355  // If we didn't find this initializer, it must be because we
5356  // scanned past it on a previous iteration. That can only
5357  // happen if we're out of order; emit a warning.
5358  if (IdealIndex == NumIdealInits && InitIndex) {
5359  WarnIndexes.push_back(InitIndex);
5360 
5361  // Move back to the initializer's location in the ideal list.
5362  for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
5363  if (InitKey == IdealInitKeys[IdealIndex])
5364  break;
5365 
5366  assert(IdealIndex < NumIdealInits &&
5367  "initializer not found in initializer list");
5368  }
5369  CorrelatedInitOrder.emplace_back(IdealIndex, InitIndex);
5370  }
5371 
5372  if (WarnIndexes.empty())
5373  return;
5374 
5375  // Sort based on the ideal order, first in the pair.
5376  llvm::sort(CorrelatedInitOrder,
5377  [](auto &LHS, auto &RHS) { return LHS.first < RHS.first; });
5378 
5379  // Introduce a new scope as SemaDiagnosticBuilder needs to be destroyed to
5380  // emit the diagnostic before we can try adding notes.
5381  {
5382  Sema::SemaDiagnosticBuilder D = SemaRef.Diag(
5383  Inits[WarnIndexes.front() - 1]->getSourceLocation(),
5384  WarnIndexes.size() == 1 ? diag::warn_initializer_out_of_order
5385  : diag::warn_some_initializers_out_of_order);
5386 
5387  for (unsigned I = 0; I < CorrelatedInitOrder.size(); ++I) {
5388  if (CorrelatedInitOrder[I].second == I)
5389  continue;
5390  // Ideally we would be using InsertFromRange here, but clang doesn't
5391  // appear to handle InsertFromRange correctly when the source range is
5392  // modified by another fix-it.
5394  Inits[I]->getSourceRange(),
5397  Inits[CorrelatedInitOrder[I].second]->getSourceRange()),
5398  SemaRef.getSourceManager(), SemaRef.getLangOpts()));
5399  }
5400 
5401  // If there is only 1 item out of order, the warning expects the name and
5402  // type of each being added to it.
5403  if (WarnIndexes.size() == 1) {
5404  AddInitializerToDiag(D, Inits[WarnIndexes.front() - 1],
5405  Inits[WarnIndexes.front()]);
5406  return;
5407  }
5408  }
5409  // More than 1 item to warn, create notes letting the user know which ones
5410  // are bad.
5411  for (unsigned WarnIndex : WarnIndexes) {
5412  const clang::CXXCtorInitializer *PrevInit = Inits[WarnIndex - 1];
5413  auto D = SemaRef.Diag(PrevInit->getSourceLocation(),
5414  diag::note_initializer_out_of_order);
5415  AddInitializerToDiag(D, PrevInit, Inits[WarnIndex]);
5416  D << PrevInit->getSourceRange();
5417  }
5418 }
5419 
5420 namespace {
5421 bool CheckRedundantInit(Sema &S,
5422  CXXCtorInitializer *Init,
5423  CXXCtorInitializer *&PrevInit) {
5424  if (!PrevInit) {
5425  PrevInit = Init;
5426  return false;
5427  }
5428 
5429  if (FieldDecl *Field = Init->getAnyMember())
5430  S.Diag(Init->getSourceLocation(),
5431  diag::err_multiple_mem_initialization)
5432  << Field->getDeclName()
5433  << Init->getSourceRange();
5434  else {
5435  const Type *BaseClass = Init->getBaseClass();
5436  assert(BaseClass && "neither field nor base");
5437  S.Diag(Init->getSourceLocation(),
5438  diag::err_multiple_base_initialization)
5439  << QualType(BaseClass, 0)
5440  << Init->getSourceRange();
5441  }
5442  S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer)
5443  << 0 << PrevInit->getSourceRange();
5444 
5445  return true;
5446 }
5447 
5448 typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
5449 typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
5450 
5451 bool CheckRedundantUnionInit(Sema &S,
5452  CXXCtorInitializer *Init,
5453  RedundantUnionMap &Unions) {
5454  FieldDecl *Field = Init->getAnyMember();
5455  RecordDecl *Parent = Field->getParent();
5456  NamedDecl *Child = Field;
5457 
5458  while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {
5459  if (Parent->isUnion()) {
5460  UnionEntry &En = Unions[Parent];
5461  if (En.first && En.first != Child) {
5462  S.Diag(Init->getSourceLocation(),
5463  diag::err_multiple_mem_union_initialization)
5464  << Field->getDeclName()
5465  << Init->getSourceRange();
5466  S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer)