clang  6.0.0
SemaDeclCXX.cpp
Go to the documentation of this file.
1 //===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements semantic analysis for C++ declarations.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/ASTConsumer.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/ASTLambda.h"
19 #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"
28 #include "clang/Basic/TargetInfo.h"
30 #include "clang/Lex/Preprocessor.h"
32 #include "clang/Sema/DeclSpec.h"
34 #include "clang/Sema/Lookup.h"
36 #include "clang/Sema/Scope.h"
37 #include "clang/Sema/ScopeInfo.h"
39 #include "clang/Sema/Template.h"
40 #include "llvm/ADT/STLExtras.h"
41 #include "llvm/ADT/SmallString.h"
42 #include "llvm/ADT/StringExtras.h"
43 #include <map>
44 #include <set>
45 
46 using namespace clang;
47 
48 //===----------------------------------------------------------------------===//
49 // CheckDefaultArgumentVisitor
50 //===----------------------------------------------------------------------===//
51 
52 namespace {
53  /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
54  /// the default argument of a parameter to determine whether it
55  /// contains any ill-formed subexpressions. For example, this will
56  /// diagnose the use of local variables or parameters within the
57  /// default argument expression.
58  class CheckDefaultArgumentVisitor
59  : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
60  Expr *DefaultArg;
61  Sema *S;
62 
63  public:
64  CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
65  : DefaultArg(defarg), S(s) {}
66 
67  bool VisitExpr(Expr *Node);
68  bool VisitDeclRefExpr(DeclRefExpr *DRE);
69  bool VisitCXXThisExpr(CXXThisExpr *ThisE);
70  bool VisitLambdaExpr(LambdaExpr *Lambda);
71  bool VisitPseudoObjectExpr(PseudoObjectExpr *POE);
72  };
73 
74  /// VisitExpr - Visit all of the children of this expression.
75  bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
76  bool IsInvalid = false;
77  for (Stmt *SubStmt : Node->children())
78  IsInvalid |= Visit(SubStmt);
79  return IsInvalid;
80  }
81 
82  /// VisitDeclRefExpr - Visit a reference to a declaration, to
83  /// determine whether this declaration can be used in the default
84  /// argument expression.
85  bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
86  NamedDecl *Decl = DRE->getDecl();
87  if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
88  // C++ [dcl.fct.default]p9
89  // Default arguments are evaluated each time the function is
90  // called. The order of evaluation of function arguments is
91  // unspecified. Consequently, parameters of a function shall not
92  // be used in default argument expressions, even if they are not
93  // evaluated. Parameters of a function declared before a default
94  // argument expression are in scope and can hide namespace and
95  // class member names.
96  return S->Diag(DRE->getLocStart(),
97  diag::err_param_default_argument_references_param)
98  << Param->getDeclName() << DefaultArg->getSourceRange();
99  } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
100  // C++ [dcl.fct.default]p7
101  // Local variables shall not be used in default argument
102  // expressions.
103  if (VDecl->isLocalVarDecl())
104  return S->Diag(DRE->getLocStart(),
105  diag::err_param_default_argument_references_local)
106  << VDecl->getDeclName() << DefaultArg->getSourceRange();
107  }
108 
109  return false;
110  }
111 
112  /// VisitCXXThisExpr - Visit a C++ "this" expression.
113  bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
114  // C++ [dcl.fct.default]p8:
115  // The keyword this shall not be used in a default argument of a
116  // member function.
117  return S->Diag(ThisE->getLocStart(),
118  diag::err_param_default_argument_references_this)
119  << ThisE->getSourceRange();
120  }
121 
122  bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(PseudoObjectExpr *POE) {
123  bool Invalid = false;
125  i = POE->semantics_begin(), e = POE->semantics_end(); i != e; ++i) {
126  Expr *E = *i;
127 
128  // Look through bindings.
129  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
130  E = OVE->getSourceExpr();
131  assert(E && "pseudo-object binding without source expression?");
132  }
133 
134  Invalid |= Visit(E);
135  }
136  return Invalid;
137  }
138 
139  bool CheckDefaultArgumentVisitor::VisitLambdaExpr(LambdaExpr *Lambda) {
140  // C++11 [expr.lambda.prim]p13:
141  // A lambda-expression appearing in a default argument shall not
142  // implicitly or explicitly capture any entity.
143  if (Lambda->capture_begin() == Lambda->capture_end())
144  return false;
145 
146  return S->Diag(Lambda->getLocStart(),
147  diag::err_lambda_capture_default_arg);
148  }
149 }
150 
151 void
153  const CXXMethodDecl *Method) {
154  // If we have an MSAny spec already, don't bother.
155  if (!Method || ComputedEST == EST_MSAny)
156  return;
157 
158  const FunctionProtoType *Proto
159  = Method->getType()->getAs<FunctionProtoType>();
160  Proto = Self->ResolveExceptionSpec(CallLoc, Proto);
161  if (!Proto)
162  return;
163 
165 
166  // If we have a throw-all spec at this point, ignore the function.
167  if (ComputedEST == EST_None)
168  return;
169 
170  if (EST == EST_None && Method->hasAttr<NoThrowAttr>())
171  EST = EST_BasicNoexcept;
172 
173  switch(EST) {
174  // If this function can throw any exceptions, make a note of that.
175  case EST_MSAny:
176  case EST_None:
177  ClearExceptions();
178  ComputedEST = EST;
179  return;
180  // FIXME: If the call to this decl is using any of its default arguments, we
181  // need to search them for potentially-throwing calls.
182  // If this function has a basic noexcept, it doesn't affect the outcome.
183  case EST_BasicNoexcept:
184  return;
185  // If we're still at noexcept(true) and there's a nothrow() callee,
186  // change to that specification.
187  case EST_DynamicNone:
188  if (ComputedEST == EST_BasicNoexcept)
189  ComputedEST = EST_DynamicNone;
190  return;
191  // Check out noexcept specs.
193  {
195  Proto->getNoexceptSpec(Self->Context);
196  assert(NR != FunctionProtoType::NR_NoNoexcept &&
197  "Must have noexcept result for EST_ComputedNoexcept.");
198  assert(NR != FunctionProtoType::NR_Dependent &&
199  "Should not generate implicit declarations for dependent cases, "
200  "and don't know how to handle them anyway.");
201  // noexcept(false) -> no spec on the new function
202  if (NR == FunctionProtoType::NR_Throw) {
203  ClearExceptions();
204  ComputedEST = EST_None;
205  }
206  // noexcept(true) won't change anything either.
207  return;
208  }
209  default:
210  break;
211  }
212  assert(EST == EST_Dynamic && "EST case not considered earlier.");
213  assert(ComputedEST != EST_None &&
214  "Shouldn't collect exceptions when throw-all is guaranteed.");
215  ComputedEST = EST_Dynamic;
216  // Record the exceptions in this function's exception specification.
217  for (const auto &E : Proto->exceptions())
218  if (ExceptionsSeen.insert(Self->Context.getCanonicalType(E)).second)
219  Exceptions.push_back(E);
220 }
221 
223  if (!E || ComputedEST == EST_MSAny)
224  return;
225 
226  // FIXME:
227  //
228  // C++0x [except.spec]p14:
229  // [An] implicit exception-specification specifies the type-id T if and
230  // only if T is allowed by the exception-specification of a function directly
231  // invoked by f's implicit definition; f shall allow all exceptions if any
232  // function it directly invokes allows all exceptions, and f shall allow no
233  // exceptions if every function it directly invokes allows no exceptions.
234  //
235  // Note in particular that if an implicit exception-specification is generated
236  // for a function containing a throw-expression, that specification can still
237  // be noexcept(true).
238  //
239  // Note also that 'directly invoked' is not defined in the standard, and there
240  // is no indication that we should only consider potentially-evaluated calls.
241  //
242  // Ultimately we should implement the intent of the standard: the exception
243  // specification should be the set of exceptions which can be thrown by the
244  // implicit definition. For now, we assume that any non-nothrow expression can
245  // throw any exception.
246 
247  if (Self->canThrow(E))
248  ComputedEST = EST_None;
249 }
250 
251 bool
253  SourceLocation EqualLoc) {
254  if (RequireCompleteType(Param->getLocation(), Param->getType(),
255  diag::err_typecheck_decl_incomplete_type)) {
256  Param->setInvalidDecl();
257  return true;
258  }
259 
260  // C++ [dcl.fct.default]p5
261  // A default argument expression is implicitly converted (clause
262  // 4) to the parameter type. The default argument expression has
263  // the same semantic constraints as the initializer expression in
264  // a declaration of a variable of the parameter type, using the
265  // copy-initialization semantics (8.5).
267  Param);
269  EqualLoc);
270  InitializationSequence InitSeq(*this, Entity, Kind, Arg);
271  ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg);
272  if (Result.isInvalid())
273  return true;
274  Arg = Result.getAs<Expr>();
275 
276  CheckCompletedExpr(Arg, EqualLoc);
277  Arg = MaybeCreateExprWithCleanups(Arg);
278 
279  // Okay: add the default argument to the parameter
280  Param->setDefaultArg(Arg);
281 
282  // We have already instantiated this parameter; provide each of the
283  // instantiations with the uninstantiated default argument.
284  UnparsedDefaultArgInstantiationsMap::iterator InstPos
285  = UnparsedDefaultArgInstantiations.find(Param);
286  if (InstPos != UnparsedDefaultArgInstantiations.end()) {
287  for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
288  InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
289 
290  // We're done tracking this parameter's instantiations.
291  UnparsedDefaultArgInstantiations.erase(InstPos);
292  }
293 
294  return false;
295 }
296 
297 /// ActOnParamDefaultArgument - Check whether the default argument
298 /// provided for a function parameter is well-formed. If so, attach it
299 /// to the parameter declaration.
300 void
302  Expr *DefaultArg) {
303  if (!param || !DefaultArg)
304  return;
305 
306  ParmVarDecl *Param = cast<ParmVarDecl>(param);
307  UnparsedDefaultArgLocs.erase(Param);
308 
309  // Default arguments are only permitted in C++
310  if (!getLangOpts().CPlusPlus) {
311  Diag(EqualLoc, diag::err_param_default_argument)
312  << DefaultArg->getSourceRange();
313  Param->setInvalidDecl();
314  return;
315  }
316 
317  // Check for unexpanded parameter packs.
318  if (DiagnoseUnexpandedParameterPack(DefaultArg, UPPC_DefaultArgument)) {
319  Param->setInvalidDecl();
320  return;
321  }
322 
323  // C++11 [dcl.fct.default]p3
324  // A default argument expression [...] shall not be specified for a
325  // parameter pack.
326  if (Param->isParameterPack()) {
327  Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
328  << DefaultArg->getSourceRange();
329  return;
330  }
331 
332  // Check that the default argument is well-formed
333  CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg, this);
334  if (DefaultArgChecker.Visit(DefaultArg)) {
335  Param->setInvalidDecl();
336  return;
337  }
338 
339  SetParamDefaultArgument(Param, DefaultArg, EqualLoc);
340 }
341 
342 /// ActOnParamUnparsedDefaultArgument - We've seen a default
343 /// argument for a function parameter, but we can't parse it yet
344 /// because we're inside a class definition. Note that this default
345 /// argument will be parsed later.
347  SourceLocation EqualLoc,
348  SourceLocation ArgLoc) {
349  if (!param)
350  return;
351 
352  ParmVarDecl *Param = cast<ParmVarDecl>(param);
353  Param->setUnparsedDefaultArg();
354  UnparsedDefaultArgLocs[Param] = ArgLoc;
355 }
356 
357 /// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
358 /// the default argument for the parameter param failed.
360  SourceLocation EqualLoc) {
361  if (!param)
362  return;
363 
364  ParmVarDecl *Param = cast<ParmVarDecl>(param);
365  Param->setInvalidDecl();
366  UnparsedDefaultArgLocs.erase(Param);
367  Param->setDefaultArg(new(Context)
368  OpaqueValueExpr(EqualLoc,
369  Param->getType().getNonReferenceType(),
370  VK_RValue));
371 }
372 
373 /// CheckExtraCXXDefaultArguments - Check for any extra default
374 /// arguments in the declarator, which is not a function declaration
375 /// or definition and therefore is not permitted to have default
376 /// arguments. This routine should be invoked for every declarator
377 /// that is not a function declaration or definition.
379  // C++ [dcl.fct.default]p3
380  // A default argument expression shall be specified only in the
381  // parameter-declaration-clause of a function declaration or in a
382  // template-parameter (14.1). It shall not be specified for a
383  // parameter pack. If it is specified in a
384  // parameter-declaration-clause, it shall not occur within a
385  // declarator or abstract-declarator of a parameter-declaration.
386  bool MightBeFunction = D.isFunctionDeclarationContext();
387  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
388  DeclaratorChunk &chunk = D.getTypeObject(i);
389  if (chunk.Kind == DeclaratorChunk::Function) {
390  if (MightBeFunction) {
391  // This is a function declaration. It can have default arguments, but
392  // keep looking in case its return type is a function type with default
393  // arguments.
394  MightBeFunction = false;
395  continue;
396  }
397  for (unsigned argIdx = 0, e = chunk.Fun.NumParams; argIdx != e;
398  ++argIdx) {
399  ParmVarDecl *Param = cast<ParmVarDecl>(chunk.Fun.Params[argIdx].Param);
400  if (Param->hasUnparsedDefaultArg()) {
401  std::unique_ptr<CachedTokens> Toks =
402  std::move(chunk.Fun.Params[argIdx].DefaultArgTokens);
403  SourceRange SR;
404  if (Toks->size() > 1)
405  SR = SourceRange((*Toks)[1].getLocation(),
406  Toks->back().getLocation());
407  else
408  SR = UnparsedDefaultArgLocs[Param];
409  Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
410  << SR;
411  } else if (Param->getDefaultArg()) {
412  Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
413  << Param->getDefaultArg()->getSourceRange();
414  Param->setDefaultArg(nullptr);
415  }
416  }
417  } else if (chunk.Kind != DeclaratorChunk::Paren) {
418  MightBeFunction = false;
419  }
420  }
421 }
422 
424  for (unsigned NumParams = FD->getNumParams(); NumParams > 0; --NumParams) {
425  const ParmVarDecl *PVD = FD->getParamDecl(NumParams-1);
426  if (!PVD->hasDefaultArg())
427  return false;
428  if (!PVD->hasInheritedDefaultArg())
429  return true;
430  }
431  return false;
432 }
433 
434 /// MergeCXXFunctionDecl - Merge two declarations of the same C++
435 /// function, once we already know that they have the same
436 /// type. Subroutine of MergeFunctionDecl. Returns true if there was an
437 /// error, false otherwise.
439  Scope *S) {
440  bool Invalid = false;
441 
442  // The declaration context corresponding to the scope is the semantic
443  // parent, unless this is a local function declaration, in which case
444  // it is that surrounding function.
445  DeclContext *ScopeDC = New->isLocalExternDecl()
446  ? New->getLexicalDeclContext()
447  : New->getDeclContext();
448 
449  // Find the previous declaration for the purpose of default arguments.
450  FunctionDecl *PrevForDefaultArgs = Old;
451  for (/**/; PrevForDefaultArgs;
452  // Don't bother looking back past the latest decl if this is a local
453  // extern declaration; nothing else could work.
454  PrevForDefaultArgs = New->isLocalExternDecl()
455  ? nullptr
456  : PrevForDefaultArgs->getPreviousDecl()) {
457  // Ignore hidden declarations.
458  if (!LookupResult::isVisible(*this, PrevForDefaultArgs))
459  continue;
460 
461  if (S && !isDeclInScope(PrevForDefaultArgs, ScopeDC, S) &&
462  !New->isCXXClassMember()) {
463  // Ignore default arguments of old decl if they are not in
464  // the same scope and this is not an out-of-line definition of
465  // a member function.
466  continue;
467  }
468 
469  if (PrevForDefaultArgs->isLocalExternDecl() != New->isLocalExternDecl()) {
470  // If only one of these is a local function declaration, then they are
471  // declared in different scopes, even though isDeclInScope may think
472  // they're in the same scope. (If both are local, the scope check is
473  // sufficient, and if neither is local, then they are in the same scope.)
474  continue;
475  }
476 
477  // We found the right previous declaration.
478  break;
479  }
480 
481  // C++ [dcl.fct.default]p4:
482  // For non-template functions, default arguments can be added in
483  // later declarations of a function in the same
484  // scope. Declarations in different scopes have completely
485  // distinct sets of default arguments. That is, declarations in
486  // inner scopes do not acquire default arguments from
487  // declarations in outer scopes, and vice versa. In a given
488  // function declaration, all parameters subsequent to a
489  // parameter with a default argument shall have default
490  // arguments supplied in this or previous declarations. A
491  // default argument shall not be redefined by a later
492  // declaration (not even to the same value).
493  //
494  // C++ [dcl.fct.default]p6:
495  // Except for member functions of class templates, the default arguments
496  // in a member function definition that appears outside of the class
497  // definition are added to the set of default arguments provided by the
498  // member function declaration in the class definition.
499  for (unsigned p = 0, NumParams = PrevForDefaultArgs
500  ? PrevForDefaultArgs->getNumParams()
501  : 0;
502  p < NumParams; ++p) {
503  ParmVarDecl *OldParam = PrevForDefaultArgs->getParamDecl(p);
504  ParmVarDecl *NewParam = New->getParamDecl(p);
505 
506  bool OldParamHasDfl = OldParam ? OldParam->hasDefaultArg() : false;
507  bool NewParamHasDfl = NewParam->hasDefaultArg();
508 
509  if (OldParamHasDfl && NewParamHasDfl) {
510  unsigned DiagDefaultParamID =
511  diag::err_param_default_argument_redefinition;
512 
513  // MSVC accepts that default parameters be redefined for member functions
514  // of template class. The new default parameter's value is ignored.
515  Invalid = true;
516  if (getLangOpts().MicrosoftExt) {
517  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(New);
518  if (MD && MD->getParent()->getDescribedClassTemplate()) {
519  // Merge the old default argument into the new parameter.
520  NewParam->setHasInheritedDefaultArg();
521  if (OldParam->hasUninstantiatedDefaultArg())
522  NewParam->setUninstantiatedDefaultArg(
523  OldParam->getUninstantiatedDefaultArg());
524  else
525  NewParam->setDefaultArg(OldParam->getInit());
526  DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
527  Invalid = false;
528  }
529  }
530 
531  // FIXME: If we knew where the '=' was, we could easily provide a fix-it
532  // hint here. Alternatively, we could walk the type-source information
533  // for NewParam to find the last source location in the type... but it
534  // isn't worth the effort right now. This is the kind of test case that
535  // is hard to get right:
536  // int f(int);
537  // void g(int (*fp)(int) = f);
538  // void g(int (*fp)(int) = &f);
539  Diag(NewParam->getLocation(), DiagDefaultParamID)
540  << NewParam->getDefaultArgRange();
541 
542  // Look for the function declaration where the default argument was
543  // actually written, which may be a declaration prior to Old.
544  for (auto Older = PrevForDefaultArgs;
545  OldParam->hasInheritedDefaultArg(); /**/) {
546  Older = Older->getPreviousDecl();
547  OldParam = Older->getParamDecl(p);
548  }
549 
550  Diag(OldParam->getLocation(), diag::note_previous_definition)
551  << OldParam->getDefaultArgRange();
552  } else if (OldParamHasDfl) {
553  // Merge the old default argument into the new parameter unless the new
554  // function is a friend declaration in a template class. In the latter
555  // case the default arguments will be inherited when the friend
556  // declaration will be instantiated.
557  if (New->getFriendObjectKind() == Decl::FOK_None ||
559  // It's important to use getInit() here; getDefaultArg()
560  // strips off any top-level ExprWithCleanups.
561  NewParam->setHasInheritedDefaultArg();
562  if (OldParam->hasUnparsedDefaultArg())
563  NewParam->setUnparsedDefaultArg();
564  else if (OldParam->hasUninstantiatedDefaultArg())
565  NewParam->setUninstantiatedDefaultArg(
566  OldParam->getUninstantiatedDefaultArg());
567  else
568  NewParam->setDefaultArg(OldParam->getInit());
569  }
570  } else if (NewParamHasDfl) {
571  if (New->getDescribedFunctionTemplate()) {
572  // Paragraph 4, quoted above, only applies to non-template functions.
573  Diag(NewParam->getLocation(),
574  diag::err_param_default_argument_template_redecl)
575  << NewParam->getDefaultArgRange();
576  Diag(PrevForDefaultArgs->getLocation(),
577  diag::note_template_prev_declaration)
578  << false;
579  } else if (New->getTemplateSpecializationKind()
582  // C++ [temp.expr.spec]p21:
583  // Default function arguments shall not be specified in a declaration
584  // or a definition for one of the following explicit specializations:
585  // - the explicit specialization of a function template;
586  // - the explicit specialization of a member function template;
587  // - the explicit specialization of a member function of a class
588  // template where the class template specialization to which the
589  // member function specialization belongs is implicitly
590  // instantiated.
591  Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
593  << New->getDeclName()
594  << NewParam->getDefaultArgRange();
595  } else if (New->getDeclContext()->isDependentContext()) {
596  // C++ [dcl.fct.default]p6 (DR217):
597  // Default arguments for a member function of a class template shall
598  // be specified on the initial declaration of the member function
599  // within the class template.
600  //
601  // Reading the tea leaves a bit in DR217 and its reference to DR205
602  // leads me to the conclusion that one cannot add default function
603  // arguments for an out-of-line definition of a member function of a
604  // dependent type.
605  int WhichKind = 2;
606  if (CXXRecordDecl *Record
607  = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
608  if (Record->getDescribedClassTemplate())
609  WhichKind = 0;
610  else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
611  WhichKind = 1;
612  else
613  WhichKind = 2;
614  }
615 
616  Diag(NewParam->getLocation(),
617  diag::err_param_default_argument_member_template_redecl)
618  << WhichKind
619  << NewParam->getDefaultArgRange();
620  }
621  }
622  }
623 
624  // DR1344: If a default argument is added outside a class definition and that
625  // default argument makes the function a special member function, the program
626  // is ill-formed. This can only happen for constructors.
627  if (isa<CXXConstructorDecl>(New) &&
629  CXXSpecialMember NewSM = getSpecialMember(cast<CXXMethodDecl>(New)),
630  OldSM = getSpecialMember(cast<CXXMethodDecl>(Old));
631  if (NewSM != OldSM) {
632  ParmVarDecl *NewParam = New->getParamDecl(New->getMinRequiredArguments());
633  assert(NewParam->hasDefaultArg());
634  Diag(NewParam->getLocation(), diag::err_default_arg_makes_ctor_special)
635  << NewParam->getDefaultArgRange() << NewSM;
636  Diag(Old->getLocation(), diag::note_previous_declaration);
637  }
638  }
639 
640  const FunctionDecl *Def;
641  // C++11 [dcl.constexpr]p1: If any declaration of a function or function
642  // template has a constexpr specifier then all its declarations shall
643  // contain the constexpr specifier.
644  if (New->isConstexpr() != Old->isConstexpr()) {
645  Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
646  << New << New->isConstexpr();
647  Diag(Old->getLocation(), diag::note_previous_declaration);
648  Invalid = true;
649  } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
650  Old->isDefined(Def) &&
651  // If a friend function is inlined but does not have 'inline'
652  // specifier, it is a definition. Do not report attribute conflict
653  // in this case, redefinition will be diagnosed later.
654  (New->isInlineSpecified() ||
655  New->getFriendObjectKind() == Decl::FOK_None)) {
656  // C++11 [dcl.fcn.spec]p4:
657  // If the definition of a function appears in a translation unit before its
658  // first declaration as inline, the program is ill-formed.
659  Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
660  Diag(Def->getLocation(), diag::note_previous_definition);
661  Invalid = true;
662  }
663 
664  // FIXME: It's not clear what should happen if multiple declarations of a
665  // deduction guide have different explicitness. For now at least we simply
666  // reject any case where the explicitness changes.
667  auto *NewGuide = dyn_cast<CXXDeductionGuideDecl>(New);
668  if (NewGuide && NewGuide->isExplicitSpecified() !=
669  cast<CXXDeductionGuideDecl>(Old)->isExplicitSpecified()) {
670  Diag(New->getLocation(), diag::err_deduction_guide_explicit_mismatch)
671  << NewGuide->isExplicitSpecified();
672  Diag(Old->getLocation(), diag::note_previous_declaration);
673  }
674 
675  // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
676  // argument expression, that declaration shall be a definition and shall be
677  // the only declaration of the function or function template in the
678  // translation unit.
681  Diag(New->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
682  Diag(Old->getLocation(), diag::note_previous_declaration);
683  Invalid = true;
684  }
685 
686  return Invalid;
687 }
688 
689 NamedDecl *
691  MultiTemplateParamsArg TemplateParamLists) {
692  assert(D.isDecompositionDeclarator());
694 
695  // The syntax only allows a decomposition declarator as a simple-declaration,
696  // a for-range-declaration, or a condition in Clang, but we parse it in more
697  // cases than that.
699  Diag(Decomp.getLSquareLoc(), diag::err_decomp_decl_context)
700  << Decomp.getSourceRange();
701  return nullptr;
702  }
703 
704  if (!TemplateParamLists.empty()) {
705  // FIXME: There's no rule against this, but there are also no rules that
706  // would actually make it usable, so we reject it for now.
707  Diag(TemplateParamLists.front()->getTemplateLoc(),
708  diag::err_decomp_decl_template);
709  return nullptr;
710  }
711 
712  Diag(Decomp.getLSquareLoc(),
713  !getLangOpts().CPlusPlus17
714  ? diag::ext_decomp_decl
716  ? diag::ext_decomp_decl_cond
717  : diag::warn_cxx14_compat_decomp_decl)
718  << Decomp.getSourceRange();
719 
720  // The semantic context is always just the current context.
721  DeclContext *const DC = CurContext;
722 
723  // C++1z [dcl.dcl]/8:
724  // The decl-specifier-seq shall contain only the type-specifier auto
725  // and cv-qualifiers.
726  auto &DS = D.getDeclSpec();
727  {
728  SmallVector<StringRef, 8> BadSpecifiers;
729  SmallVector<SourceLocation, 8> BadSpecifierLocs;
730  if (auto SCS = DS.getStorageClassSpec()) {
731  BadSpecifiers.push_back(DeclSpec::getSpecifierName(SCS));
732  BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());
733  }
734  if (auto TSCS = DS.getThreadStorageClassSpec()) {
735  BadSpecifiers.push_back(DeclSpec::getSpecifierName(TSCS));
736  BadSpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());
737  }
738  if (DS.isConstexprSpecified()) {
739  BadSpecifiers.push_back("constexpr");
740  BadSpecifierLocs.push_back(DS.getConstexprSpecLoc());
741  }
742  if (DS.isInlineSpecified()) {
743  BadSpecifiers.push_back("inline");
744  BadSpecifierLocs.push_back(DS.getInlineSpecLoc());
745  }
746  if (!BadSpecifiers.empty()) {
747  auto &&Err = Diag(BadSpecifierLocs.front(), diag::err_decomp_decl_spec);
748  Err << (int)BadSpecifiers.size()
749  << llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(), " ");
750  // Don't add FixItHints to remove the specifiers; we do still respect
751  // them when building the underlying variable.
752  for (auto Loc : BadSpecifierLocs)
753  Err << SourceRange(Loc, Loc);
754  }
755  // We can't recover from it being declared as a typedef.
756  if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
757  return nullptr;
758  }
759 
760  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
761  QualType R = TInfo->getType();
762 
763  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
764  UPPC_DeclarationType))
765  D.setInvalidType();
766 
767  // The syntax only allows a single ref-qualifier prior to the decomposition
768  // declarator. No other declarator chunks are permitted. Also check the type
769  // specifier here.
770  if (DS.getTypeSpecType() != DeclSpec::TST_auto ||
771  D.hasGroupingParens() || D.getNumTypeObjects() > 1 ||
772  (D.getNumTypeObjects() == 1 &&
774  Diag(Decomp.getLSquareLoc(),
775  (D.hasGroupingParens() ||
776  (D.getNumTypeObjects() &&
778  ? diag::err_decomp_decl_parens
779  : diag::err_decomp_decl_type)
780  << R;
781 
782  // In most cases, there's no actual problem with an explicitly-specified
783  // type, but a function type won't work here, and ActOnVariableDeclarator
784  // shouldn't be called for such a type.
785  if (R->isFunctionType())
786  D.setInvalidType();
787  }
788 
789  // Build the BindingDecls.
791 
792  // Build the BindingDecls.
793  for (auto &B : D.getDecompositionDeclarator().bindings()) {
794  // Check for name conflicts.
795  DeclarationNameInfo NameInfo(B.Name, B.NameLoc);
796  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
797  ForVisibleRedeclaration);
798  LookupName(Previous, S,
799  /*CreateBuiltins*/DC->getRedeclContext()->isTranslationUnit());
800 
801  // It's not permitted to shadow a template parameter name.
802  if (Previous.isSingleResult() &&
803  Previous.getFoundDecl()->isTemplateParameter()) {
804  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
805  Previous.getFoundDecl());
806  Previous.clear();
807  }
808 
809  bool ConsiderLinkage = DC->isFunctionOrMethod() &&
810  DS.getStorageClassSpec() == DeclSpec::SCS_extern;
811  FilterLookupForScope(Previous, DC, S, ConsiderLinkage,
812  /*AllowInlineNamespace*/false);
813  if (!Previous.empty()) {
814  auto *Old = Previous.getRepresentativeDecl();
815  Diag(B.NameLoc, diag::err_redefinition) << B.Name;
816  Diag(Old->getLocation(), diag::note_previous_definition);
817  }
818 
819  auto *BD = BindingDecl::Create(Context, DC, B.NameLoc, B.Name);
820  PushOnScopeChains(BD, S, true);
821  Bindings.push_back(BD);
822  ParsingInitForAutoVars.insert(BD);
823  }
824 
825  // There are no prior lookup results for the variable itself, because it
826  // is unnamed.
827  DeclarationNameInfo NameInfo((IdentifierInfo *)nullptr,
828  Decomp.getLSquareLoc());
829  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
830  ForVisibleRedeclaration);
831 
832  // Build the variable that holds the non-decomposed object.
833  bool AddToScope = true;
834  NamedDecl *New =
835  ActOnVariableDeclarator(S, D, DC, TInfo, Previous,
836  MultiTemplateParamsArg(), AddToScope, Bindings);
837  if (AddToScope) {
838  S->AddDecl(New);
839  CurContext->addHiddenDecl(New);
840  }
841 
842  if (isInOpenMPDeclareTargetContext())
843  checkDeclIsAllowedInOpenMPTarget(nullptr, New);
844 
845  return New;
846 }
847 
849  Sema &S, ArrayRef<BindingDecl *> Bindings, ValueDecl *Src,
850  QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType,
851  llvm::function_ref<ExprResult(SourceLocation, Expr *, unsigned)> GetInit) {
852  if ((int64_t)Bindings.size() != NumElems) {
853  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
854  << DecompType << (unsigned)Bindings.size() << NumElems.toString(10)
855  << (NumElems < Bindings.size());
856  return true;
857  }
858 
859  unsigned I = 0;
860  for (auto *B : Bindings) {
861  SourceLocation Loc = B->getLocation();
862  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
863  if (E.isInvalid())
864  return true;
865  E = GetInit(Loc, E.get(), I++);
866  if (E.isInvalid())
867  return true;
868  B->setBinding(ElemType, E.get());
869  }
870 
871  return false;
872 }
873 
875  ArrayRef<BindingDecl *> Bindings,
876  ValueDecl *Src, QualType DecompType,
877  const llvm::APSInt &NumElems,
878  QualType ElemType) {
880  S, Bindings, Src, DecompType, NumElems, ElemType,
881  [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
882  ExprResult E = S.ActOnIntegerConstant(Loc, I);
883  if (E.isInvalid())
884  return ExprError();
885  return S.CreateBuiltinArraySubscriptExpr(Base, Loc, E.get(), Loc);
886  });
887 }
888 
890  ValueDecl *Src, QualType DecompType,
891  const ConstantArrayType *CAT) {
892  return checkArrayLikeDecomposition(S, Bindings, Src, DecompType,
893  llvm::APSInt(CAT->getSize()),
894  CAT->getElementType());
895 }
896 
898  ValueDecl *Src, QualType DecompType,
899  const VectorType *VT) {
901  S, Bindings, Src, DecompType, llvm::APSInt::get(VT->getNumElements()),
903  DecompType.getQualifiers()));
904 }
905 
907  ArrayRef<BindingDecl *> Bindings,
908  ValueDecl *Src, QualType DecompType,
909  const ComplexType *CT) {
911  S, Bindings, Src, DecompType, llvm::APSInt::get(2),
913  DecompType.getQualifiers()),
914  [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
915  return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
916  });
917 }
918 
920  TemplateArgumentListInfo &Args) {
921  SmallString<128> SS;
922  llvm::raw_svector_ostream OS(SS);
923  bool First = true;
924  for (auto &Arg : Args.arguments()) {
925  if (!First)
926  OS << ", ";
927  Arg.getArgument().print(PrintingPolicy, OS);
928  First = false;
929  }
930  return OS.str();
931 }
932 
933 static bool lookupStdTypeTraitMember(Sema &S, LookupResult &TraitMemberLookup,
934  SourceLocation Loc, StringRef Trait,
936  unsigned DiagID) {
937  auto DiagnoseMissing = [&] {
938  if (DiagID)
939  S.Diag(Loc, DiagID) << printTemplateArgs(S.Context.getPrintingPolicy(),
940  Args);
941  return true;
942  };
943 
944  // FIXME: Factor out duplication with lookupPromiseType in SemaCoroutine.
945  NamespaceDecl *Std = S.getStdNamespace();
946  if (!Std)
947  return DiagnoseMissing();
948 
949  // Look up the trait itself, within namespace std. We can diagnose various
950  // problems with this lookup even if we've been asked to not diagnose a
951  // missing specialization, because this can only fail if the user has been
952  // declaring their own names in namespace std or we don't support the
953  // standard library implementation in use.
956  if (!S.LookupQualifiedName(Result, Std))
957  return DiagnoseMissing();
958  if (Result.isAmbiguous())
959  return true;
960 
961  ClassTemplateDecl *TraitTD = Result.getAsSingle<ClassTemplateDecl>();
962  if (!TraitTD) {
963  Result.suppressDiagnostics();
964  NamedDecl *Found = *Result.begin();
965  S.Diag(Loc, diag::err_std_type_trait_not_class_template) << Trait;
966  S.Diag(Found->getLocation(), diag::note_declared_at);
967  return true;
968  }
969 
970  // Build the template-id.
971  QualType TraitTy = S.CheckTemplateIdType(TemplateName(TraitTD), Loc, Args);
972  if (TraitTy.isNull())
973  return true;
974  if (!S.isCompleteType(Loc, TraitTy)) {
975  if (DiagID)
977  Loc, TraitTy, DiagID,
979  return true;
980  }
981 
982  CXXRecordDecl *RD = TraitTy->getAsCXXRecordDecl();
983  assert(RD && "specialization of class template is not a class?");
984 
985  // Look up the member of the trait type.
986  S.LookupQualifiedName(TraitMemberLookup, RD);
987  return TraitMemberLookup.isAmbiguous();
988 }
989 
990 static TemplateArgumentLoc
992  uint64_t I) {
993  TemplateArgument Arg(S.Context, S.Context.MakeIntValue(I, T), T);
994  return S.getTrivialTemplateArgumentLoc(Arg, T, Loc);
995 }
996 
997 static TemplateArgumentLoc
1000 }
1001 
1002 namespace { enum class IsTupleLike { TupleLike, NotTupleLike, Error }; }
1003 
1005  llvm::APSInt &Size) {
1008 
1010  LookupResult R(S, Value, Loc, Sema::LookupOrdinaryName);
1011 
1012  // Form template argument list for tuple_size<T>.
1013  TemplateArgumentListInfo Args(Loc, Loc);
1015 
1016  // If there's no tuple_size specialization, it's not tuple-like.
1017  if (lookupStdTypeTraitMember(S, R, Loc, "tuple_size", Args, /*DiagID*/0))
1018  return IsTupleLike::NotTupleLike;
1019 
1020  // If we get this far, we've committed to the tuple interpretation, but
1021  // we can still fail if there actually isn't a usable ::value.
1022 
1023  struct ICEDiagnoser : Sema::VerifyICEDiagnoser {
1024  LookupResult &R;
1026  ICEDiagnoser(LookupResult &R, TemplateArgumentListInfo &Args)
1027  : R(R), Args(Args) {}
1028  void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) {
1029  S.Diag(Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
1031  }
1032  } Diagnoser(R, Args);
1033 
1034  if (R.empty()) {
1035  Diagnoser.diagnoseNotICE(S, Loc, SourceRange());
1036  return IsTupleLike::Error;
1037  }
1038 
1039  ExprResult E =
1040  S.BuildDeclarationNameExpr(CXXScopeSpec(), R, /*NeedsADL*/false);
1041  if (E.isInvalid())
1042  return IsTupleLike::Error;
1043 
1044  E = S.VerifyIntegerConstantExpression(E.get(), &Size, Diagnoser, false);
1045  if (E.isInvalid())
1046  return IsTupleLike::Error;
1047 
1048  return IsTupleLike::TupleLike;
1049 }
1050 
1051 /// \return std::tuple_element<I, T>::type.
1053  unsigned I, QualType T) {
1054  // Form template argument list for tuple_element<I, T>.
1055  TemplateArgumentListInfo Args(Loc, Loc);
1056  Args.addArgument(
1059 
1060  DeclarationName TypeDN = S.PP.getIdentifierInfo("type");
1061  LookupResult R(S, TypeDN, Loc, Sema::LookupOrdinaryName);
1063  S, R, Loc, "tuple_element", Args,
1064  diag::err_decomp_decl_std_tuple_element_not_specialized))
1065  return QualType();
1066 
1067  auto *TD = R.getAsSingle<TypeDecl>();
1068  if (!TD) {
1069  R.suppressDiagnostics();
1070  S.Diag(Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
1072  if (!R.empty())
1073  S.Diag(R.getRepresentativeDecl()->getLocation(), diag::note_declared_at);
1074  return QualType();
1075  }
1076 
1077  return S.Context.getTypeDeclType(TD);
1078 }
1079 
1080 namespace {
1081 struct BindingDiagnosticTrap {
1082  Sema &S;
1083  DiagnosticErrorTrap Trap;
1084  BindingDecl *BD;
1085 
1086  BindingDiagnosticTrap(Sema &S, BindingDecl *BD)
1087  : S(S), Trap(S.Diags), BD(BD) {}
1088  ~BindingDiagnosticTrap() {
1089  if (Trap.hasErrorOccurred())
1090  S.Diag(BD->getLocation(), diag::note_in_binding_decl_init) << BD;
1091  }
1092 };
1093 }
1094 
1096  ArrayRef<BindingDecl *> Bindings,
1097  VarDecl *Src, QualType DecompType,
1098  const llvm::APSInt &TupleSize) {
1099  if ((int64_t)Bindings.size() != TupleSize) {
1100  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1101  << DecompType << (unsigned)Bindings.size() << TupleSize.toString(10)
1102  << (TupleSize < Bindings.size());
1103  return true;
1104  }
1105 
1106  if (Bindings.empty())
1107  return false;
1108 
1109  DeclarationName GetDN = S.PP.getIdentifierInfo("get");
1110 
1111  // [dcl.decomp]p3:
1112  // The unqualified-id get is looked up in the scope of E by class member
1113  // access lookup
1114  LookupResult MemberGet(S, GetDN, Src->getLocation(), Sema::LookupMemberName);
1115  bool UseMemberGet = false;
1116  if (S.isCompleteType(Src->getLocation(), DecompType)) {
1117  if (auto *RD = DecompType->getAsCXXRecordDecl())
1118  S.LookupQualifiedName(MemberGet, RD);
1119  if (MemberGet.isAmbiguous())
1120  return true;
1121  UseMemberGet = !MemberGet.empty();
1122  S.FilterAcceptableTemplateNames(MemberGet);
1123  }
1124 
1125  unsigned I = 0;
1126  for (auto *B : Bindings) {
1127  BindingDiagnosticTrap Trap(S, B);
1128  SourceLocation Loc = B->getLocation();
1129 
1130  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1131  if (E.isInvalid())
1132  return true;
1133 
1134  // e is an lvalue if the type of the entity is an lvalue reference and
1135  // an xvalue otherwise
1136  if (!Src->getType()->isLValueReferenceType())
1137  E = ImplicitCastExpr::Create(S.Context, E.get()->getType(), CK_NoOp,
1138  E.get(), nullptr, VK_XValue);
1139 
1140  TemplateArgumentListInfo Args(Loc, Loc);
1141  Args.addArgument(
1143 
1144  if (UseMemberGet) {
1145  // if [lookup of member get] finds at least one declaration, the
1146  // initializer is e.get<i-1>().
1147  E = S.BuildMemberReferenceExpr(E.get(), DecompType, Loc, false,
1148  CXXScopeSpec(), SourceLocation(), nullptr,
1149  MemberGet, &Args, nullptr);
1150  if (E.isInvalid())
1151  return true;
1152 
1153  E = S.ActOnCallExpr(nullptr, E.get(), Loc, None, Loc);
1154  } else {
1155  // Otherwise, the initializer is get<i-1>(e), where get is looked up
1156  // in the associated namespaces.
1159  DeclarationNameInfo(GetDN, Loc), /*RequiresADL*/true, &Args,
1161 
1162  Expr *Arg = E.get();
1163  E = S.ActOnCallExpr(nullptr, Get, Loc, Arg, Loc);
1164  }
1165  if (E.isInvalid())
1166  return true;
1167  Expr *Init = E.get();
1168 
1169  // Given the type T designated by std::tuple_element<i - 1, E>::type,
1170  QualType T = getTupleLikeElementType(S, Loc, I, DecompType);
1171  if (T.isNull())
1172  return true;
1173 
1174  // each vi is a variable of type "reference to T" initialized with the
1175  // initializer, where the reference is an lvalue reference if the
1176  // initializer is an lvalue and an rvalue reference otherwise
1177  QualType RefType =
1178  S.BuildReferenceType(T, E.get()->isLValue(), Loc, B->getDeclName());
1179  if (RefType.isNull())
1180  return true;
1181  auto *RefVD = VarDecl::Create(
1182  S.Context, Src->getDeclContext(), Loc, Loc,
1183  B->getDeclName().getAsIdentifierInfo(), RefType,
1186  RefVD->setTSCSpec(Src->getTSCSpec());
1187  RefVD->setImplicit();
1188  if (Src->isInlineSpecified())
1189  RefVD->setInlineSpecified();
1190  RefVD->getLexicalDeclContext()->addHiddenDecl(RefVD);
1191 
1194  InitializationSequence Seq(S, Entity, Kind, Init);
1195  E = Seq.Perform(S, Entity, Kind, Init);
1196  if (E.isInvalid())
1197  return true;
1198  E = S.ActOnFinishFullExpr(E.get(), Loc);
1199  if (E.isInvalid())
1200  return true;
1201  RefVD->setInit(E.get());
1202  RefVD->checkInitIsICE();
1203 
1205  DeclarationNameInfo(B->getDeclName(), Loc),
1206  RefVD);
1207  if (E.isInvalid())
1208  return true;
1209 
1210  B->setBinding(T, E.get());
1211  I++;
1212  }
1213 
1214  return false;
1215 }
1216 
1217 /// Find the base class to decompose in a built-in decomposition of a class type.
1218 /// This base class search is, unfortunately, not quite like any other that we
1219 /// perform anywhere else in C++.
1221  SourceLocation Loc,
1222  const CXXRecordDecl *RD,
1223  CXXCastPath &BasePath) {
1224  auto BaseHasFields = [](const CXXBaseSpecifier *Specifier,
1225  CXXBasePath &Path) {
1226  return Specifier->getType()->getAsCXXRecordDecl()->hasDirectFields();
1227  };
1228 
1229  const CXXRecordDecl *ClassWithFields = nullptr;
1230  if (RD->hasDirectFields())
1231  // [dcl.decomp]p4:
1232  // Otherwise, all of E's non-static data members shall be public direct
1233  // members of E ...
1234  ClassWithFields = RD;
1235  else {
1236  // ... or of ...
1237  CXXBasePaths Paths;
1238  Paths.setOrigin(const_cast<CXXRecordDecl*>(RD));
1239  if (!RD->lookupInBases(BaseHasFields, Paths)) {
1240  // If no classes have fields, just decompose RD itself. (This will work
1241  // if and only if zero bindings were provided.)
1242  return RD;
1243  }
1244 
1245  CXXBasePath *BestPath = nullptr;
1246  for (auto &P : Paths) {
1247  if (!BestPath)
1248  BestPath = &P;
1249  else if (!S.Context.hasSameType(P.back().Base->getType(),
1250  BestPath->back().Base->getType())) {
1251  // ... the same ...
1252  S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1253  << false << RD << BestPath->back().Base->getType()
1254  << P.back().Base->getType();
1255  return nullptr;
1256  } else if (P.Access < BestPath->Access) {
1257  BestPath = &P;
1258  }
1259  }
1260 
1261  // ... unambiguous ...
1262  QualType BaseType = BestPath->back().Base->getType();
1263  if (Paths.isAmbiguous(S.Context.getCanonicalType(BaseType))) {
1264  S.Diag(Loc, diag::err_decomp_decl_ambiguous_base)
1265  << RD << BaseType << S.getAmbiguousPathsDisplayString(Paths);
1266  return nullptr;
1267  }
1268 
1269  // ... public base class of E.
1270  if (BestPath->Access != AS_public) {
1271  S.Diag(Loc, diag::err_decomp_decl_non_public_base)
1272  << RD << BaseType;
1273  for (auto &BS : *BestPath) {
1274  if (BS.Base->getAccessSpecifier() != AS_public) {
1275  S.Diag(BS.Base->getLocStart(), diag::note_access_constrained_by_path)
1276  << (BS.Base->getAccessSpecifier() == AS_protected)
1277  << (BS.Base->getAccessSpecifierAsWritten() == AS_none);
1278  break;
1279  }
1280  }
1281  return nullptr;
1282  }
1283 
1284  ClassWithFields = BaseType->getAsCXXRecordDecl();
1285  S.BuildBasePathArray(Paths, BasePath);
1286  }
1287 
1288  // The above search did not check whether the selected class itself has base
1289  // classes with fields, so check that now.
1290  CXXBasePaths Paths;
1291  if (ClassWithFields->lookupInBases(BaseHasFields, Paths)) {
1292  S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1293  << (ClassWithFields == RD) << RD << ClassWithFields
1294  << Paths.front().back().Base->getType();
1295  return nullptr;
1296  }
1297 
1298  return ClassWithFields;
1299 }
1300 
1302  ValueDecl *Src, QualType DecompType,
1303  const CXXRecordDecl *RD) {
1304  CXXCastPath BasePath;
1305  RD = findDecomposableBaseClass(S, Src->getLocation(), RD, BasePath);
1306  if (!RD)
1307  return true;
1309  DecompType.getQualifiers());
1310 
1311  auto DiagnoseBadNumberOfBindings = [&]() -> bool {
1312  unsigned NumFields =
1313  std::count_if(RD->field_begin(), RD->field_end(),
1314  [](FieldDecl *FD) { return !FD->isUnnamedBitfield(); });
1315  assert(Bindings.size() != NumFields);
1316  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1317  << DecompType << (unsigned)Bindings.size() << NumFields
1318  << (NumFields < Bindings.size());
1319  return true;
1320  };
1321 
1322  // all of E's non-static data members shall be public [...] members,
1323  // E shall not have an anonymous union member, ...
1324  unsigned I = 0;
1325  for (auto *FD : RD->fields()) {
1326  if (FD->isUnnamedBitfield())
1327  continue;
1328 
1329  if (FD->isAnonymousStructOrUnion()) {
1330  S.Diag(Src->getLocation(), diag::err_decomp_decl_anon_union_member)
1331  << DecompType << FD->getType()->isUnionType();
1332  S.Diag(FD->getLocation(), diag::note_declared_at);
1333  return true;
1334  }
1335 
1336  // We have a real field to bind.
1337  if (I >= Bindings.size())
1338  return DiagnoseBadNumberOfBindings();
1339  auto *B = Bindings[I++];
1340 
1341  SourceLocation Loc = B->getLocation();
1342  if (FD->getAccess() != AS_public) {
1343  S.Diag(Loc, diag::err_decomp_decl_non_public_member) << FD << DecompType;
1344 
1345  // Determine whether the access specifier was explicit.
1346  bool Implicit = true;
1347  for (const auto *D : RD->decls()) {
1348  if (declaresSameEntity(D, FD))
1349  break;
1350  if (isa<AccessSpecDecl>(D)) {
1351  Implicit = false;
1352  break;
1353  }
1354  }
1355 
1356  S.Diag(FD->getLocation(), diag::note_access_natural)
1357  << (FD->getAccess() == AS_protected) << Implicit;
1358  return true;
1359  }
1360 
1361  // Initialize the binding to Src.FD.
1362  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1363  if (E.isInvalid())
1364  return true;
1365  E = S.ImpCastExprToType(E.get(), BaseType, CK_UncheckedDerivedToBase,
1366  VK_LValue, &BasePath);
1367  if (E.isInvalid())
1368  return true;
1369  E = S.BuildFieldReferenceExpr(E.get(), /*IsArrow*/ false, Loc,
1370  CXXScopeSpec(), FD,
1371  DeclAccessPair::make(FD, FD->getAccess()),
1372  DeclarationNameInfo(FD->getDeclName(), Loc));
1373  if (E.isInvalid())
1374  return true;
1375 
1376  // If the type of the member is T, the referenced type is cv T, where cv is
1377  // the cv-qualification of the decomposition expression.
1378  //
1379  // FIXME: We resolve a defect here: if the field is mutable, we do not add
1380  // 'const' to the type of the field.
1381  Qualifiers Q = DecompType.getQualifiers();
1382  if (FD->isMutable())
1383  Q.removeConst();
1384  B->setBinding(S.BuildQualifiedType(FD->getType(), Loc, Q), E.get());
1385  }
1386 
1387  if (I != Bindings.size())
1388  return DiagnoseBadNumberOfBindings();
1389 
1390  return false;
1391 }
1392 
1394  QualType DecompType = DD->getType();
1395 
1396  // If the type of the decomposition is dependent, then so is the type of
1397  // each binding.
1398  if (DecompType->isDependentType()) {
1399  for (auto *B : DD->bindings())
1400  B->setType(Context.DependentTy);
1401  return;
1402  }
1403 
1404  DecompType = DecompType.getNonReferenceType();
1405  ArrayRef<BindingDecl*> Bindings = DD->bindings();
1406 
1407  // C++1z [dcl.decomp]/2:
1408  // If E is an array type [...]
1409  // As an extension, we also support decomposition of built-in complex and
1410  // vector types.
1411  if (auto *CAT = Context.getAsConstantArrayType(DecompType)) {
1412  if (checkArrayDecomposition(*this, Bindings, DD, DecompType, CAT))
1413  DD->setInvalidDecl();
1414  return;
1415  }
1416  if (auto *VT = DecompType->getAs<VectorType>()) {
1417  if (checkVectorDecomposition(*this, Bindings, DD, DecompType, VT))
1418  DD->setInvalidDecl();
1419  return;
1420  }
1421  if (auto *CT = DecompType->getAs<ComplexType>()) {
1422  if (checkComplexDecomposition(*this, Bindings, DD, DecompType, CT))
1423  DD->setInvalidDecl();
1424  return;
1425  }
1426 
1427  // C++1z [dcl.decomp]/3:
1428  // if the expression std::tuple_size<E>::value is a well-formed integral
1429  // constant expression, [...]
1430  llvm::APSInt TupleSize(32);
1431  switch (isTupleLike(*this, DD->getLocation(), DecompType, TupleSize)) {
1432  case IsTupleLike::Error:
1433  DD->setInvalidDecl();
1434  return;
1435 
1436  case IsTupleLike::TupleLike:
1437  if (checkTupleLikeDecomposition(*this, Bindings, DD, DecompType, TupleSize))
1438  DD->setInvalidDecl();
1439  return;
1440 
1441  case IsTupleLike::NotTupleLike:
1442  break;
1443  }
1444 
1445  // C++1z [dcl.dcl]/8:
1446  // [E shall be of array or non-union class type]
1447  CXXRecordDecl *RD = DecompType->getAsCXXRecordDecl();
1448  if (!RD || RD->isUnion()) {
1449  Diag(DD->getLocation(), diag::err_decomp_decl_unbindable_type)
1450  << DD << !RD << DecompType;
1451  DD->setInvalidDecl();
1452  return;
1453  }
1454 
1455  // C++1z [dcl.decomp]/4:
1456  // all of E's non-static data members shall be [...] direct members of
1457  // E or of the same unambiguous public base class of E, ...
1458  if (checkMemberDecomposition(*this, Bindings, DD, DecompType, RD))
1459  DD->setInvalidDecl();
1460 }
1461 
1462 /// \brief Merge the exception specifications of two variable declarations.
1463 ///
1464 /// This is called when there's a redeclaration of a VarDecl. The function
1465 /// checks if the redeclaration might have an exception specification and
1466 /// validates compatibility and merges the specs if necessary.
1468  // Shortcut if exceptions are disabled.
1469  if (!getLangOpts().CXXExceptions)
1470  return;
1471 
1472  assert(Context.hasSameType(New->getType(), Old->getType()) &&
1473  "Should only be called if types are otherwise the same.");
1474 
1475  QualType NewType = New->getType();
1476  QualType OldType = Old->getType();
1477 
1478  // We're only interested in pointers and references to functions, as well
1479  // as pointers to member functions.
1480  if (const ReferenceType *R = NewType->getAs<ReferenceType>()) {
1481  NewType = R->getPointeeType();
1482  OldType = OldType->getAs<ReferenceType>()->getPointeeType();
1483  } else if (const PointerType *P = NewType->getAs<PointerType>()) {
1484  NewType = P->getPointeeType();
1485  OldType = OldType->getAs<PointerType>()->getPointeeType();
1486  } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) {
1487  NewType = M->getPointeeType();
1488  OldType = OldType->getAs<MemberPointerType>()->getPointeeType();
1489  }
1490 
1491  if (!NewType->isFunctionProtoType())
1492  return;
1493 
1494  // There's lots of special cases for functions. For function pointers, system
1495  // libraries are hopefully not as broken so that we don't need these
1496  // workarounds.
1497  if (CheckEquivalentExceptionSpec(
1498  OldType->getAs<FunctionProtoType>(), Old->getLocation(),
1499  NewType->getAs<FunctionProtoType>(), New->getLocation())) {
1500  New->setInvalidDecl();
1501  }
1502 }
1503 
1504 /// CheckCXXDefaultArguments - Verify that the default arguments for a
1505 /// function declaration are well-formed according to C++
1506 /// [dcl.fct.default].
1508  unsigned NumParams = FD->getNumParams();
1509  unsigned p;
1510 
1511  // Find first parameter with a default argument
1512  for (p = 0; p < NumParams; ++p) {
1513  ParmVarDecl *Param = FD->getParamDecl(p);
1514  if (Param->hasDefaultArg())
1515  break;
1516  }
1517 
1518  // C++11 [dcl.fct.default]p4:
1519  // In a given function declaration, each parameter subsequent to a parameter
1520  // with a default argument shall have a default argument supplied in this or
1521  // a previous declaration or shall be a function parameter pack. A default
1522  // argument shall not be redefined by a later declaration (not even to the
1523  // same value).
1524  unsigned LastMissingDefaultArg = 0;
1525  for (; p < NumParams; ++p) {
1526  ParmVarDecl *Param = FD->getParamDecl(p);
1527  if (!Param->hasDefaultArg() && !Param->isParameterPack()) {
1528  if (Param->isInvalidDecl())
1529  /* We already complained about this parameter. */;
1530  else if (Param->getIdentifier())
1531  Diag(Param->getLocation(),
1532  diag::err_param_default_argument_missing_name)
1533  << Param->getIdentifier();
1534  else
1535  Diag(Param->getLocation(),
1536  diag::err_param_default_argument_missing);
1537 
1538  LastMissingDefaultArg = p;
1539  }
1540  }
1541 
1542  if (LastMissingDefaultArg > 0) {
1543  // Some default arguments were missing. Clear out all of the
1544  // default arguments up to (and including) the last missing
1545  // default argument, so that we leave the function parameters
1546  // in a semantically valid state.
1547  for (p = 0; p <= LastMissingDefaultArg; ++p) {
1548  ParmVarDecl *Param = FD->getParamDecl(p);
1549  if (Param->hasDefaultArg()) {
1550  Param->setDefaultArg(nullptr);
1551  }
1552  }
1553  }
1554 }
1555 
1556 // CheckConstexprParameterTypes - Check whether a function's parameter types
1557 // are all literal types. If so, return true. If not, produce a suitable
1558 // diagnostic and return false.
1559 static bool CheckConstexprParameterTypes(Sema &SemaRef,
1560  const FunctionDecl *FD) {
1561  unsigned ArgIndex = 0;
1562  const FunctionProtoType *FT = FD->getType()->getAs<FunctionProtoType>();
1564  e = FT->param_type_end();
1565  i != e; ++i, ++ArgIndex) {
1566  const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
1567  SourceLocation ParamLoc = PD->getLocation();
1568  if (!(*i)->isDependentType() &&
1569  SemaRef.RequireLiteralType(ParamLoc, *i,
1570  diag::err_constexpr_non_literal_param,
1571  ArgIndex+1, PD->getSourceRange(),
1572  isa<CXXConstructorDecl>(FD)))
1573  return false;
1574  }
1575  return true;
1576 }
1577 
1578 /// \brief Get diagnostic %select index for tag kind for
1579 /// record diagnostic message.
1580 /// WARNING: Indexes apply to particular diagnostics only!
1581 ///
1582 /// \returns diagnostic %select index.
1584  switch (Tag) {
1585  case TTK_Struct: return 0;
1586  case TTK_Interface: return 1;
1587  case TTK_Class: return 2;
1588  default: llvm_unreachable("Invalid tag kind for record diagnostic!");
1589  }
1590 }
1591 
1592 // CheckConstexprFunctionDecl - Check whether a function declaration satisfies
1593 // the requirements of a constexpr function definition or a constexpr
1594 // constructor definition. If so, return true. If not, produce appropriate
1595 // diagnostics and return false.
1596 //
1597 // This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360.
1599  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
1600  if (MD && MD->isInstance()) {
1601  // C++11 [dcl.constexpr]p4:
1602  // The definition of a constexpr constructor shall satisfy the following
1603  // constraints:
1604  // - the class shall not have any virtual base classes;
1605  const CXXRecordDecl *RD = MD->getParent();
1606  if (RD->getNumVBases()) {
1607  Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base)
1608  << isa<CXXConstructorDecl>(NewFD)
1610  for (const auto &I : RD->vbases())
1611  Diag(I.getLocStart(),
1612  diag::note_constexpr_virtual_base_here) << I.getSourceRange();
1613  return false;
1614  }
1615  }
1616 
1617  if (!isa<CXXConstructorDecl>(NewFD)) {
1618  // C++11 [dcl.constexpr]p3:
1619  // The definition of a constexpr function shall satisfy the following
1620  // constraints:
1621  // - it shall not be virtual;
1622  const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
1623  if (Method && Method->isVirtual()) {
1624  Method = Method->getCanonicalDecl();
1625  Diag(Method->getLocation(), diag::err_constexpr_virtual);
1626 
1627  // If it's not obvious why this function is virtual, find an overridden
1628  // function which uses the 'virtual' keyword.
1629  const CXXMethodDecl *WrittenVirtual = Method;
1630  while (!WrittenVirtual->isVirtualAsWritten())
1631  WrittenVirtual = *WrittenVirtual->begin_overridden_methods();
1632  if (WrittenVirtual != Method)
1633  Diag(WrittenVirtual->getLocation(),
1634  diag::note_overridden_virtual_function);
1635  return false;
1636  }
1637 
1638  // - its return type shall be a literal type;
1639  QualType RT = NewFD->getReturnType();
1640  if (!RT->isDependentType() &&
1641  RequireLiteralType(NewFD->getLocation(), RT,
1642  diag::err_constexpr_non_literal_return))
1643  return false;
1644  }
1645 
1646  // - each of its parameter types shall be a literal type;
1647  if (!CheckConstexprParameterTypes(*this, NewFD))
1648  return false;
1649 
1650  return true;
1651 }
1652 
1653 /// Check the given declaration statement is legal within a constexpr function
1654 /// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.
1655 ///
1656 /// \return true if the body is OK (maybe only as an extension), false if we
1657 /// have diagnosed a problem.
1658 static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
1659  DeclStmt *DS, SourceLocation &Cxx1yLoc) {
1660  // C++11 [dcl.constexpr]p3 and p4:
1661  // The definition of a constexpr function(p3) or constructor(p4) [...] shall
1662  // contain only
1663  for (const auto *DclIt : DS->decls()) {
1664  switch (DclIt->getKind()) {
1665  case Decl::StaticAssert:
1666  case Decl::Using:
1667  case Decl::UsingShadow:
1668  case Decl::UsingDirective:
1669  case Decl::UnresolvedUsingTypename:
1670  case Decl::UnresolvedUsingValue:
1671  // - static_assert-declarations
1672  // - using-declarations,
1673  // - using-directives,
1674  continue;
1675 
1676  case Decl::Typedef:
1677  case Decl::TypeAlias: {
1678  // - typedef declarations and alias-declarations that do not define
1679  // classes or enumerations,
1680  const auto *TN = cast<TypedefNameDecl>(DclIt);
1681  if (TN->getUnderlyingType()->isVariablyModifiedType()) {
1682  // Don't allow variably-modified types in constexpr functions.
1683  TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
1684  SemaRef.Diag(TL.getBeginLoc(), diag::err_constexpr_vla)
1685  << TL.getSourceRange() << TL.getType()
1686  << isa<CXXConstructorDecl>(Dcl);
1687  return false;
1688  }
1689  continue;
1690  }
1691 
1692  case Decl::Enum:
1693  case Decl::CXXRecord:
1694  // C++1y allows types to be defined, not just declared.
1695  if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition())
1696  SemaRef.Diag(DS->getLocStart(),
1697  SemaRef.getLangOpts().CPlusPlus14
1698  ? diag::warn_cxx11_compat_constexpr_type_definition
1699  : diag::ext_constexpr_type_definition)
1700  << isa<CXXConstructorDecl>(Dcl);
1701  continue;
1702 
1703  case Decl::EnumConstant:
1704  case Decl::IndirectField:
1705  case Decl::ParmVar:
1706  // These can only appear with other declarations which are banned in
1707  // C++11 and permitted in C++1y, so ignore them.
1708  continue;
1709 
1710  case Decl::Var:
1711  case Decl::Decomposition: {
1712  // C++1y [dcl.constexpr]p3 allows anything except:
1713  // a definition of a variable of non-literal type or of static or
1714  // thread storage duration or for which no initialization is performed.
1715  const auto *VD = cast<VarDecl>(DclIt);
1716  if (VD->isThisDeclarationADefinition()) {
1717  if (VD->isStaticLocal()) {
1718  SemaRef.Diag(VD->getLocation(),
1719  diag::err_constexpr_local_var_static)
1720  << isa<CXXConstructorDecl>(Dcl)
1721  << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
1722  return false;
1723  }
1724  if (!VD->getType()->isDependentType() &&
1725  SemaRef.RequireLiteralType(
1726  VD->getLocation(), VD->getType(),
1727  diag::err_constexpr_local_var_non_literal_type,
1728  isa<CXXConstructorDecl>(Dcl)))
1729  return false;
1730  if (!VD->getType()->isDependentType() &&
1731  !VD->hasInit() && !VD->isCXXForRangeDecl()) {
1732  SemaRef.Diag(VD->getLocation(),
1733  diag::err_constexpr_local_var_no_init)
1734  << isa<CXXConstructorDecl>(Dcl);
1735  return false;
1736  }
1737  }
1738  SemaRef.Diag(VD->getLocation(),
1739  SemaRef.getLangOpts().CPlusPlus14
1740  ? diag::warn_cxx11_compat_constexpr_local_var
1741  : diag::ext_constexpr_local_var)
1742  << isa<CXXConstructorDecl>(Dcl);
1743  continue;
1744  }
1745 
1746  case Decl::NamespaceAlias:
1747  case Decl::Function:
1748  // These are disallowed in C++11 and permitted in C++1y. Allow them
1749  // everywhere as an extension.
1750  if (!Cxx1yLoc.isValid())
1751  Cxx1yLoc = DS->getLocStart();
1752  continue;
1753 
1754  default:
1755  SemaRef.Diag(DS->getLocStart(), diag::err_constexpr_body_invalid_stmt)
1756  << isa<CXXConstructorDecl>(Dcl);
1757  return false;
1758  }
1759  }
1760 
1761  return true;
1762 }
1763 
1764 /// Check that the given field is initialized within a constexpr constructor.
1765 ///
1766 /// \param Dcl The constexpr constructor being checked.
1767 /// \param Field The field being checked. This may be a member of an anonymous
1768 /// struct or union nested within the class being checked.
1769 /// \param Inits All declarations, including anonymous struct/union members and
1770 /// indirect members, for which any initialization was provided.
1771 /// \param Diagnosed Set to true if an error is produced.
1773  const FunctionDecl *Dcl,
1774  FieldDecl *Field,
1775  llvm::SmallSet<Decl*, 16> &Inits,
1776  bool &Diagnosed) {
1777  if (Field->isInvalidDecl())
1778  return;
1779 
1780  if (Field->isUnnamedBitfield())
1781  return;
1782 
1783  // Anonymous unions with no variant members and empty anonymous structs do not
1784  // need to be explicitly initialized. FIXME: Anonymous structs that contain no
1785  // indirect fields don't need initializing.
1786  if (Field->isAnonymousStructOrUnion() &&
1787  (Field->getType()->isUnionType()
1788  ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
1789  : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
1790  return;
1791 
1792  if (!Inits.count(Field)) {
1793  if (!Diagnosed) {
1794  SemaRef.Diag(Dcl->getLocation(), diag::err_constexpr_ctor_missing_init);
1795  Diagnosed = true;
1796  }
1797  SemaRef.Diag(Field->getLocation(), diag::note_constexpr_ctor_missing_init);
1798  } else if (Field->isAnonymousStructOrUnion()) {
1799  const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
1800  for (auto *I : RD->fields())
1801  // If an anonymous union contains an anonymous struct of which any member
1802  // is initialized, all members must be initialized.
1803  if (!RD->isUnion() || Inits.count(I))
1804  CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed);
1805  }
1806 }
1807 
1808 /// Check the provided statement is allowed in a constexpr function
1809 /// definition.
1810 static bool
1812  SmallVectorImpl<SourceLocation> &ReturnStmts,
1813  SourceLocation &Cxx1yLoc) {
1814  // - its function-body shall be [...] a compound-statement that contains only
1815  switch (S->getStmtClass()) {
1816  case Stmt::NullStmtClass:
1817  // - null statements,
1818  return true;
1819 
1820  case Stmt::DeclStmtClass:
1821  // - static_assert-declarations
1822  // - using-declarations,
1823  // - using-directives,
1824  // - typedef declarations and alias-declarations that do not define
1825  // classes or enumerations,
1826  if (!CheckConstexprDeclStmt(SemaRef, Dcl, cast<DeclStmt>(S), Cxx1yLoc))
1827  return false;
1828  return true;
1829 
1830  case Stmt::ReturnStmtClass:
1831  // - and exactly one return statement;
1832  if (isa<CXXConstructorDecl>(Dcl)) {
1833  // C++1y allows return statements in constexpr constructors.
1834  if (!Cxx1yLoc.isValid())
1835  Cxx1yLoc = S->getLocStart();
1836  return true;
1837  }
1838 
1839  ReturnStmts.push_back(S->getLocStart());
1840  return true;
1841 
1842  case Stmt::CompoundStmtClass: {
1843  // C++1y allows compound-statements.
1844  if (!Cxx1yLoc.isValid())
1845  Cxx1yLoc = S->getLocStart();
1846 
1847  CompoundStmt *CompStmt = cast<CompoundStmt>(S);
1848  for (auto *BodyIt : CompStmt->body()) {
1849  if (!CheckConstexprFunctionStmt(SemaRef, Dcl, BodyIt, ReturnStmts,
1850  Cxx1yLoc))
1851  return false;
1852  }
1853  return true;
1854  }
1855 
1856  case Stmt::AttributedStmtClass:
1857  if (!Cxx1yLoc.isValid())
1858  Cxx1yLoc = S->getLocStart();
1859  return true;
1860 
1861  case Stmt::IfStmtClass: {
1862  // C++1y allows if-statements.
1863  if (!Cxx1yLoc.isValid())
1864  Cxx1yLoc = S->getLocStart();
1865 
1866  IfStmt *If = cast<IfStmt>(S);
1867  if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
1868  Cxx1yLoc))
1869  return false;
1870  if (If->getElse() &&
1871  !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
1872  Cxx1yLoc))
1873  return false;
1874  return true;
1875  }
1876 
1877  case Stmt::WhileStmtClass:
1878  case Stmt::DoStmtClass:
1879  case Stmt::ForStmtClass:
1880  case Stmt::CXXForRangeStmtClass:
1881  case Stmt::ContinueStmtClass:
1882  // C++1y allows all of these. We don't allow them as extensions in C++11,
1883  // because they don't make sense without variable mutation.
1884  if (!SemaRef.getLangOpts().CPlusPlus14)
1885  break;
1886  if (!Cxx1yLoc.isValid())
1887  Cxx1yLoc = S->getLocStart();
1888  for (Stmt *SubStmt : S->children())
1889  if (SubStmt &&
1890  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
1891  Cxx1yLoc))
1892  return false;
1893  return true;
1894 
1895  case Stmt::SwitchStmtClass:
1896  case Stmt::CaseStmtClass:
1897  case Stmt::DefaultStmtClass:
1898  case Stmt::BreakStmtClass:
1899  // C++1y allows switch-statements, and since they don't need variable
1900  // mutation, we can reasonably allow them in C++11 as an extension.
1901  if (!Cxx1yLoc.isValid())
1902  Cxx1yLoc = S->getLocStart();
1903  for (Stmt *SubStmt : S->children())
1904  if (SubStmt &&
1905  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
1906  Cxx1yLoc))
1907  return false;
1908  return true;
1909 
1910  default:
1911  if (!isa<Expr>(S))
1912  break;
1913 
1914  // C++1y allows expression-statements.
1915  if (!Cxx1yLoc.isValid())
1916  Cxx1yLoc = S->getLocStart();
1917  return true;
1918  }
1919 
1920  SemaRef.Diag(S->getLocStart(), diag::err_constexpr_body_invalid_stmt)
1921  << isa<CXXConstructorDecl>(Dcl);
1922  return false;
1923 }
1924 
1925 /// Check the body for the given constexpr function declaration only contains
1926 /// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.
1927 ///
1928 /// \return true if the body is OK, false if we have diagnosed a problem.
1930  if (isa<CXXTryStmt>(Body)) {
1931  // C++11 [dcl.constexpr]p3:
1932  // The definition of a constexpr function shall satisfy the following
1933  // constraints: [...]
1934  // - its function-body shall be = delete, = default, or a
1935  // compound-statement
1936  //
1937  // C++11 [dcl.constexpr]p4:
1938  // In the definition of a constexpr constructor, [...]
1939  // - its function-body shall not be a function-try-block;
1940  Diag(Body->getLocStart(), diag::err_constexpr_function_try_block)
1941  << isa<CXXConstructorDecl>(Dcl);
1942  return false;
1943  }
1944 
1945  SmallVector<SourceLocation, 4> ReturnStmts;
1946 
1947  // - its function-body shall be [...] a compound-statement that contains only
1948  // [... list of cases ...]
1949  CompoundStmt *CompBody = cast<CompoundStmt>(Body);
1950  SourceLocation Cxx1yLoc;
1951  for (auto *BodyIt : CompBody->body()) {
1952  if (!CheckConstexprFunctionStmt(*this, Dcl, BodyIt, ReturnStmts, Cxx1yLoc))
1953  return false;
1954  }
1955 
1956  if (Cxx1yLoc.isValid())
1957  Diag(Cxx1yLoc,
1958  getLangOpts().CPlusPlus14
1959  ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
1960  : diag::ext_constexpr_body_invalid_stmt)
1961  << isa<CXXConstructorDecl>(Dcl);
1962 
1963  if (const CXXConstructorDecl *Constructor
1964  = dyn_cast<CXXConstructorDecl>(Dcl)) {
1965  const CXXRecordDecl *RD = Constructor->getParent();
1966  // DR1359:
1967  // - every non-variant non-static data member and base class sub-object
1968  // shall be initialized;
1969  // DR1460:
1970  // - if the class is a union having variant members, exactly one of them
1971  // shall be initialized;
1972  if (RD->isUnion()) {
1973  if (Constructor->getNumCtorInitializers() == 0 &&
1974  RD->hasVariantMembers()) {
1975  Diag(Dcl->getLocation(), diag::err_constexpr_union_ctor_no_init);
1976  return false;
1977  }
1978  } else if (!Constructor->isDependentContext() &&
1979  !Constructor->isDelegatingConstructor()) {
1980  assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases");
1981 
1982  // Skip detailed checking if we have enough initializers, and we would
1983  // allow at most one initializer per member.
1984  bool AnyAnonStructUnionMembers = false;
1985  unsigned Fields = 0;
1987  E = RD->field_end(); I != E; ++I, ++Fields) {
1988  if (I->isAnonymousStructOrUnion()) {
1989  AnyAnonStructUnionMembers = true;
1990  break;
1991  }
1992  }
1993  // DR1460:
1994  // - if the class is a union-like class, but is not a union, for each of
1995  // its anonymous union members having variant members, exactly one of
1996  // them shall be initialized;
1997  if (AnyAnonStructUnionMembers ||
1998  Constructor->getNumCtorInitializers() != RD->getNumBases() + Fields) {
1999  // Check initialization of non-static data members. Base classes are
2000  // always initialized so do not need to be checked. Dependent bases
2001  // might not have initializers in the member initializer list.
2002  llvm::SmallSet<Decl*, 16> Inits;
2003  for (const auto *I: Constructor->inits()) {
2004  if (FieldDecl *FD = I->getMember())
2005  Inits.insert(FD);
2006  else if (IndirectFieldDecl *ID = I->getIndirectMember())
2007  Inits.insert(ID->chain_begin(), ID->chain_end());
2008  }
2009 
2010  bool Diagnosed = false;
2011  for (auto *I : RD->fields())
2012  CheckConstexprCtorInitializer(*this, Dcl, I, Inits, Diagnosed);
2013  if (Diagnosed)
2014  return false;
2015  }
2016  }
2017  } else {
2018  if (ReturnStmts.empty()) {
2019  // C++1y doesn't require constexpr functions to contain a 'return'
2020  // statement. We still do, unless the return type might be void, because
2021  // otherwise if there's no return statement, the function cannot
2022  // be used in a core constant expression.
2023  bool OK = getLangOpts().CPlusPlus14 &&
2024  (Dcl->getReturnType()->isVoidType() ||
2025  Dcl->getReturnType()->isDependentType());
2026  Diag(Dcl->getLocation(),
2027  OK ? diag::warn_cxx11_compat_constexpr_body_no_return
2028  : diag::err_constexpr_body_no_return);
2029  if (!OK)
2030  return false;
2031  } else if (ReturnStmts.size() > 1) {
2032  Diag(ReturnStmts.back(),
2033  getLangOpts().CPlusPlus14
2034  ? diag::warn_cxx11_compat_constexpr_body_multiple_return
2035  : diag::ext_constexpr_body_multiple_return);
2036  for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
2037  Diag(ReturnStmts[I], diag::note_constexpr_body_previous_return);
2038  }
2039  }
2040 
2041  // C++11 [dcl.constexpr]p5:
2042  // if no function argument values exist such that the function invocation
2043  // substitution would produce a constant expression, the program is
2044  // ill-formed; no diagnostic required.
2045  // C++11 [dcl.constexpr]p3:
2046  // - every constructor call and implicit conversion used in initializing the
2047  // return value shall be one of those allowed in a constant expression.
2048  // C++11 [dcl.constexpr]p4:
2049  // - every constructor involved in initializing non-static data members and
2050  // base class sub-objects shall be a constexpr constructor.
2052  if (!Expr::isPotentialConstantExpr(Dcl, Diags)) {
2053  Diag(Dcl->getLocation(), diag::ext_constexpr_function_never_constant_expr)
2054  << isa<CXXConstructorDecl>(Dcl);
2055  for (size_t I = 0, N = Diags.size(); I != N; ++I)
2056  Diag(Diags[I].first, Diags[I].second);
2057  // Don't return false here: we allow this for compatibility in
2058  // system headers.
2059  }
2060 
2061  return true;
2062 }
2063 
2064 /// isCurrentClassName - Determine whether the identifier II is the
2065 /// name of the class type currently being defined. In the case of
2066 /// nested classes, this will only return true if II is the name of
2067 /// the innermost class.
2069  const CXXScopeSpec *SS) {
2070  assert(getLangOpts().CPlusPlus && "No class names in C!");
2071 
2072  CXXRecordDecl *CurDecl;
2073  if (SS && SS->isSet() && !SS->isInvalid()) {
2074  DeclContext *DC = computeDeclContext(*SS, true);
2075  CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
2076  } else
2077  CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
2078 
2079  if (CurDecl && CurDecl->getIdentifier())
2080  return &II == CurDecl->getIdentifier();
2081  return false;
2082 }
2083 
2084 /// \brief Determine whether the identifier II is a typo for the name of
2085 /// the class type currently being defined. If so, update it to the identifier
2086 /// that should have been used.
2088  assert(getLangOpts().CPlusPlus && "No class names in C!");
2089 
2090  if (!getLangOpts().SpellChecking)
2091  return false;
2092 
2093  CXXRecordDecl *CurDecl;
2094  if (SS && SS->isSet() && !SS->isInvalid()) {
2095  DeclContext *DC = computeDeclContext(*SS, true);
2096  CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
2097  } else
2098  CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
2099 
2100  if (CurDecl && CurDecl->getIdentifier() && II != CurDecl->getIdentifier() &&
2101  3 * II->getName().edit_distance(CurDecl->getIdentifier()->getName())
2102  < II->getLength()) {
2103  II = CurDecl->getIdentifier();
2104  return true;
2105  }
2106 
2107  return false;
2108 }
2109 
2110 /// \brief Determine whether the given class is a base class of the given
2111 /// class, including looking at dependent bases.
2112 static bool findCircularInheritance(const CXXRecordDecl *Class,
2113  const CXXRecordDecl *Current) {
2115 
2116  Class = Class->getCanonicalDecl();
2117  while (true) {
2118  for (const auto &I : Current->bases()) {
2119  CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl();
2120  if (!Base)
2121  continue;
2122 
2123  Base = Base->getDefinition();
2124  if (!Base)
2125  continue;
2126 
2127  if (Base->getCanonicalDecl() == Class)
2128  return true;
2129 
2130  Queue.push_back(Base);
2131  }
2132 
2133  if (Queue.empty())
2134  return false;
2135 
2136  Current = Queue.pop_back_val();
2137  }
2138 
2139  return false;
2140 }
2141 
2142 /// \brief Check the validity of a C++ base class specifier.
2143 ///
2144 /// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
2145 /// and returns NULL otherwise.
2148  SourceRange SpecifierRange,
2149  bool Virtual, AccessSpecifier Access,
2150  TypeSourceInfo *TInfo,
2151  SourceLocation EllipsisLoc) {
2152  QualType BaseType = TInfo->getType();
2153 
2154  // C++ [class.union]p1:
2155  // A union shall not have base classes.
2156  if (Class->isUnion()) {
2157  Diag(Class->getLocation(), diag::err_base_clause_on_union)
2158  << SpecifierRange;
2159  return nullptr;
2160  }
2161 
2162  if (EllipsisLoc.isValid() &&
2164  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
2165  << TInfo->getTypeLoc().getSourceRange();
2166  EllipsisLoc = SourceLocation();
2167  }
2168 
2169  SourceLocation BaseLoc = TInfo->getTypeLoc().getBeginLoc();
2170 
2171  if (BaseType->isDependentType()) {
2172  // Make sure that we don't have circular inheritance among our dependent
2173  // bases. For non-dependent bases, the check for completeness below handles
2174  // this.
2175  if (CXXRecordDecl *BaseDecl = BaseType->getAsCXXRecordDecl()) {
2176  if (BaseDecl->getCanonicalDecl() == Class->getCanonicalDecl() ||
2177  ((BaseDecl = BaseDecl->getDefinition()) &&
2178  findCircularInheritance(Class, BaseDecl))) {
2179  Diag(BaseLoc, diag::err_circular_inheritance)
2180  << BaseType << Context.getTypeDeclType(Class);
2181 
2182  if (BaseDecl->getCanonicalDecl() != Class->getCanonicalDecl())
2183  Diag(BaseDecl->getLocation(), diag::note_previous_decl)
2184  << BaseType;
2185 
2186  return nullptr;
2187  }
2188  }
2189 
2190  return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
2191  Class->getTagKind() == TTK_Class,
2192  Access, TInfo, EllipsisLoc);
2193  }
2194 
2195  // Base specifiers must be record types.
2196  if (!BaseType->isRecordType()) {
2197  Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
2198  return nullptr;
2199  }
2200 
2201  // C++ [class.union]p1:
2202  // A union shall not be used as a base class.
2203  if (BaseType->isUnionType()) {
2204  Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
2205  return nullptr;
2206  }
2207 
2208  // For the MS ABI, propagate DLL attributes to base class templates.
2209  if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
2210  if (Attr *ClassAttr = getDLLAttr(Class)) {
2211  if (auto *BaseTemplate = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
2212  BaseType->getAsCXXRecordDecl())) {
2213  propagateDLLAttrToBaseClassTemplate(Class, ClassAttr, BaseTemplate,
2214  BaseLoc);
2215  }
2216  }
2217  }
2218 
2219  // C++ [class.derived]p2:
2220  // The class-name in a base-specifier shall not be an incompletely
2221  // defined class.
2222  if (RequireCompleteType(BaseLoc, BaseType,
2223  diag::err_incomplete_base_class, SpecifierRange)) {
2224  Class->setInvalidDecl();
2225  return nullptr;
2226  }
2227 
2228  // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
2229  RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl();
2230  assert(BaseDecl && "Record type has no declaration");
2231  BaseDecl = BaseDecl->getDefinition();
2232  assert(BaseDecl && "Base type is not incomplete, but has no definition");
2233  CXXRecordDecl *CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
2234  assert(CXXBaseDecl && "Base type is not a C++ type");
2235 
2236  // A class which contains a flexible array member is not suitable for use as a
2237  // base class:
2238  // - If the layout determines that a base comes before another base,
2239  // the flexible array member would index into the subsequent base.
2240  // - If the layout determines that base comes before the derived class,
2241  // the flexible array member would index into the derived class.
2242  if (CXXBaseDecl->hasFlexibleArrayMember()) {
2243  Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
2244  << CXXBaseDecl->getDeclName();
2245  return nullptr;
2246  }
2247 
2248  // C++ [class]p3:
2249  // If a class is marked final and it appears as a base-type-specifier in
2250  // base-clause, the program is ill-formed.
2251  if (FinalAttr *FA = CXXBaseDecl->getAttr<FinalAttr>()) {
2252  Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
2253  << CXXBaseDecl->getDeclName()
2254  << FA->isSpelledAsSealed();
2255  Diag(CXXBaseDecl->getLocation(), diag::note_entity_declared_at)
2256  << CXXBaseDecl->getDeclName() << FA->getRange();
2257  return nullptr;
2258  }
2259 
2260  if (BaseDecl->isInvalidDecl())
2261  Class->setInvalidDecl();
2262 
2263  // Create the base specifier.
2264  return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
2265  Class->getTagKind() == TTK_Class,
2266  Access, TInfo, EllipsisLoc);
2267 }
2268 
2269 /// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
2270 /// one entry in the base class list of a class specifier, for
2271 /// example:
2272 /// class foo : public bar, virtual private baz {
2273 /// 'public bar' and 'virtual private baz' are each base-specifiers.
2274 BaseResult
2275 Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange,
2276  ParsedAttributes &Attributes,
2277  bool Virtual, AccessSpecifier Access,
2278  ParsedType basetype, SourceLocation BaseLoc,
2279  SourceLocation EllipsisLoc) {
2280  if (!classdecl)
2281  return true;
2282 
2283  AdjustDeclIfTemplate(classdecl);
2284  CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl);
2285  if (!Class)
2286  return true;
2287 
2288  // We haven't yet attached the base specifiers.
2289  Class->setIsParsingBaseSpecifiers();
2290 
2291  // We do not support any C++11 attributes on base-specifiers yet.
2292  // Diagnose any attributes we see.
2293  if (!Attributes.empty()) {
2294  for (AttributeList *Attr = Attributes.getList(); Attr;
2295  Attr = Attr->getNext()) {
2296  if (Attr->isInvalid() ||
2298  continue;
2299  Diag(Attr->getLoc(),
2301  ? diag::warn_unknown_attribute_ignored
2302  : diag::err_base_specifier_attribute)
2303  << Attr->getName();
2304  }
2305  }
2306 
2307  TypeSourceInfo *TInfo = nullptr;
2308  GetTypeFromParser(basetype, &TInfo);
2309 
2310  if (EllipsisLoc.isInvalid() &&
2311  DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo,
2312  UPPC_BaseType))
2313  return true;
2314 
2315  if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
2316  Virtual, Access, TInfo,
2317  EllipsisLoc))
2318  return BaseSpec;
2319  else
2320  Class->setInvalidDecl();
2321 
2322  return true;
2323 }
2324 
2325 /// Use small set to collect indirect bases. As this is only used
2326 /// locally, there's no need to abstract the small size parameter.
2327 typedef llvm::SmallPtrSet<QualType, 4> IndirectBaseSet;
2328 
2329 /// \brief Recursively add the bases of Type. Don't add Type itself.
2330 static void
2331 NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set,
2332  const QualType &Type)
2333 {
2334  // Even though the incoming type is a base, it might not be
2335  // a class -- it could be a template parm, for instance.
2336  if (auto Rec = Type->getAs<RecordType>()) {
2337  auto Decl = Rec->getAsCXXRecordDecl();
2338 
2339  // Iterate over its bases.
2340  for (const auto &BaseSpec : Decl->bases()) {
2341  QualType Base = Context.getCanonicalType(BaseSpec.getType())
2342  .getUnqualifiedType();
2343  if (Set.insert(Base).second)
2344  // If we've not already seen it, recurse.
2345  NoteIndirectBases(Context, Set, Base);
2346  }
2347  }
2348 }
2349 
2350 /// \brief Performs the actual work of attaching the given base class
2351 /// specifiers to a C++ class.
2354  if (Bases.empty())
2355  return false;
2356 
2357  // Used to keep track of which base types we have already seen, so
2358  // that we can properly diagnose redundant direct base types. Note
2359  // that the key is always the unqualified canonical type of the base
2360  // class.
2361  std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
2362 
2363  // Used to track indirect bases so we can see if a direct base is
2364  // ambiguous.
2365  IndirectBaseSet IndirectBaseTypes;
2366 
2367  // Copy non-redundant base specifiers into permanent storage.
2368  unsigned NumGoodBases = 0;
2369  bool Invalid = false;
2370  for (unsigned idx = 0; idx < Bases.size(); ++idx) {
2371  QualType NewBaseType
2372  = Context.getCanonicalType(Bases[idx]->getType());
2373  NewBaseType = NewBaseType.getLocalUnqualifiedType();
2374 
2375  CXXBaseSpecifier *&KnownBase = KnownBaseTypes[NewBaseType];
2376  if (KnownBase) {
2377  // C++ [class.mi]p3:
2378  // A class shall not be specified as a direct base class of a
2379  // derived class more than once.
2380  Diag(Bases[idx]->getLocStart(),
2381  diag::err_duplicate_base_class)
2382  << KnownBase->getType()
2383  << Bases[idx]->getSourceRange();
2384 
2385  // Delete the duplicate base class specifier; we're going to
2386  // overwrite its pointer later.
2387  Context.Deallocate(Bases[idx]);
2388 
2389  Invalid = true;
2390  } else {
2391  // Okay, add this new base class.
2392  KnownBase = Bases[idx];
2393  Bases[NumGoodBases++] = Bases[idx];
2394 
2395  // Note this base's direct & indirect bases, if there could be ambiguity.
2396  if (Bases.size() > 1)
2397  NoteIndirectBases(Context, IndirectBaseTypes, NewBaseType);
2398 
2399  if (const RecordType *Record = NewBaseType->getAs<RecordType>()) {
2400  const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
2401  if (Class->isInterface() &&
2402  (!RD->isInterfaceLike() ||
2403  KnownBase->getAccessSpecifier() != AS_public)) {
2404  // The Microsoft extension __interface does not permit bases that
2405  // are not themselves public interfaces.
2406  Diag(KnownBase->getLocStart(), diag::err_invalid_base_in_interface)
2407  << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getName()
2408  << RD->getSourceRange();
2409  Invalid = true;
2410  }
2411  if (RD->hasAttr<WeakAttr>())
2412  Class->addAttr(WeakAttr::CreateImplicit(Context));
2413  }
2414  }
2415  }
2416 
2417  // Attach the remaining base class specifiers to the derived class.
2418  Class->setBases(Bases.data(), NumGoodBases);
2419 
2420  for (unsigned idx = 0; idx < NumGoodBases; ++idx) {
2421  // Check whether this direct base is inaccessible due to ambiguity.
2422  QualType BaseType = Bases[idx]->getType();
2423  CanQualType CanonicalBase = Context.getCanonicalType(BaseType)
2424  .getUnqualifiedType();
2425 
2426  if (IndirectBaseTypes.count(CanonicalBase)) {
2427  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2428  /*DetectVirtual=*/true);
2429  bool found
2430  = Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
2431  assert(found);
2432  (void)found;
2433 
2434  if (Paths.isAmbiguous(CanonicalBase))
2435  Diag(Bases[idx]->getLocStart (), diag::warn_inaccessible_base_class)
2436  << BaseType << getAmbiguousPathsDisplayString(Paths)
2437  << Bases[idx]->getSourceRange();
2438  else
2439  assert(Bases[idx]->isVirtual());
2440  }
2441 
2442  // Delete the base class specifier, since its data has been copied
2443  // into the CXXRecordDecl.
2444  Context.Deallocate(Bases[idx]);
2445  }
2446 
2447  return Invalid;
2448 }
2449 
2450 /// ActOnBaseSpecifiers - Attach the given base specifiers to the
2451 /// class, after checking whether there are any duplicate base
2452 /// classes.
2453 void Sema::ActOnBaseSpecifiers(Decl *ClassDecl,
2455  if (!ClassDecl || Bases.empty())
2456  return;
2457 
2458  AdjustDeclIfTemplate(ClassDecl);
2459  AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), Bases);
2460 }
2461 
2462 /// \brief Determine whether the type \p Derived is a C++ class that is
2463 /// derived from the type \p Base.
2465  if (!getLangOpts().CPlusPlus)
2466  return false;
2467 
2468  CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
2469  if (!DerivedRD)
2470  return false;
2471 
2472  CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
2473  if (!BaseRD)
2474  return false;
2475 
2476  // If either the base or the derived type is invalid, don't try to
2477  // check whether one is derived from the other.
2478  if (BaseRD->isInvalidDecl() || DerivedRD->isInvalidDecl())
2479  return false;
2480 
2481  // FIXME: In a modules build, do we need the entire path to be visible for us
2482  // to be able to use the inheritance relationship?
2483  if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
2484  return false;
2485 
2486  return DerivedRD->isDerivedFrom(BaseRD);
2487 }
2488 
2489 /// \brief Determine whether the type \p Derived is a C++ class that is
2490 /// derived from the type \p Base.
2492  CXXBasePaths &Paths) {
2493  if (!getLangOpts().CPlusPlus)
2494  return false;
2495 
2496  CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
2497  if (!DerivedRD)
2498  return false;
2499 
2500  CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
2501  if (!BaseRD)
2502  return false;
2503 
2504  if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
2505  return false;
2506 
2507  return DerivedRD->isDerivedFrom(BaseRD, Paths);
2508 }
2509 
2510 static void BuildBasePathArray(const CXXBasePath &Path,
2511  CXXCastPath &BasePathArray) {
2512  // We first go backward and check if we have a virtual base.
2513  // FIXME: It would be better if CXXBasePath had the base specifier for
2514  // the nearest virtual base.
2515  unsigned Start = 0;
2516  for (unsigned I = Path.size(); I != 0; --I) {
2517  if (Path[I - 1].Base->isVirtual()) {
2518  Start = I - 1;
2519  break;
2520  }
2521  }
2522 
2523  // Now add all bases.
2524  for (unsigned I = Start, E = Path.size(); I != E; ++I)
2525  BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
2526 }
2527 
2528 
2530  CXXCastPath &BasePathArray) {
2531  assert(BasePathArray.empty() && "Base path array must be empty!");
2532  assert(Paths.isRecordingPaths() && "Must record paths!");
2533  return ::BuildBasePathArray(Paths.front(), BasePathArray);
2534 }
2535 /// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
2536 /// conversion (where Derived and Base are class types) is
2537 /// well-formed, meaning that the conversion is unambiguous (and
2538 /// that all of the base classes are accessible). Returns true
2539 /// and emits a diagnostic if the code is ill-formed, returns false
2540 /// otherwise. Loc is the location where this routine should point to
2541 /// if there is an error, and Range is the source range to highlight
2542 /// if there is an error.
2543 ///
2544 /// If either InaccessibleBaseID or AmbigiousBaseConvID are 0, then the
2545 /// diagnostic for the respective type of error will be suppressed, but the
2546 /// check for ill-formed code will still be performed.
2547 bool
2549  unsigned InaccessibleBaseID,
2550  unsigned AmbigiousBaseConvID,
2551  SourceLocation Loc, SourceRange Range,
2552  DeclarationName Name,
2553  CXXCastPath *BasePath,
2554  bool IgnoreAccess) {
2555  // First, determine whether the path from Derived to Base is
2556  // ambiguous. This is slightly more expensive than checking whether
2557  // the Derived to Base conversion exists, because here we need to
2558  // explore multiple paths to determine if there is an ambiguity.
2559  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2560  /*DetectVirtual=*/false);
2561  bool DerivationOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
2562  if (!DerivationOkay)
2563  return true;
2564 
2565  const CXXBasePath *Path = nullptr;
2566  if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType()))
2567  Path = &Paths.front();
2568 
2569  // For MSVC compatibility, check if Derived directly inherits from Base. Clang
2570  // warns about this hierarchy under -Winaccessible-base, but MSVC allows the
2571  // user to access such bases.
2572  if (!Path && getLangOpts().MSVCCompat) {
2573  for (const CXXBasePath &PossiblePath : Paths) {
2574  if (PossiblePath.size() == 1) {
2575  Path = &PossiblePath;
2576  if (AmbigiousBaseConvID)
2577  Diag(Loc, diag::ext_ms_ambiguous_direct_base)
2578  << Base << Derived << Range;
2579  break;
2580  }
2581  }
2582  }
2583 
2584  if (Path) {
2585  if (!IgnoreAccess) {
2586  // Check that the base class can be accessed.
2587  switch (
2588  CheckBaseClassAccess(Loc, Base, Derived, *Path, InaccessibleBaseID)) {
2589  case AR_inaccessible:
2590  return true;
2591  case AR_accessible:
2592  case AR_dependent:
2593  case AR_delayed:
2594  break;
2595  }
2596  }
2597 
2598  // Build a base path if necessary.
2599  if (BasePath)
2600  ::BuildBasePathArray(*Path, *BasePath);
2601  return false;
2602  }
2603 
2604  if (AmbigiousBaseConvID) {
2605  // We know that the derived-to-base conversion is ambiguous, and
2606  // we're going to produce a diagnostic. Perform the derived-to-base
2607  // search just one more time to compute all of the possible paths so
2608  // that we can print them out. This is more expensive than any of
2609  // the previous derived-to-base checks we've done, but at this point
2610  // performance isn't as much of an issue.
2611  Paths.clear();
2612  Paths.setRecordingPaths(true);
2613  bool StillOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
2614  assert(StillOkay && "Can only be used with a derived-to-base conversion");
2615  (void)StillOkay;
2616 
2617  // Build up a textual representation of the ambiguous paths, e.g.,
2618  // D -> B -> A, that will be used to illustrate the ambiguous
2619  // conversions in the diagnostic. We only print one of the paths
2620  // to each base class subobject.
2621  std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
2622 
2623  Diag(Loc, AmbigiousBaseConvID)
2624  << Derived << Base << PathDisplayStr << Range << Name;
2625  }
2626  return true;
2627 }
2628 
2629 bool
2631  SourceLocation Loc, SourceRange Range,
2632  CXXCastPath *BasePath,
2633  bool IgnoreAccess) {
2634  return CheckDerivedToBaseConversion(
2635  Derived, Base, diag::err_upcast_to_inaccessible_base,
2636  diag::err_ambiguous_derived_to_base_conv, Loc, Range, DeclarationName(),
2637  BasePath, IgnoreAccess);
2638 }
2639 
2640 
2641 /// @brief Builds a string representing ambiguous paths from a
2642 /// specific derived class to different subobjects of the same base
2643 /// class.
2644 ///
2645 /// This function builds a string that can be used in error messages
2646 /// to show the different paths that one can take through the
2647 /// inheritance hierarchy to go from the derived class to different
2648 /// subobjects of a base class. The result looks something like this:
2649 /// @code
2650 /// struct D -> struct B -> struct A
2651 /// struct D -> struct C -> struct A
2652 /// @endcode
2654  std::string PathDisplayStr;
2655  std::set<unsigned> DisplayedPaths;
2656  for (CXXBasePaths::paths_iterator Path = Paths.begin();
2657  Path != Paths.end(); ++Path) {
2658  if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
2659  // We haven't displayed a path to this particular base
2660  // class subobject yet.
2661  PathDisplayStr += "\n ";
2662  PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
2663  for (CXXBasePath::const_iterator Element = Path->begin();
2664  Element != Path->end(); ++Element)
2665  PathDisplayStr += " -> " + Element->Base->getType().getAsString();
2666  }
2667  }
2668 
2669  return PathDisplayStr;
2670 }
2671 
2672 //===----------------------------------------------------------------------===//
2673 // C++ class member Handling
2674 //===----------------------------------------------------------------------===//
2675 
2676 /// ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
2678  SourceLocation ASLoc,
2680  AttributeList *Attrs) {
2681  assert(Access != AS_none && "Invalid kind for syntactic access specifier!");
2682  AccessSpecDecl *ASDecl = AccessSpecDecl::Create(Context, Access, CurContext,
2683  ASLoc, ColonLoc);
2684  CurContext->addHiddenDecl(ASDecl);
2685  return ProcessAccessDeclAttributeList(ASDecl, Attrs);
2686 }
2687 
2688 /// CheckOverrideControl - Check C++11 override control semantics.
2690  if (D->isInvalidDecl())
2691  return;
2692 
2693  // We only care about "override" and "final" declarations.
2694  if (!D->hasAttr<OverrideAttr>() && !D->hasAttr<FinalAttr>())
2695  return;
2696 
2697  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
2698 
2699  // We can't check dependent instance methods.
2700  if (MD && MD->isInstance() &&
2701  (MD->getParent()->hasAnyDependentBases() ||
2702  MD->getType()->isDependentType()))
2703  return;
2704 
2705  if (MD && !MD->isVirtual()) {
2706  // If we have a non-virtual method, check if if hides a virtual method.
2707  // (In that case, it's most likely the method has the wrong type.)
2708  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
2709  FindHiddenVirtualMethods(MD, OverloadedMethods);
2710 
2711  if (!OverloadedMethods.empty()) {
2712  if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
2713  Diag(OA->getLocation(),
2714  diag::override_keyword_hides_virtual_member_function)
2715  << "override" << (OverloadedMethods.size() > 1);
2716  } else if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
2717  Diag(FA->getLocation(),
2718  diag::override_keyword_hides_virtual_member_function)
2719  << (FA->isSpelledAsSealed() ? "sealed" : "final")
2720  << (OverloadedMethods.size() > 1);
2721  }
2722  NoteHiddenVirtualMethods(MD, OverloadedMethods);
2723  MD->setInvalidDecl();
2724  return;
2725  }
2726  // Fall through into the general case diagnostic.
2727  // FIXME: We might want to attempt typo correction here.
2728  }
2729 
2730  if (!MD || !MD->isVirtual()) {
2731  if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
2732  Diag(OA->getLocation(),
2733  diag::override_keyword_only_allowed_on_virtual_member_functions)
2734  << "override" << FixItHint::CreateRemoval(OA->getLocation());
2735  D->dropAttr<OverrideAttr>();
2736  }
2737  if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
2738  Diag(FA->getLocation(),
2739  diag::override_keyword_only_allowed_on_virtual_member_functions)
2740  << (FA->isSpelledAsSealed() ? "sealed" : "final")
2741  << FixItHint::CreateRemoval(FA->getLocation());
2742  D->dropAttr<FinalAttr>();
2743  }
2744  return;
2745  }
2746 
2747  // C++11 [class.virtual]p5:
2748  // If a function is marked with the virt-specifier override and
2749  // does not override a member function of a base class, the program is
2750  // ill-formed.
2751  bool HasOverriddenMethods = MD->size_overridden_methods() != 0;
2752  if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)
2753  Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding)
2754  << MD->getDeclName();
2755 }
2756 
2758  if (D->isInvalidDecl() || D->hasAttr<OverrideAttr>())
2759  return;
2760  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
2761  if (!MD || MD->isImplicit() || MD->hasAttr<FinalAttr>())
2762  return;
2763 
2764  SourceLocation Loc = MD->getLocation();
2765  SourceLocation SpellingLoc = Loc;
2766  if (getSourceManager().isMacroArgExpansion(Loc))
2767  SpellingLoc = getSourceManager().getImmediateExpansionRange(Loc).first;
2768  SpellingLoc = getSourceManager().getSpellingLoc(SpellingLoc);
2769  if (SpellingLoc.isValid() && getSourceManager().isInSystemHeader(SpellingLoc))
2770  return;
2771 
2772  if (MD->size_overridden_methods() > 0) {
2773  unsigned DiagID = isa<CXXDestructorDecl>(MD)
2774  ? diag::warn_destructor_marked_not_override_overriding
2775  : diag::warn_function_marked_not_override_overriding;
2776  Diag(MD->getLocation(), DiagID) << MD->getDeclName();
2777  const CXXMethodDecl *OMD = *MD->begin_overridden_methods();
2778  Diag(OMD->getLocation(), diag::note_overridden_virtual_function);
2779  }
2780 }
2781 
2782 /// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member
2783 /// function overrides a virtual member function marked 'final', according to
2784 /// C++11 [class.virtual]p4.
2786  const CXXMethodDecl *Old) {
2787  FinalAttr *FA = Old->getAttr<FinalAttr>();
2788  if (!FA)
2789  return false;
2790 
2791  Diag(New->getLocation(), diag::err_final_function_overridden)
2792  << New->getDeclName()
2793  << FA->isSpelledAsSealed();
2794  Diag(Old->getLocation(), diag::note_overridden_virtual_function);
2795  return true;
2796 }
2797 
2798 static bool InitializationHasSideEffects(const FieldDecl &FD) {
2799  const Type *T = FD.getType()->getBaseElementTypeUnsafe();
2800  // FIXME: Destruction of ObjC lifetime types has side-effects.
2801  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
2802  return !RD->isCompleteDefinition() ||
2803  !RD->hasTrivialDefaultConstructor() ||
2804  !RD->hasTrivialDestructor();
2805  return false;
2806 }
2807 
2809  for (AttributeList *it = list; it != nullptr; it = it->getNext())
2810  if (it->isDeclspecPropertyAttribute())
2811  return it;
2812  return nullptr;
2813 }
2814 
2815 // Check if there is a field shadowing.
2816 void Sema::CheckShadowInheritedFields(const SourceLocation &Loc,
2817  DeclarationName FieldName,
2818  const CXXRecordDecl *RD) {
2819  if (Diags.isIgnored(diag::warn_shadow_field, Loc))
2820  return;
2821 
2822  // To record a shadowed field in a base
2823  std::map<CXXRecordDecl*, NamedDecl*> Bases;
2824  auto FieldShadowed = [&](const CXXBaseSpecifier *Specifier,
2825  CXXBasePath &Path) {
2826  const auto Base = Specifier->getType()->getAsCXXRecordDecl();
2827  // Record an ambiguous path directly
2828  if (Bases.find(Base) != Bases.end())
2829  return true;
2830  for (const auto Field : Base->lookup(FieldName)) {
2831  if ((isa<FieldDecl>(Field) || isa<IndirectFieldDecl>(Field)) &&
2832  Field->getAccess() != AS_private) {
2833  assert(Field->getAccess() != AS_none);
2834  assert(Bases.find(Base) == Bases.end());
2835  Bases[Base] = Field;
2836  return true;
2837  }
2838  }
2839  return false;
2840  };
2841 
2842  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2843  /*DetectVirtual=*/true);
2844  if (!RD->lookupInBases(FieldShadowed, Paths))
2845  return;
2846 
2847  for (const auto &P : Paths) {
2848  auto Base = P.back().Base->getType()->getAsCXXRecordDecl();
2849  auto It = Bases.find(Base);
2850  // Skip duplicated bases
2851  if (It == Bases.end())
2852  continue;
2853  auto BaseField = It->second;
2854  assert(BaseField->getAccess() != AS_private);
2855  if (AS_none !=
2856  CXXRecordDecl::MergeAccess(P.Access, BaseField->getAccess())) {
2857  Diag(Loc, diag::warn_shadow_field)
2858  << FieldName.getAsString() << RD->getName() << Base->getName();
2859  Diag(BaseField->getLocation(), diag::note_shadow_field);
2860  Bases.erase(It);
2861  }
2862  }
2863 }
2864 
2865 /// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
2866 /// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
2867 /// bitfield width if there is one, 'InitExpr' specifies the initializer if
2868 /// one has been parsed, and 'InitStyle' is set if an in-class initializer is
2869 /// present (but parsing it has been deferred).
2870 NamedDecl *
2872  MultiTemplateParamsArg TemplateParameterLists,
2873  Expr *BW, const VirtSpecifiers &VS,
2874  InClassInitStyle InitStyle) {
2875  const DeclSpec &DS = D.getDeclSpec();
2876  DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
2877  DeclarationName Name = NameInfo.getName();
2878  SourceLocation Loc = NameInfo.getLoc();
2879 
2880  // For anonymous bitfields, the location should point to the type.
2881  if (Loc.isInvalid())
2882  Loc = D.getLocStart();
2883 
2884  Expr *BitWidth = static_cast<Expr*>(BW);
2885 
2886  assert(isa<CXXRecordDecl>(CurContext));
2887  assert(!DS.isFriendSpecified());
2888 
2889  bool isFunc = D.isDeclarationOfFunction();
2890  AttributeList *MSPropertyAttr =
2892 
2893  if (cast<CXXRecordDecl>(CurContext)->isInterface()) {
2894  // The Microsoft extension __interface only permits public member functions
2895  // and prohibits constructors, destructors, operators, non-public member
2896  // functions, static methods and data members.
2897  unsigned InvalidDecl;
2898  bool ShowDeclName = true;
2899  if (!isFunc &&
2900  (DS.getStorageClassSpec() == DeclSpec::SCS_typedef || MSPropertyAttr))
2901  InvalidDecl = 0;
2902  else if (!isFunc)
2903  InvalidDecl = 1;
2904  else if (AS != AS_public)
2905  InvalidDecl = 2;
2906  else if (DS.getStorageClassSpec() == DeclSpec::SCS_static)
2907  InvalidDecl = 3;
2908  else switch (Name.getNameKind()) {
2910  InvalidDecl = 4;
2911  ShowDeclName = false;
2912  break;
2913 
2915  InvalidDecl = 5;
2916  ShowDeclName = false;
2917  break;
2918 
2921  InvalidDecl = 6;
2922  break;
2923 
2924  default:
2925  InvalidDecl = 0;
2926  break;
2927  }
2928 
2929  if (InvalidDecl) {
2930  if (ShowDeclName)
2931  Diag(Loc, diag::err_invalid_member_in_interface)
2932  << (InvalidDecl-1) << Name;
2933  else
2934  Diag(Loc, diag::err_invalid_member_in_interface)
2935  << (InvalidDecl-1) << "";
2936  return nullptr;
2937  }
2938  }
2939 
2940  // C++ 9.2p6: A member shall not be declared to have automatic storage
2941  // duration (auto, register) or with the extern storage-class-specifier.
2942  // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
2943  // data members and cannot be applied to names declared const or static,
2944  // and cannot be applied to reference members.
2945  switch (DS.getStorageClassSpec()) {
2947  case DeclSpec::SCS_typedef:
2948  case DeclSpec::SCS_static:
2949  break;
2950  case DeclSpec::SCS_mutable:
2951  if (isFunc) {
2952  Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
2953 
2954  // FIXME: It would be nicer if the keyword was ignored only for this
2955  // declarator. Otherwise we could get follow-up errors.
2957  }
2958  break;
2959  default:
2961  diag::err_storageclass_invalid_for_member);
2963  break;
2964  }
2965 
2966  bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
2968  !isFunc);
2969 
2970  if (DS.isConstexprSpecified() && isInstField) {
2972  Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr_member);
2973  SourceLocation ConstexprLoc = DS.getConstexprSpecLoc();
2974  if (InitStyle == ICIS_NoInit) {
2975  B << 0 << 0;
2977  B << FixItHint::CreateRemoval(ConstexprLoc);
2978  else {
2979  B << FixItHint::CreateReplacement(ConstexprLoc, "const");
2981  const char *PrevSpec;
2982  unsigned DiagID;
2983  bool Failed = D.getMutableDeclSpec().SetTypeQual(
2984  DeclSpec::TQ_const, ConstexprLoc, PrevSpec, DiagID, getLangOpts());
2985  (void)Failed;
2986  assert(!Failed && "Making a constexpr member const shouldn't fail");
2987  }
2988  } else {
2989  B << 1;
2990  const char *PrevSpec;
2991  unsigned DiagID;
2993  *this, DeclSpec::SCS_static, ConstexprLoc, PrevSpec, DiagID,
2994  Context.getPrintingPolicy())) {
2995  assert(DS.getStorageClassSpec() == DeclSpec::SCS_mutable &&
2996  "This is the only DeclSpec that should fail to be applied");
2997  B << 1;
2998  } else {
2999  B << 0 << FixItHint::CreateInsertion(ConstexprLoc, "static ");
3000  isInstField = false;
3001  }
3002  }
3003  }
3004 
3005  NamedDecl *Member;
3006  if (isInstField) {
3007  CXXScopeSpec &SS = D.getCXXScopeSpec();
3008 
3009  // Data members must have identifiers for names.
3010  if (!Name.isIdentifier()) {
3011  Diag(Loc, diag::err_bad_variable_name)
3012  << Name;
3013  return nullptr;
3014  }
3015 
3016  IdentifierInfo *II = Name.getAsIdentifierInfo();
3017 
3018  // Member field could not be with "template" keyword.
3019  // So TemplateParameterLists should be empty in this case.
3020  if (TemplateParameterLists.size()) {
3021  TemplateParameterList* TemplateParams = TemplateParameterLists[0];
3022  if (TemplateParams->size()) {
3023  // There is no such thing as a member field template.
3024  Diag(D.getIdentifierLoc(), diag::err_template_member)
3025  << II
3026  << SourceRange(TemplateParams->getTemplateLoc(),
3027  TemplateParams->getRAngleLoc());
3028  } else {
3029  // There is an extraneous 'template<>' for this member.
3030  Diag(TemplateParams->getTemplateLoc(),
3031  diag::err_template_member_noparams)
3032  << II
3033  << SourceRange(TemplateParams->getTemplateLoc(),
3034  TemplateParams->getRAngleLoc());
3035  }
3036  return nullptr;
3037  }
3038 
3039  if (SS.isSet() && !SS.isInvalid()) {
3040  // The user provided a superfluous scope specifier inside a class
3041  // definition:
3042  //
3043  // class X {
3044  // int X::member;
3045  // };
3046  if (DeclContext *DC = computeDeclContext(SS, false))
3047  diagnoseQualifiedDeclaration(SS, DC, Name, D.getIdentifierLoc());
3048  else
3049  Diag(D.getIdentifierLoc(), diag::err_member_qualification)
3050  << Name << SS.getRange();
3051 
3052  SS.clear();
3053  }
3054 
3055  if (MSPropertyAttr) {
3056  Member = HandleMSProperty(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3057  BitWidth, InitStyle, AS, MSPropertyAttr);
3058  if (!Member)
3059  return nullptr;
3060  isInstField = false;
3061  } else {
3062  Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3063  BitWidth, InitStyle, AS);
3064  if (!Member)
3065  return nullptr;
3066  }
3067 
3068  CheckShadowInheritedFields(Loc, Name, cast<CXXRecordDecl>(CurContext));
3069  } else {
3070  Member = HandleDeclarator(S, D, TemplateParameterLists);
3071  if (!Member)
3072  return nullptr;
3073 
3074  // Non-instance-fields can't have a bitfield.
3075  if (BitWidth) {
3076  if (Member->isInvalidDecl()) {
3077  // don't emit another diagnostic.
3078  } else if (isa<VarDecl>(Member) || isa<VarTemplateDecl>(Member)) {
3079  // C++ 9.6p3: A bit-field shall not be a static member.
3080  // "static member 'A' cannot be a bit-field"
3081  Diag(Loc, diag::err_static_not_bitfield)
3082  << Name << BitWidth->getSourceRange();
3083  } else if (isa<TypedefDecl>(Member)) {
3084  // "typedef member 'x' cannot be a bit-field"
3085  Diag(Loc, diag::err_typedef_not_bitfield)
3086  << Name << BitWidth->getSourceRange();
3087  } else {
3088  // A function typedef ("typedef int f(); f a;").
3089  // C++ 9.6p3: A bit-field shall have integral or enumeration type.
3090  Diag(Loc, diag::err_not_integral_type_bitfield)
3091  << Name << cast<ValueDecl>(Member)->getType()
3092  << BitWidth->getSourceRange();
3093  }
3094 
3095  BitWidth = nullptr;
3096  Member->setInvalidDecl();
3097  }
3098 
3099  Member->setAccess(AS);
3100 
3101  // If we have declared a member function template or static data member
3102  // template, set the access of the templated declaration as well.
3103  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
3104  FunTmpl->getTemplatedDecl()->setAccess(AS);
3105  else if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(Member))
3106  VarTmpl->getTemplatedDecl()->setAccess(AS);
3107  }
3108 
3109  if (VS.isOverrideSpecified())
3110  Member->addAttr(new (Context) OverrideAttr(VS.getOverrideLoc(), Context, 0));
3111  if (VS.isFinalSpecified())
3112  Member->addAttr(new (Context) FinalAttr(VS.getFinalLoc(), Context,
3113  VS.isFinalSpelledSealed()));
3114 
3115  if (VS.getLastLocation().isValid()) {
3116  // Update the end location of a method that has a virt-specifiers.
3117  if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member))
3118  MD->setRangeEnd(VS.getLastLocation());
3119  }
3120 
3121  CheckOverrideControl(Member);
3122 
3123  assert((Name || isInstField) && "No identifier for non-field ?");
3124 
3125  if (isInstField) {
3126  FieldDecl *FD = cast<FieldDecl>(Member);
3127  FieldCollector->Add(FD);
3128 
3129  if (!Diags.isIgnored(diag::warn_unused_private_field, FD->getLocation())) {
3130  // Remember all explicit private FieldDecls that have a name, no side
3131  // effects and are not part of a dependent type declaration.
3132  if (!FD->isImplicit() && FD->getDeclName() &&
3133  FD->getAccess() == AS_private &&
3134  !FD->hasAttr<UnusedAttr>() &&
3135  !FD->getParent()->isDependentContext() &&
3137  UnusedPrivateFields.insert(FD);
3138  }
3139  }
3140 
3141  return Member;
3142 }
3143 
3144 namespace {
3145  class UninitializedFieldVisitor
3146  : public EvaluatedExprVisitor<UninitializedFieldVisitor> {
3147  Sema &S;
3148  // List of Decls to generate a warning on. Also remove Decls that become
3149  // initialized.
3150  llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
3151  // List of base classes of the record. Classes are removed after their
3152  // initializers.
3153  llvm::SmallPtrSetImpl<QualType> &BaseClasses;
3154  // Vector of decls to be removed from the Decl set prior to visiting the
3155  // nodes. These Decls may have been initialized in the prior initializer.
3156  llvm::SmallVector<ValueDecl*, 4> DeclsToRemove;
3157  // If non-null, add a note to the warning pointing back to the constructor.
3158  const CXXConstructorDecl *Constructor;
3159  // Variables to hold state when processing an initializer list. When
3160  // InitList is true, special case initialization of FieldDecls matching
3161  // InitListFieldDecl.
3162  bool InitList;
3163  FieldDecl *InitListFieldDecl;
3164  llvm::SmallVector<unsigned, 4> InitFieldIndex;
3165 
3166  public:
3168  UninitializedFieldVisitor(Sema &S,
3169  llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
3170  llvm::SmallPtrSetImpl<QualType> &BaseClasses)
3171  : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
3172  Constructor(nullptr), InitList(false), InitListFieldDecl(nullptr) {}
3173 
3174  // Returns true if the use of ME is not an uninitialized use.
3175  bool IsInitListMemberExprInitialized(MemberExpr *ME,
3176  bool CheckReferenceOnly) {
3178  bool ReferenceField = false;
3179  while (ME) {
3180  FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
3181  if (!FD)
3182  return false;
3183  Fields.push_back(FD);
3184  if (FD->getType()->isReferenceType())
3185  ReferenceField = true;
3186  ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParenImpCasts());
3187  }
3188 
3189  // Binding a reference to an unintialized field is not an
3190  // uninitialized use.
3191  if (CheckReferenceOnly && !ReferenceField)
3192  return true;
3193 
3194  llvm::SmallVector<unsigned, 4> UsedFieldIndex;
3195  // Discard the first field since it is the field decl that is being
3196  // initialized.
3197  for (auto I = Fields.rbegin() + 1, E = Fields.rend(); I != E; ++I) {
3198  UsedFieldIndex.push_back((*I)->getFieldIndex());
3199  }
3200 
3201  for (auto UsedIter = UsedFieldIndex.begin(),
3202  UsedEnd = UsedFieldIndex.end(),
3203  OrigIter = InitFieldIndex.begin(),
3204  OrigEnd = InitFieldIndex.end();
3205  UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
3206  if (*UsedIter < *OrigIter)
3207  return true;
3208  if (*UsedIter > *OrigIter)
3209  break;
3210  }
3211 
3212  return false;
3213  }
3214 
3215  void HandleMemberExpr(MemberExpr *ME, bool CheckReferenceOnly,
3216  bool AddressOf) {
3217  if (isa<EnumConstantDecl>(ME->getMemberDecl()))
3218  return;
3219 
3220  // FieldME is the inner-most MemberExpr that is not an anonymous struct
3221  // or union.
3222  MemberExpr *FieldME = ME;
3223 
3224  bool AllPODFields = FieldME->getType().isPODType(S.Context);
3225 
3226  Expr *Base = ME;
3227  while (MemberExpr *SubME =
3228  dyn_cast<MemberExpr>(Base->IgnoreParenImpCasts())) {
3229 
3230  if (isa<VarDecl>(SubME->getMemberDecl()))
3231  return;
3232 
3233  if (FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
3234  if (!FD->isAnonymousStructOrUnion())
3235  FieldME = SubME;
3236 
3237  if (!FieldME->getType().isPODType(S.Context))
3238  AllPODFields = false;
3239 
3240  Base = SubME->getBase();
3241  }
3242 
3243  if (!isa<CXXThisExpr>(Base->IgnoreParenImpCasts()))
3244  return;
3245 
3246  if (AddressOf && AllPODFields)
3247  return;
3248 
3249  ValueDecl* FoundVD = FieldME->getMemberDecl();
3250 
3251  if (ImplicitCastExpr *BaseCast = dyn_cast<ImplicitCastExpr>(Base)) {
3252  while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
3253  BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
3254  }
3255 
3256  if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
3257  QualType T = BaseCast->getType();
3258  if (T->isPointerType() &&
3259  BaseClasses.count(T->getPointeeType())) {
3260  S.Diag(FieldME->getExprLoc(), diag::warn_base_class_is_uninit)
3261  << T->getPointeeType() << FoundVD;
3262  }
3263  }
3264  }
3265 
3266  if (!Decls.count(FoundVD))
3267  return;
3268 
3269  const bool IsReference = FoundVD->getType()->isReferenceType();
3270 
3271  if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
3272  // Special checking for initializer lists.
3273  if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
3274  return;
3275  }
3276  } else {
3277  // Prevent double warnings on use of unbounded references.
3278  if (CheckReferenceOnly && !IsReference)
3279  return;
3280  }
3281 
3282  unsigned diag = IsReference
3283  ? diag::warn_reference_field_is_uninit
3284  : diag::warn_field_is_uninit;
3285  S.Diag(FieldME->getExprLoc(), diag) << FoundVD;
3286  if (Constructor)
3287  S.Diag(Constructor->getLocation(),
3288  diag::note_uninit_in_this_constructor)
3289  << (Constructor->isDefaultConstructor() && Constructor->isImplicit());
3290 
3291  }
3292 
3293  void HandleValue(Expr *E, bool AddressOf) {
3294  E = E->IgnoreParens();
3295 
3296  if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
3297  HandleMemberExpr(ME, false /*CheckReferenceOnly*/,
3298  AddressOf /*AddressOf*/);
3299  return;
3300  }
3301 
3302  if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
3303  Visit(CO->getCond());
3304  HandleValue(CO->getTrueExpr(), AddressOf);
3305  HandleValue(CO->getFalseExpr(), AddressOf);
3306  return;
3307  }
3308 
3309  if (BinaryConditionalOperator *BCO =
3310  dyn_cast<BinaryConditionalOperator>(E)) {
3311  Visit(BCO->getCond());
3312  HandleValue(BCO->getFalseExpr(), AddressOf);
3313  return;
3314  }
3315 
3316  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
3317  HandleValue(OVE->getSourceExpr(), AddressOf);
3318  return;
3319  }
3320 
3321  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
3322  switch (BO->getOpcode()) {
3323  default:
3324  break;
3325  case(BO_PtrMemD):
3326  case(BO_PtrMemI):
3327  HandleValue(BO->getLHS(), AddressOf);
3328  Visit(BO->getRHS());
3329  return;
3330  case(BO_Comma):
3331  Visit(BO->getLHS());
3332  HandleValue(BO->getRHS(), AddressOf);
3333  return;
3334  }
3335  }
3336 
3337  Visit(E);
3338  }
3339 
3340  void CheckInitListExpr(InitListExpr *ILE) {
3341  InitFieldIndex.push_back(0);
3342  for (auto Child : ILE->children()) {
3343  if (InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
3344  CheckInitListExpr(SubList);
3345  } else {
3346  Visit(Child);
3347  }
3348  ++InitFieldIndex.back();
3349  }
3350  InitFieldIndex.pop_back();
3351  }
3352 
3353  void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor,
3354  FieldDecl *Field, const Type *BaseClass) {
3355  // Remove Decls that may have been initialized in the previous
3356  // initializer.
3357  for (ValueDecl* VD : DeclsToRemove)
3358  Decls.erase(VD);
3359  DeclsToRemove.clear();
3360 
3361  Constructor = FieldConstructor;
3362  InitListExpr *ILE = dyn_cast<InitListExpr>(E);
3363 
3364  if (ILE && Field) {
3365  InitList = true;
3366  InitListFieldDecl = Field;
3367  InitFieldIndex.clear();
3368  CheckInitListExpr(ILE);
3369  } else {
3370  InitList = false;
3371  Visit(E);
3372  }
3373 
3374  if (Field)
3375  Decls.erase(Field);
3376  if (BaseClass)
3377  BaseClasses.erase(BaseClass->getCanonicalTypeInternal());
3378  }
3379 
3380  void VisitMemberExpr(MemberExpr *ME) {
3381  // All uses of unbounded reference fields will warn.
3382  HandleMemberExpr(ME, true /*CheckReferenceOnly*/, false /*AddressOf*/);
3383  }
3384 
3385  void VisitImplicitCastExpr(ImplicitCastExpr *E) {
3386  if (E->getCastKind() == CK_LValueToRValue) {
3387  HandleValue(E->getSubExpr(), false /*AddressOf*/);
3388  return;
3389  }
3390 
3391  Inherited::VisitImplicitCastExpr(E);
3392  }
3393 
3394  void VisitCXXConstructExpr(CXXConstructExpr *E) {
3395  if (E->getConstructor()->isCopyConstructor()) {
3396  Expr *ArgExpr = E->getArg(0);
3397  if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
3398  if (ILE->getNumInits() == 1)
3399  ArgExpr = ILE->getInit(0);
3400  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
3401  if (ICE->getCastKind() == CK_NoOp)
3402  ArgExpr = ICE->getSubExpr();
3403  HandleValue(ArgExpr, false /*AddressOf*/);
3404  return;
3405  }
3406  Inherited::VisitCXXConstructExpr(E);
3407  }
3408 
3409  void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
3410  Expr *Callee = E->getCallee();
3411  if (isa<MemberExpr>(Callee)) {
3412  HandleValue(Callee, false /*AddressOf*/);
3413  for (auto Arg : E->arguments())
3414  Visit(Arg);
3415  return;
3416  }
3417 
3418  Inherited::VisitCXXMemberCallExpr(E);
3419  }
3420 
3421  void VisitCallExpr(CallExpr *E) {
3422  // Treat std::move as a use.
3423  if (E->isCallToStdMove()) {
3424  HandleValue(E->getArg(0), /*AddressOf=*/false);
3425  return;
3426  }
3427 
3428  Inherited::VisitCallExpr(E);
3429  }
3430 
3431  void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
3432  Expr *Callee = E->getCallee();
3433 
3434  if (isa<UnresolvedLookupExpr>(Callee))
3435  return Inherited::VisitCXXOperatorCallExpr(E);
3436 
3437  Visit(Callee);
3438  for (auto Arg : E->arguments())
3439  HandleValue(Arg->IgnoreParenImpCasts(), false /*AddressOf*/);
3440  }
3441 
3442  void VisitBinaryOperator(BinaryOperator *E) {
3443  // If a field assignment is detected, remove the field from the
3444  // uninitiailized field set.
3445  if (E->getOpcode() == BO_Assign)
3446  if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getLHS()))
3447  if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
3448  if (!FD->getType()->isReferenceType())
3449  DeclsToRemove.push_back(FD);
3450 
3451  if (E->isCompoundAssignmentOp()) {
3452  HandleValue(E->getLHS(), false /*AddressOf*/);
3453  Visit(E->getRHS());
3454  return;
3455  }
3456 
3457  Inherited::VisitBinaryOperator(E);
3458  }
3459 
3460  void VisitUnaryOperator(UnaryOperator *E) {
3461  if (E->isIncrementDecrementOp()) {
3462  HandleValue(E->getSubExpr(), false /*AddressOf*/);
3463  return;
3464  }
3465  if (E->getOpcode() == UO_AddrOf) {
3466  if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getSubExpr())) {
3467  HandleValue(ME->getBase(), true /*AddressOf*/);
3468  return;
3469  }
3470  }
3471 
3472  Inherited::VisitUnaryOperator(E);
3473  }
3474  };
3475 
3476  // Diagnose value-uses of fields to initialize themselves, e.g.
3477  // foo(foo)
3478  // where foo is not also a parameter to the constructor.
3479  // Also diagnose across field uninitialized use such as
3480  // x(y), y(x)
3481  // TODO: implement -Wuninitialized and fold this into that framework.
3482  static void DiagnoseUninitializedFields(
3483  Sema &SemaRef, const CXXConstructorDecl *Constructor) {
3484 
3485  if (SemaRef.getDiagnostics().isIgnored(diag::warn_field_is_uninit,
3486  Constructor->getLocation())) {
3487  return;
3488  }
3489 
3490  if (Constructor->isInvalidDecl())
3491  return;
3492 
3493  const CXXRecordDecl *RD = Constructor->getParent();
3494 
3495  if (RD->getDescribedClassTemplate())
3496  return;
3497 
3498  // Holds fields that are uninitialized.
3499  llvm::SmallPtrSet<ValueDecl*, 4> UninitializedFields;
3500 
3501  // At the beginning, all fields are uninitialized.
3502  for (auto *I : RD->decls()) {
3503  if (auto *FD = dyn_cast<FieldDecl>(I)) {
3504  UninitializedFields.insert(FD);
3505  } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
3506  UninitializedFields.insert(IFD->getAnonField());
3507  }
3508  }
3509 
3510  llvm::SmallPtrSet<QualType, 4> UninitializedBaseClasses;
3511  for (auto I : RD->bases())
3512  UninitializedBaseClasses.insert(I.getType().getCanonicalType());
3513 
3514  if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
3515  return;
3516 
3517  UninitializedFieldVisitor UninitializedChecker(SemaRef,
3518  UninitializedFields,
3519  UninitializedBaseClasses);
3520 
3521  for (const auto *FieldInit : Constructor->inits()) {
3522  if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
3523  break;
3524 
3525  Expr *InitExpr = FieldInit->getInit();
3526  if (!InitExpr)
3527  continue;
3528 
3530  dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
3531  InitExpr = Default->getExpr();
3532  if (!InitExpr)
3533  continue;
3534  // In class initializers will point to the constructor.
3535  UninitializedChecker.CheckInitializer(InitExpr, Constructor,
3536  FieldInit->getAnyMember(),
3537  FieldInit->getBaseClass());
3538  } else {
3539  UninitializedChecker.CheckInitializer(InitExpr, nullptr,
3540  FieldInit->getAnyMember(),
3541  FieldInit->getBaseClass());
3542  }
3543  }
3544  }
3545 } // namespace
3546 
3547 /// \brief Enter a new C++ default initializer scope. After calling this, the
3548 /// caller must call \ref ActOnFinishCXXInClassMemberInitializer, even if
3549 /// parsing or instantiating the initializer failed.
3551  // Create a synthetic function scope to represent the call to the constructor
3552  // that notionally surrounds a use of this initializer.
3553  PushFunctionScope();
3554 }
3555 
3556 /// \brief This is invoked after parsing an in-class initializer for a
3557 /// non-static C++ class member, and after instantiating an in-class initializer
3558 /// in a class template. Such actions are deferred until the class is complete.
3560  SourceLocation InitLoc,
3561  Expr *InitExpr) {
3562  // Pop the notional constructor scope we created earlier.
3563  PopFunctionScopeInfo(nullptr, D);
3564 
3565  FieldDecl *FD = dyn_cast<FieldDecl>(D);
3566  assert((isa<MSPropertyDecl>(D) || FD->getInClassInitStyle() != ICIS_NoInit) &&
3567  "must set init style when field is created");
3568 
3569  if (!InitExpr) {
3570  D->setInvalidDecl();
3571  if (FD)
3573  return;
3574  }
3575 
3576  if (DiagnoseUnexpandedParameterPack(InitExpr, UPPC_Initializer)) {
3577  FD->setInvalidDecl();
3579  return;
3580  }
3581 
3582  ExprResult Init = InitExpr;
3583  if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent()) {
3587  : InitializationKind::CreateCopy(InitExpr->getLocStart(), InitLoc);
3588  InitializationSequence Seq(*this, Entity, Kind, InitExpr);
3589  Init = Seq.Perform(*this, Entity, Kind, InitExpr);
3590  if (Init.isInvalid()) {
3591  FD->setInvalidDecl();
3592  return;
3593  }
3594  }
3595 
3596  // C++11 [class.base.init]p7:
3597  // The initialization of each base and member constitutes a
3598  // full-expression.
3599  Init = ActOnFinishFullExpr(Init.get(), InitLoc);
3600  if (Init.isInvalid()) {
3601  FD->setInvalidDecl();
3602  return;
3603  }
3604 
3605  InitExpr = Init.get();
3606 
3607  FD->setInClassInitializer(InitExpr);
3608 }
3609 
3610 /// \brief Find the direct and/or virtual base specifiers that
3611 /// correspond to the given base type, for use in base initialization
3612 /// within a constructor.
3613 static bool FindBaseInitializer(Sema &SemaRef,
3614  CXXRecordDecl *ClassDecl,
3615  QualType BaseType,
3616  const CXXBaseSpecifier *&DirectBaseSpec,
3617  const CXXBaseSpecifier *&VirtualBaseSpec) {
3618  // First, check for a direct base class.
3619  DirectBaseSpec = nullptr;
3620  for (const auto &Base : ClassDecl->bases()) {
3621  if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base.getType())) {
3622  // We found a direct base of this type. That's what we're
3623  // initializing.
3624  DirectBaseSpec = &Base;
3625  break;
3626  }
3627  }
3628 
3629  // Check for a virtual base class.
3630  // FIXME: We might be able to short-circuit this if we know in advance that
3631  // there are no virtual bases.
3632  VirtualBaseSpec = nullptr;
3633  if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
3634  // We haven't found a base yet; search the class hierarchy for a
3635  // virtual base class.
3636  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3637  /*DetectVirtual=*/false);
3638  if (SemaRef.IsDerivedFrom(ClassDecl->getLocation(),
3639  SemaRef.Context.getTypeDeclType(ClassDecl),
3640  BaseType, Paths)) {
3641  for (CXXBasePaths::paths_iterator Path = Paths.begin();
3642  Path != Paths.end(); ++Path) {
3643  if (Path->back().Base->isVirtual()) {
3644  VirtualBaseSpec = Path->back().Base;
3645  break;
3646  }
3647  }
3648  }
3649  }
3650 
3651  return DirectBaseSpec || VirtualBaseSpec;
3652 }
3653 
3654 /// \brief Handle a C++ member initializer using braced-init-list syntax.
3656 Sema::ActOnMemInitializer(Decl *ConstructorD,
3657  Scope *S,
3658  CXXScopeSpec &SS,
3659  IdentifierInfo *MemberOrBase,
3660  ParsedType TemplateTypeTy,
3661  const DeclSpec &DS,
3662  SourceLocation IdLoc,
3663  Expr *InitList,
3664  SourceLocation EllipsisLoc) {
3665  return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
3666  DS, IdLoc, InitList,
3667  EllipsisLoc);
3668 }
3669 
3670 /// \brief Handle a C++ member initializer using parentheses syntax.
3672 Sema::ActOnMemInitializer(Decl *ConstructorD,
3673  Scope *S,
3674  CXXScopeSpec &SS,
3675  IdentifierInfo *MemberOrBase,
3676  ParsedType TemplateTypeTy,
3677  const DeclSpec &DS,
3678  SourceLocation IdLoc,
3679  SourceLocation LParenLoc,
3680  ArrayRef<Expr *> Args,
3681  SourceLocation RParenLoc,
3682  SourceLocation EllipsisLoc) {
3683  Expr *List = new (Context) ParenListExpr(Context, LParenLoc,
3684  Args, RParenLoc);
3685  return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
3686  DS, IdLoc, List, EllipsisLoc);
3687 }
3688 
3689 namespace {
3690 
3691 // Callback to only accept typo corrections that can be a valid C++ member
3692 // intializer: either a non-static field member or a base class.
3693 class MemInitializerValidatorCCC : public CorrectionCandidateCallback {
3694 public:
3695  explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl)
3696  : ClassDecl(ClassDecl) {}
3697 
3698  bool ValidateCandidate(const TypoCorrection &candidate) override {
3699  if (NamedDecl *ND = candidate.getCorrectionDecl()) {
3700  if (FieldDecl *Member = dyn_cast<FieldDecl>(ND))
3701  return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
3702  return isa<TypeDecl>(ND);
3703  }
3704  return false;
3705  }
3706 
3707 private:
3708  CXXRecordDecl *ClassDecl;
3709 };
3710 
3711 }
3712 
3713 /// \brief Handle a C++ member initializer.
3715 Sema::BuildMemInitializer(Decl *ConstructorD,
3716  Scope *S,
3717  CXXScopeSpec &SS,
3718  IdentifierInfo *MemberOrBase,
3719  ParsedType TemplateTypeTy,
3720  const DeclSpec &DS,
3721  SourceLocation IdLoc,
3722  Expr *Init,
3723  SourceLocation EllipsisLoc) {
3724  ExprResult Res = CorrectDelayedTyposInExpr(Init);
3725  if (!Res.isUsable())
3726  return true;
3727  Init = Res.get();
3728 
3729  if (!ConstructorD)
3730  return true;
3731 
3732  AdjustDeclIfTemplate(ConstructorD);
3733 
3734  CXXConstructorDecl *Constructor
3735  = dyn_cast<CXXConstructorDecl>(ConstructorD);
3736  if (!Constructor) {
3737  // The user wrote a constructor initializer on a function that is
3738  // not a C++ constructor. Ignore the error for now, because we may
3739  // have more member initializers coming; we'll diagnose it just
3740  // once in ActOnMemInitializers.
3741  return true;
3742  }
3743 
3744  CXXRecordDecl *ClassDecl = Constructor->getParent();
3745 
3746  // C++ [class.base.init]p2:
3747  // Names in a mem-initializer-id are looked up in the scope of the
3748  // constructor's class and, if not found in that scope, are looked
3749  // up in the scope containing the constructor's definition.
3750  // [Note: if the constructor's class contains a member with the
3751  // same name as a direct or virtual base class of the class, a
3752  // mem-initializer-id naming the member or base class and composed
3753  // of a single identifier refers to the class member. A
3754  // mem-initializer-id for the hidden base class may be specified
3755  // using a qualified name. ]
3756  if (!SS.getScopeRep() && !TemplateTypeTy) {
3757  // Look for a member, first.
3758  DeclContext::lookup_result Result = ClassDecl->lookup(MemberOrBase);
3759  if (!Result.empty()) {
3760  ValueDecl *Member;
3761  if ((Member = dyn_cast<FieldDecl>(Result.front())) ||
3762  (Member = dyn_cast<IndirectFieldDecl>(Result.front()))) {
3763  if (EllipsisLoc.isValid())
3764  Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
3765  << MemberOrBase
3766  << SourceRange(IdLoc, Init->getSourceRange().getEnd());
3767 
3768  return BuildMemberInitializer(Member, Init, IdLoc);
3769  }
3770  }
3771  }
3772  // It didn't name a member, so see if it names a class.
3773  QualType BaseType;
3774  TypeSourceInfo *TInfo = nullptr;
3775 
3776  if (TemplateTypeTy) {
3777  BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
3778  } else if (DS.getTypeSpecType() == TST_decltype) {
3779  BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
3780  } else if (DS.getTypeSpecType() == TST_decltype_auto) {
3781  Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);
3782  return true;
3783  } else {
3784  LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
3785  LookupParsedName(R, S, &SS);
3786 
3787  TypeDecl *TyD = R.getAsSingle<TypeDecl>();
3788  if (!TyD) {
3789  if (R.isAmbiguous()) return true;
3790 
3791  // We don't want access-control diagnostics here.
3792  R.suppressDiagnostics();
3793 
3794  if (SS.isSet() && isDependentScopeSpecifier(SS)) {
3795  bool NotUnknownSpecialization = false;
3796  DeclContext *DC = computeDeclContext(SS, false);
3797  if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
3798  NotUnknownSpecialization = !Record->hasAnyDependentBases();
3799 
3800  if (!NotUnknownSpecialization) {
3801  // When the scope specifier can refer to a member of an unknown
3802  // specialization, we take it as a type name.
3803  BaseType = CheckTypenameType(ETK_None, SourceLocation(),
3804  SS.getWithLocInContext(Context),
3805  *MemberOrBase, IdLoc);
3806  if (BaseType.isNull())
3807  return true;
3808 
3809  TInfo = Context.CreateTypeSourceInfo(BaseType);
3812  if (!TL.isNull()) {
3813  TL.setNameLoc(IdLoc);
3815  TL.setQualifierLoc(SS.getWithLocInContext(Context));
3816  }
3817 
3818  R.clear();
3819  R.setLookupName(MemberOrBase);
3820  }
3821  }
3822 
3823  // If no results were found, try to correct typos.
3824  TypoCorrection Corr;
3825  if (R.empty() && BaseType.isNull() &&
3826  (Corr = CorrectTypo(
3827  R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
3828  llvm::make_unique<MemInitializerValidatorCCC>(ClassDecl),
3829  CTK_ErrorRecovery, ClassDecl))) {
3830  if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
3831  // We have found a non-static data member with a similar
3832  // name to what was typed; complain and initialize that
3833  // member.
3834  diagnoseTypo(Corr,
3835  PDiag(diag::err_mem_init_not_member_or_class_suggest)
3836  << MemberOrBase << true);
3837  return BuildMemberInitializer(Member, Init, IdLoc);
3838  } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
3839  const CXXBaseSpecifier *DirectBaseSpec;
3840  const CXXBaseSpecifier *VirtualBaseSpec;
3841  if (FindBaseInitializer(*this, ClassDecl,
3842  Context.getTypeDeclType(Type),
3843  DirectBaseSpec, VirtualBaseSpec)) {
3844  // We have found a direct or virtual base class with a
3845  // similar name to what was typed; complain and initialize
3846  // that base class.
3847  diagnoseTypo(Corr,
3848  PDiag(diag::err_mem_init_not_member_or_class_suggest)
3849  << MemberOrBase << false,
3850  PDiag() /*Suppress note, we provide our own.*/);
3851 
3852  const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
3853  : VirtualBaseSpec;
3854  Diag(BaseSpec->getLocStart(),
3855  diag::note_base_class_specified_here)
3856  << BaseSpec->getType()
3857  << BaseSpec->getSourceRange();
3858 
3859  TyD = Type;
3860  }
3861  }
3862  }
3863 
3864  if (!TyD && BaseType.isNull()) {
3865  Diag(IdLoc, diag::err_mem_init_not_member_or_class)
3866  << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
3867  return true;
3868  }
3869  }
3870 
3871  if (BaseType.isNull()) {
3872  BaseType = Context.getTypeDeclType(TyD);
3873  MarkAnyDeclReferenced(TyD->getLocation(), TyD, /*OdrUse=*/false);
3874  if (SS.isSet()) {
3875  BaseType = Context.getElaboratedType(ETK_None, SS.getScopeRep(),
3876  BaseType);
3877  TInfo = Context.CreateTypeSourceInfo(BaseType);
3879  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
3881  TL.setQualifierLoc(SS.getWithLocInContext(Context));
3882  }
3883  }
3884  }
3885 
3886  if (!TInfo)
3887  TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
3888 
3889  return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc);
3890 }
3891 
3892 /// Checks a member initializer expression for cases where reference (or
3893 /// pointer) members are bound to by-value parameters (or their addresses).
3895  Expr *Init,
3896  SourceLocation IdLoc) {
3897  QualType MemberTy = Member->getType();
3898 
3899  // We only handle pointers and references currently.
3900  // FIXME: Would this be relevant for ObjC object pointers? Or block pointers?
3901  if (!MemberTy->isReferenceType() && !MemberTy->isPointerType())
3902  return;
3903 
3904  const bool IsPointer = MemberTy->isPointerType();
3905  if (IsPointer) {
3906  if (const UnaryOperator *Op
3907  = dyn_cast<UnaryOperator>(Init->IgnoreParenImpCasts())) {
3908  // The only case we're worried about with pointers requires taking the
3909  // address.
3910  if (Op->getOpcode() != UO_AddrOf)
3911  return;
3912 
3913  Init = Op->getSubExpr();
3914  } else {
3915  // We only handle address-of expression initializers for pointers.
3916  return;
3917  }
3918  }
3919 
3920  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Init->IgnoreParens())) {
3921  // We only warn when referring to a non-reference parameter declaration.
3922  const ParmVarDecl *Parameter = dyn_cast<ParmVarDecl>(DRE->getDecl());
3923  if (!Parameter || Parameter->getType()->isReferenceType())
3924  return;
3925 
3926  S.Diag(Init->getExprLoc(),
3927  IsPointer ? diag::warn_init_ptr_member_to_parameter_addr
3928  : diag::warn_bind_ref_member_to_parameter)
3929  << Member << Parameter << Init->getSourceRange();
3930  } else {
3931  // Other initializers are fine.
3932  return;
3933  }
3934 
3935  S.Diag(Member->getLocation(), diag::note_ref_or_ptr_member_declared_here)
3936  << (unsigned)IsPointer;
3937 }
3938 
3941  SourceLocation IdLoc) {
3942  FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member);
3943  IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member);
3944  assert((DirectMember || IndirectMember) &&
3945  "Member must be a FieldDecl or IndirectFieldDecl");
3946 
3947  if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
3948  return true;
3949 
3950  if (Member->isInvalidDecl())
3951  return true;
3952 
3953  MultiExprArg Args;
3954  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
3955  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
3956  } else if (InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
3957  Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
3958  } else {
3959  // Template instantiation doesn't reconstruct ParenListExprs for us.
3960  Args = Init;
3961  }
3962 
3963  SourceRange InitRange = Init->getSourceRange();
3964 
3965  if (Member->getType()->isDependentType() || Init->isTypeDependent()) {
3966  // Can't check initialization for a member of dependent type or when
3967  // any of the arguments are type-dependent expressions.
3968  DiscardCleanupsInEvaluationContext();
3969  } else {
3970  bool InitList = false;
3971  if (isa<InitListExpr>(Init)) {
3972  InitList = true;
3973  Args = Init;
3974  }
3975 
3976  // Initialize the member.
3977  InitializedEntity MemberEntity =
3978  DirectMember ? InitializedEntity::InitializeMember(DirectMember, nullptr)
3979  : InitializedEntity::InitializeMember(IndirectMember,
3980  nullptr);
3982  InitList ? InitializationKind::CreateDirectList(IdLoc)
3983  : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(),
3984  InitRange.getEnd());
3985 
3986  InitializationSequence InitSeq(*this, MemberEntity, Kind, Args);
3987  ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind, Args,
3988  nullptr);
3989  if (MemberInit.isInvalid())
3990  return true;
3991 
3992  CheckForDanglingReferenceOrPointer(*this, Member, MemberInit.get(), IdLoc);
3993 
3994  // C++11 [class.base.init]p7:
3995  // The initialization of each base and member constitutes a
3996  // full-expression.
3997  MemberInit = ActOnFinishFullExpr(MemberInit.get(), InitRange.getBegin());
3998  if (MemberInit.isInvalid())
3999  return true;
4000 
4001  Init = MemberInit.get();
4002  }
4003 
4004  if (DirectMember) {
4005  return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc,
4006  InitRange.getBegin(), Init,
4007  InitRange.getEnd());
4008  } else {
4009  return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc,
4010  InitRange.getBegin(), Init,
4011  InitRange.getEnd());
4012  }
4013 }
4014 
4017  CXXRecordDecl *ClassDecl) {
4018  SourceLocation NameLoc = TInfo->getTypeLoc().getLocalSourceRange().getBegin();
4019  if (!LangOpts.CPlusPlus11)
4020  return Diag(NameLoc, diag::err_delegating_ctor)
4021  << TInfo->getTypeLoc().getLocalSourceRange();
4022  Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
4023 
4024  bool InitList = true;
4025  MultiExprArg Args = Init;
4026  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4027  InitList = false;
4028  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4029  }
4030 
4031  SourceRange InitRange = Init->getSourceRange();
4032  // Initialize the object.
4034  QualType(ClassDecl->getTypeForDecl(), 0));
4036  InitList ? InitializationKind::CreateDirectList(NameLoc)
4037  : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(),
4038  InitRange.getEnd());
4039  InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args);
4040  ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind,
4041  Args, nullptr);
4042  if (DelegationInit.isInvalid())
4043  return true;
4044 
4045  assert(cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() &&
4046  "Delegating constructor with no target?");
4047 
4048  // C++11 [class.base.init]p7:
4049  // The initialization of each base and member constitutes a
4050  // full-expression.
4051  DelegationInit = ActOnFinishFullExpr(DelegationInit.get(),
4052  InitRange.getBegin());
4053  if (DelegationInit.isInvalid())
4054  return true;
4055 
4056  // If we are in a dependent context, template instantiation will
4057  // perform this type-checking again. Just save the arguments that we
4058  // received in a ParenListExpr.
4059  // FIXME: This isn't quite ideal, since our ASTs don't capture all
4060  // of the information that we have about the base
4061  // initializer. However, deconstructing the ASTs is a dicey process,
4062  // and this approach is far more likely to get the corner cases right.
4063  if (CurContext->isDependentContext())
4064  DelegationInit = Init;
4065 
4066  return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(),
4067  DelegationInit.getAs<Expr>(),
4068  InitRange.getEnd());
4069 }
4070 
4073  Expr *Init, CXXRecordDecl *ClassDecl,
4074  SourceLocation EllipsisLoc) {
4075  SourceLocation BaseLoc
4076  = BaseTInfo->getTypeLoc().getLocalSourceRange().getBegin();
4077 
4078  if (!BaseType->isDependentType() && !BaseType->isRecordType())
4079  return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
4080  << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
4081 
4082  // C++ [class.base.init]p2:
4083  // [...] Unless the mem-initializer-id names a nonstatic data
4084  // member of the constructor's class or a direct or virtual base
4085  // of that class, the mem-initializer is ill-formed. A
4086  // mem-initializer-list can initialize a base class using any
4087  // name that denotes that base class type.
4088  bool Dependent = BaseType->isDependentType() || Init->isTypeDependent();
4089 
4090  SourceRange InitRange = Init->getSourceRange();
4091  if (EllipsisLoc.isValid()) {
4092  // This is a pack expansion.
4093  if (!BaseType->containsUnexpandedParameterPack()) {
4094  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
4095  << SourceRange(BaseLoc, InitRange.getEnd());
4096 
4097  EllipsisLoc = SourceLocation();
4098  }
4099  } else {
4100  // Check for any unexpanded parameter packs.
4101  if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer))
4102  return true;
4103 
4104  if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
4105  return true;
4106  }
4107 
4108  // Check for direct and virtual base classes.
4109  const CXXBaseSpecifier *DirectBaseSpec = nullptr;
4110  const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
4111  if (!Dependent) {
4112  if (Context.hasSameUnqualifiedType(QualType(ClassDecl->getTypeForDecl(),0),
4113  BaseType))
4114  return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl);
4115 
4116  FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
4117  VirtualBaseSpec);
4118 
4119  // C++ [base.class.init]p2:
4120  // Unless the mem-initializer-id names a nonstatic data member of the
4121  // constructor's class or a direct or virtual base of that class, the
4122  // mem-initializer is ill-formed.
4123  if (!DirectBaseSpec && !VirtualBaseSpec) {
4124  // If the class has any dependent bases, then it's possible that
4125  // one of those types will resolve to the same type as
4126  // BaseType. Therefore, just treat this as a dependent base
4127  // class initialization. FIXME: Should we try to check the
4128  // initialization anyway? It seems odd.
4129  if (ClassDecl->hasAnyDependentBases())
4130  Dependent = true;
4131  else
4132  return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
4133  << BaseType << Context.getTypeDeclType(ClassDecl)
4134  << BaseTInfo->getTypeLoc().getLocalSourceRange();
4135  }
4136  }
4137 
4138  if (Dependent) {
4139  DiscardCleanupsInEvaluationContext();
4140 
4141  return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4142  /*IsVirtual=*/false,
4143  InitRange.getBegin(), Init,
4144  InitRange.getEnd(), EllipsisLoc);
4145  }
4146 
4147  // C++ [base.class.init]p2:
4148  // If a mem-initializer-id is ambiguous because it designates both
4149  // a direct non-virtual base class and an inherited virtual base
4150  // class, the mem-initializer is ill-formed.
4151  if (DirectBaseSpec && VirtualBaseSpec)
4152  return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
4153  << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
4154 
4155  const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
4156  if (!BaseSpec)
4157  BaseSpec = VirtualBaseSpec;
4158 
4159  // Initialize the base.
4160  bool InitList = true;
4161  MultiExprArg Args = Init;
4162  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4163  InitList = false;
4164  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4165  }
4166 
4167  InitializedEntity BaseEntity =
4168  InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec);
4170  InitList ? InitializationKind::CreateDirectList(BaseLoc)
4171  : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(),
4172  InitRange.getEnd());
4173  InitializationSequence InitSeq(*this, BaseEntity, Kind, Args);
4174  ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind, Args, nullptr);
4175  if (BaseInit.isInvalid())
4176  return true;
4177 
4178  // C++11 [class.base.init]p7:
4179  // The initialization of each base and member constitutes a
4180  // full-expression.
4181  BaseInit = ActOnFinishFullExpr(BaseInit.get(), InitRange.getBegin());
4182  if (BaseInit.isInvalid())
4183  return true;
4184 
4185  // If we are in a dependent context, template instantiation will
4186  // perform this type-checking again. Just save the arguments that we
4187  // received in a ParenListExpr.
4188  // FIXME: This isn't quite ideal, since our ASTs don't capture all
4189  // of the information that we have about the base
4190  // initializer. However, deconstructing the ASTs is a dicey process,
4191  // and this approach is far more likely to get the corner cases right.
4192  if (CurContext->isDependentContext())
4193  BaseInit = Init;
4194 
4195  return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4196  BaseSpec->isVirtual(),
4197  InitRange.getBegin(),
4198  BaseInit.getAs<Expr>(),
4199  InitRange.getEnd(), EllipsisLoc);
4200 }
4201 
4202 // Create a static_cast<T&&>(expr).
4203 static Expr *CastForMoving(Sema &SemaRef, Expr *E, QualType T = QualType()) {
4204  if (T.isNull()) T = E->getType();
4205  QualType TargetType = SemaRef.BuildReferenceType(
4206  T, /*SpelledAsLValue*/false, SourceLocation(), DeclarationName());
4207  SourceLocation ExprLoc = E->getLocStart();
4208  TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo(
4209  TargetType, ExprLoc);
4210 
4211  return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
4212  SourceRange(ExprLoc, ExprLoc),
4213  E->getSourceRange()).get();
4214 }
4215 
4216 /// ImplicitInitializerKind - How an implicit base or member initializer should
4217 /// initialize its base or member.
4223 };
4224 
4225 static bool
4227  ImplicitInitializerKind ImplicitInitKind,
4228  CXXBaseSpecifier *BaseSpec,
4229  bool IsInheritedVirtualBase,
4230  CXXCtorInitializer *&CXXBaseInit) {
4231  InitializedEntity InitEntity
4232  = InitializedEntity::InitializeBase(SemaRef.Context, BaseSpec,
4233  IsInheritedVirtualBase);
4234 
4235  ExprResult BaseInit;
4236 
4237  switch (ImplicitInitKind) {
4238  case IIK_Inherit:
4239  case IIK_Default: {
4240  InitializationKind InitKind
4242  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
4243  BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
4244  break;
4245  }
4246 
4247  case IIK_Move:
4248  case IIK_Copy: {
4249  bool Moving = ImplicitInitKind == IIK_Move;
4250  ParmVarDecl *Param = Constructor->getParamDecl(0);
4251  QualType ParamType = Param->getType().getNonReferenceType();
4252 
4253  Expr *CopyCtorArg =
4255  SourceLocation(), Param, false,
4256  Constructor->getLocation(), ParamType,
4257  VK_LValue, nullptr);
4258 
4259  SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg));
4260 
4261  // Cast to the base class to avoid ambiguities.
4262  QualType ArgTy =
4263  SemaRef.Context.getQualifiedType(BaseSpec->getType().getUnqualifiedType(),
4264  ParamType.getQualifiers());
4265 
4266  if (Moving) {
4267  CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg);
4268  }
4269 
4270  CXXCastPath BasePath;
4271  BasePath.push_back(BaseSpec);
4272  CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy,
4273  CK_UncheckedDerivedToBase,
4274  Moving ? VK_XValue : VK_LValue,
4275  &BasePath).get();
4276 
4277  InitializationKind InitKind
4280  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, CopyCtorArg);
4281  BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, CopyCtorArg);
4282  break;
4283  }
4284  }
4285 
4286  BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit);
4287  if (BaseInit.isInvalid())
4288  return true;
4289 
4290  CXXBaseInit =
4291  new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4292  SemaRef.Context.getTrivialTypeSourceInfo(BaseSpec->getType(),
4293  SourceLocation()),
4294  BaseSpec->isVirtual(),
4295  SourceLocation(),
4296  BaseInit.getAs<Expr>(),
4297  SourceLocation(),
4298  SourceLocation());
4299 
4300  return false;
4301 }
4302 
4303 static bool RefersToRValueRef(Expr *MemRef) {
4304  ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
4305  return Referenced->getType()->isRValueReferenceType();
4306 }
4307 
4308 static bool
4310  ImplicitInitializerKind ImplicitInitKind,
4311  FieldDecl *Field, IndirectFieldDecl *Indirect,
4312  CXXCtorInitializer *&CXXMemberInit) {
4313  if (Field->isInvalidDecl())
4314  return true;
4315 
4316  SourceLocation Loc = Constructor->getLocation();
4317 
4318  if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) {
4319  bool Moving = ImplicitInitKind == IIK_Move;
4320  ParmVarDecl *Param = Constructor->getParamDecl(0);
4321  QualType ParamType = Param->getType().getNonReferenceType();
4322 
4323  // Suppress copying zero-width bitfields.
4324  if (Field->isBitField() && Field->getBitWidthValue(SemaRef.Context) == 0)
4325  return false;
4326 
4327  Expr *MemberExprBase =
4329  SourceLocation(), Param, false,
4330  Loc, ParamType, VK_LValue, nullptr);
4331 
4332  SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase));
4333 
4334  if (Moving) {
4335  MemberExprBase = CastForMoving(SemaRef, MemberExprBase);
4336  }
4337 
4338  // Build a reference to this field within the parameter.
4339  CXXScopeSpec SS;
4340  LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
4342  MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect)
4343  : cast<ValueDecl>(Field), AS_public);
4344  MemberLookup.resolveKind();
4345  ExprResult CtorArg
4346  = SemaRef.BuildMemberReferenceExpr(MemberExprBase,
4347  ParamType, Loc,
4348  /*IsArrow=*/false,
4349  SS,
4350  /*TemplateKWLoc=*/SourceLocation(),
4351  /*FirstQualifierInScope=*/nullptr,
4352  MemberLookup,
4353  /*TemplateArgs=*/nullptr,
4354  /*S*/nullptr);
4355  if (CtorArg.isInvalid())
4356  return true;
4357 
4358  // C++11 [class.copy]p15:
4359  // - if a member m has rvalue reference type T&&, it is direct-initialized
4360  // with static_cast<T&&>(x.m);
4361  if (RefersToRValueRef(CtorArg.get())) {
4362  CtorArg = CastForMoving(SemaRef, CtorArg.get());
4363  }
4364 
4365  InitializedEntity Entity =
4366  Indirect ? InitializedEntity::InitializeMember(Indirect, nullptr,
4367  /*Implicit*/ true)
4368  : InitializedEntity::InitializeMember(Field, nullptr,
4369  /*Implicit*/ true);
4370 
4371  // Direct-initialize to use the copy constructor.
4372  InitializationKind InitKind =
4374 
4375  Expr *CtorArgE = CtorArg.getAs<Expr>();
4376  InitializationSequence InitSeq(SemaRef, Entity, InitKind, CtorArgE);
4377  ExprResult MemberInit =
4378  InitSeq.Perform(SemaRef, Entity, InitKind, MultiExprArg(&CtorArgE, 1));
4379  MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
4380  if (MemberInit.isInvalid())
4381  return true;
4382 
4383  if (Indirect)
4384  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
4385  SemaRef.Context, Indirect, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
4386  else
4387  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
4388  SemaRef.Context, Field, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
4389  return false;
4390  }
4391 
4392  assert((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) &&
4393  "Unhandled implicit init kind!");
4394 
4395  QualType FieldBaseElementType =
4396  SemaRef.Context.getBaseElementType(Field->getType());
4397 
4398  if (FieldBaseElementType->isRecordType()) {
4399  InitializedEntity InitEntity =
4400  Indirect ? InitializedEntity::InitializeMember(Indirect, nullptr,
4401  /*Implicit*/ true)
4402  : InitializedEntity::InitializeMember(Field, nullptr,
4403  /*Implicit*/ true);
4404  InitializationKind InitKind =
4406 
4407  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
4408  ExprResult MemberInit =
4409  InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
4410 
4411  MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
4412  if (MemberInit.isInvalid())
4413  return true;
4414 
4415  if (Indirect)
4416  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4417  Indirect, Loc,
4418  Loc,
4419  MemberInit.get(),
4420  Loc);
4421  else
4422  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4423  Field, Loc, Loc,
4424  MemberInit.get(),
4425  Loc);
4426  return false;
4427  }
4428 
4429  if (!Field->getParent()->isUnion()) {
4430  if (FieldBaseElementType->isReferenceType()) {
4431  SemaRef.Diag(Constructor->getLocation(),
4432  diag::err_uninitialized_member_in_ctor)
4433  << (int)Constructor->isImplicit()
4434  << SemaRef.Context.getTagDeclType(Constructor->getParent())
4435  << 0 << Field->getDeclName();
4436  SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
4437  return true;
4438  }
4439 
4440  if (FieldBaseElementType.isConstQualified()) {
4441  SemaRef.Diag(Constructor->getLocation(),
4442  diag::err_uninitialized_member_in_ctor)
4443  << (int)Constructor->isImplicit()
4444  << SemaRef.Context.getTagDeclType(Constructor->getParent())
4445  << 1 << Field->getDeclName();
4446  SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
4447  return true;
4448  }
4449  }
4450 
4451  if (FieldBaseElementType.hasNonTrivialObjCLifetime()) {
4452  // ARC and Weak:
4453  // Default-initialize Objective-C pointers to NULL.
4454  CXXMemberInit
4455  = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
4456  Loc, Loc,
4457  new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()),
4458  Loc);
4459  return false;
4460  }
4461 
4462  // Nothing to initialize.
4463  CXXMemberInit = nullptr;
4464  return false;
4465 }
4466 
4467 namespace {
4468 struct BaseAndFieldInfo {
4469  Sema &S;
4470  CXXConstructorDecl *Ctor;
4471  bool AnyErrorsInInits;
4473  llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
4475  llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
4476 
4477  BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits)
4478  : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
4479  bool Generated = Ctor->isImplicit() || Ctor->isDefaulted();
4480  if (Ctor->getInheritedConstructor())
4481  IIK = IIK_Inherit;
4482  else if (Generated && Ctor->isCopyConstructor())
4483  IIK = IIK_Copy;
4484  else if (Generated && Ctor->isMoveConstructor())
4485  IIK = IIK_Move;
4486  else
4487  IIK = IIK_Default;
4488  }
4489 
4490  bool isImplicitCopyOrMove() const {
4491  switch (IIK) {
4492  case IIK_Copy:
4493  case IIK_Move:
4494  return true;
4495 
4496  case IIK_Default:
4497  case IIK_Inherit:
4498  return false;
4499  }
4500 
4501  llvm_unreachable("Invalid ImplicitInitializerKind!");
4502  }
4503 
4504  bool addFieldInitializer(CXXCtorInitializer *Init) {
4505  AllToInit.push_back(Init);
4506 
4507  // Check whether this initializer makes the field "used".
4508  if (Init->getInit()->HasSideEffects(S.Context))
4509  S.UnusedPrivateFields.remove(Init->getAnyMember());
4510 
4511  return false;
4512  }
4513 
4514  bool isInactiveUnionMember(FieldDecl *Field) {
4515  RecordDecl *Record = Field->getParent();
4516  if (!Record->isUnion())
4517  return false;
4518 
4519  if (FieldDecl *Active =
4520  ActiveUnionMember.lookup(Record->getCanonicalDecl()))
4521  return Active != Field->getCanonicalDecl();
4522 
4523  // In an implicit copy or move constructor, ignore any in-class initializer.
4524  if (isImplicitCopyOrMove())
4525  return true;
4526 
4527  // If there's no explicit initialization, the field is active only if it
4528  // has an in-class initializer...
4529  if (Field->hasInClassInitializer())
4530  return false;
4531  // ... or it's an anonymous struct or union whose class has an in-class
4532  // initializer.
4533  if (!Field->isAnonymousStructOrUnion())
4534  return true;
4535  CXXRecordDecl *FieldRD = Field->getType()->getAsCXXRecordDecl();
4536  return !FieldRD->hasInClassInitializer();
4537  }
4538 
4539  /// \brief Determine whether the given field is, or is within, a union member
4540  /// that is inactive (because there was an initializer given for a different
4541  /// member of the union, or because the union was not initialized at all).
4542  bool isWithinInactiveUnionMember(FieldDecl *Field,
4543  IndirectFieldDecl *Indirect) {
4544  if (!Indirect)
4545  return isInactiveUnionMember(Field);
4546 
4547  for (auto *C : Indirect->chain()) {
4548  FieldDecl *Field = dyn_cast<FieldDecl>(C);
4549  if (Field && isInactiveUnionMember(Field))
4550  return true;
4551  }
4552  return false;
4553  }
4554 };
4555 }
4556 
4557 /// \brief Determine whether the given type is an incomplete or zero-lenfgth
4558 /// array type.
4560  if (T->isIncompleteArrayType())
4561  return true;
4562 
4563  while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
4564  if (!ArrayT->getSize())
4565  return true;
4566 
4567  T = ArrayT->getElementType();
4568  }
4569 
4570  return false;
4571 }
4572 
4573 static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
4574  FieldDecl *Field,
4575  IndirectFieldDecl *Indirect = nullptr) {
4576  if (Field->isInvalidDecl())
4577  return false;
4578 
4579  // Overwhelmingly common case: we have a direct initializer for this field.
4580  if (CXXCtorInitializer *Init =
4581  Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
4582  return Info.addFieldInitializer(Init);
4583 
4584  // C++11 [class.base.init]p8:
4585  // if the entity is a non-static data member that has a
4586  // brace-or-equal-initializer and either
4587  // -- the constructor's class is a union and no other variant member of that
4588  // union is designated by a mem-initializer-id or
4589  // -- the constructor's class is not a union, and, if the entity is a member
4590  // of an anonymous union, no other member of that union is designated by
4591  // a mem-initializer-id,
4592  // the entity is initialized as specified in [dcl.init].
4593  //
4594  // We also apply the same rules to handle anonymous structs within anonymous
4595  // unions.
4596  if (Info.isWithinInactiveUnionMember(Field, Indirect))
4597  return false;
4598 
4599  if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
4600  ExprResult DIE =
4601  SemaRef.BuildCXXDefaultInitExpr(Info.Ctor->getLocation(), Field);
4602  if (DIE.isInvalid())
4603  return true;
4604  CXXCtorInitializer *Init;
4605  if (Indirect)
4606  Init = new (SemaRef.Context)
4607  CXXCtorInitializer(SemaRef.Context, Indirect, SourceLocation(),
4608  SourceLocation(), DIE.get(), SourceLocation());
4609  else
4610  Init = new (SemaRef.Context)
4611  CXXCtorInitializer(SemaRef.Context, Field, SourceLocation(),
4612  SourceLocation(), DIE.get(), SourceLocation());
4613  return Info.addFieldInitializer(Init);
4614  }
4615 
4616  // Don't initialize incomplete or zero-length arrays.
4617  if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType()))
4618  return false;
4619 
4620  // Don't try to build an implicit initializer if there were semantic
4621  // errors in any of the initializers (and therefore we might be
4622  // missing some that the user actually wrote).
4623  if (Info.AnyErrorsInInits)
4624  return false;
4625 
4626  CXXCtorInitializer *Init = nullptr;
4627  if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field,
4628  Indirect, Init))
4629  return true;
4630 
4631  if (!Init)
4632  return false;
4633 
4634  return Info.addFieldInitializer(Init);
4635 }
4636 
4637 bool
4639  CXXCtorInitializer *Initializer) {
4640  assert(Initializer->isDelegatingInitializer());
4641  Constructor->setNumCtorInitializers(1);
4642  CXXCtorInitializer **initializer =
4643  new (Context) CXXCtorInitializer*[1];
4644  memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*));
4645  Constructor->setCtorInitializers(initializer);
4646 
4647  if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) {
4648  MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor);
4649  DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation());
4650  }
4651 
4652  DelegatingCtorDecls.push_back(Constructor);
4653 
4654  DiagnoseUninitializedFields(*this, Constructor);
4655 
4656  return false;
4657 }
4658 
4659 bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
4660  ArrayRef<CXXCtorInitializer *> Initializers) {
4661  if (Constructor->isDependentContext()) {
4662  // Just store the initializers as written, they will be checked during
4663  // instantiation.
4664  if (!Initializers.empty()) {
4665  Constructor->setNumCtorInitializers(Initializers.size());
4666  CXXCtorInitializer **baseOrMemberInitializers =
4667  new (Context) CXXCtorInitializer*[Initializers.size()];
4668  memcpy(baseOrMemberInitializers, Initializers.data(),
4669  Initializers.size() * sizeof(CXXCtorInitializer*));
4670  Constructor->setCtorInitializers(baseOrMemberInitializers);
4671  }
4672 
4673  // Let template instantiation know whether we had errors.
4674  if (AnyErrors)
4675  Constructor->setInvalidDecl();
4676 
4677  return false;
4678  }
4679 
4680  BaseAndFieldInfo Info(*this, Constructor, AnyErrors);
4681 
4682  // We need to build the initializer AST according to order of construction
4683  // and not what user specified in the Initializers list.
4684  CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
4685  if (!ClassDecl)
4686  return true;
4687 
4688  bool HadError = false;
4689 
4690  for (unsigned i = 0; i < Initializers.size(); i++) {
4691  CXXCtorInitializer *Member = Initializers[i];
4692 
4693  if (Member->isBaseInitializer())
4694  Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
4695  else {
4696  Info.AllBaseFields[Member->getAnyMember()->getCanonicalDecl()] = Member;
4697 
4698  if (IndirectFieldDecl *F = Member->getIndirectMember()) {
4699  for (auto *C : F->chain()) {
4700  FieldDecl *FD = dyn_cast<FieldDecl>(C);
4701  if (FD && FD->getParent()->isUnion())
4702  Info.ActiveUnionMember.insert(std::make_pair(
4703  FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
4704  }
4705  } else if (FieldDecl *FD = Member->getMember()) {
4706  if (FD->getParent()->isUnion())
4707  Info.ActiveUnionMember.insert(std::make_pair(
4708  FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
4709  }
4710  }
4711  }
4712 
4713  // Keep track of the direct virtual bases.
4714  llvm::SmallPtrSet<CXXBaseSpecifier *, 16> DirectVBases;
4715  for (auto &I : ClassDecl->bases()) {
4716  if (I.isVirtual())
4717  DirectVBases.insert(&I);
4718  }
4719 
4720  // Push virtual bases before others.
4721  for (auto &VBase : ClassDecl->vbases()) {
4723  = Info.AllBaseFields.lookup(VBase.getType()->getAs<RecordType>())) {
4724  // [class.base.init]p7, per DR257:
4725  // A mem-initializer where the mem-initializer-id names a virtual base
4726  // class is ignored during execution of a constructor of any class that
4727  // is not the most derived class.
4728  if (ClassDecl->isAbstract()) {
4729  // FIXME: Provide a fixit to remove the base specifier. This requires
4730  // tracking the location of the associated comma for a base specifier.
4731  Diag(Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
4732  << VBase.getType() << ClassDecl;
4733  DiagnoseAbstractType(ClassDecl);
4734  }
4735 
4736  Info.AllToInit.push_back(Value);
4737  } else if (!AnyErrors && !ClassDecl->isAbstract()) {
4738  // [class.base.init]p8, per DR257:
4739  // If a given [...] base class is not named by a mem-initializer-id
4740  // [...] and the entity is not a virtual base class of an abstract
4741  // class, then [...] the entity is default-initialized.
4742  bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
4743  CXXCtorInitializer *CXXBaseInit;
4744  if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
4745  &VBase, IsInheritedVirtualBase,
4746  CXXBaseInit)) {
4747  HadError = true;
4748  continue;
4749  }
4750 
4751  Info.AllToInit.push_back(CXXBaseInit);
4752  }
4753  }
4754 
4755  // Non-virtual bases.
4756  for (auto &Base : ClassDecl->bases()) {
4757  // Virtuals are in the virtual base list and already constructed.
4758  if (Base.isVirtual())
4759  continue;
4760 
4762  = Info.AllBaseFields.lookup(Base.getType()->getAs<RecordType>())) {
4763  Info.AllToInit.push_back(Value);
4764  } else if (!AnyErrors) {
4765  CXXCtorInitializer *CXXBaseInit;
4766  if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
4767  &Base, /*IsInheritedVirtualBase=*/false,
4768  CXXBaseInit)) {
4769  HadError = true;
4770  continue;
4771  }
4772 
4773  Info.AllToInit.push_back(CXXBaseInit);
4774  }
4775  }
4776 
4777  // Fields.
4778  for (auto *Mem : ClassDecl->decls()) {
4779  if (auto *F = dyn_cast<FieldDecl>(Mem)) {
4780  // C++ [class.bit]p2:
4781  // A declaration for a bit-field that omits the identifier declares an
4782  // unnamed bit-field. Unnamed bit-fields are not members and cannot be
4783  // initialized.
4784  if (F->isUnnamedBitfield())
4785  continue;
4786 
4787  // If we're not generating the implicit copy/move constructor, then we'll
4788  // handle anonymous struct/union fields based on their individual
4789  // indirect fields.
4790  if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
4791  continue;
4792 
4793  if (CollectFieldInitializer(*this, Info, F))
4794  HadError = true;
4795  continue;
4796  }
4797 
4798  // Beyond this point, we only consider default initialization.
4799  if (Info.isImplicitCopyOrMove())
4800  continue;
4801 
4802  if (auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
4803  if (F->getType()->isIncompleteArrayType()) {
4804  assert(ClassDecl->hasFlexibleArrayMember() &&
4805  "Incomplete array type is not valid");
4806  continue;
4807  }
4808 
4809  // Initialize each field of an anonymous struct individually.
4810  if (CollectFieldInitializer(*this, Info, F->getAnonField(), F))
4811  HadError = true;
4812 
4813  continue;
4814  }
4815  }
4816 
4817  unsigned NumInitializers = Info.AllToInit.size();
4818  if (NumInitializers > 0) {
4819  Constructor->setNumCtorInitializers(NumInitializers);
4820  CXXCtorInitializer **baseOrMemberInitializers =
4821  new (Context) CXXCtorInitializer*[NumInitializers];
4822  memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
4823  NumInitializers * sizeof(CXXCtorInitializer*));
4824  Constructor->setCtorInitializers(baseOrMemberInitializers);
4825 
4826  // Constructors implicitly reference the base and member
4827  // destructors.
4828  MarkBaseAndMemberDestructorsReferenced(Constructor->getLocation(),
4829  Constructor->getParent());
4830  }
4831 
4832  return HadError;
4833 }
4834 
4836  if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
4837  const RecordDecl *RD = RT->getDecl();
4838  if (RD->isAnonymousStructOrUnion()) {
4839  for (auto *Field : RD->fields())
4840  PopulateKeysForFields(Field, IdealInits);
4841  return;
4842  }
4843  }
4844  IdealInits.push_back(Field->getCanonicalDecl());
4845 }
4846 
4847 static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
4848  return Context.getCanonicalType(BaseType).getTypePtr();
4849 }
4850 
4851 static const void *GetKeyForMember(ASTContext &Context,
4852  CXXCtorInitializer *Member) {
4853  if (!Member->isAnyMemberInitializer())
4854  return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0));
4855 
4856  return Member->getAnyMember()->getCanonicalDecl();
4857 }
4858 
4860  Sema &SemaRef, const CXXConstructorDecl *Constructor,
4862  if (Constructor->getDeclContext()->isDependentContext())
4863  return;
4864 
4865  // Don't check initializers order unless the warning is enabled at the
4866  // location of at least one initializer.
4867  bool ShouldCheckOrder = false;
4868  for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
4869  CXXCtorInitializer *Init = Inits[InitIndex];
4870  if (!SemaRef.Diags.isIgnored(diag::warn_initializer_out_of_order,
4871  Init->getSourceLocation())) {
4872  ShouldCheckOrder = true;
4873  break;
4874  }
4875  }
4876  if (!ShouldCheckOrder)
4877  return;
4878 
4879  // Build the list of bases and members in the order that they'll
4880  // actually be initialized. The explicit initializers should be in
4881  // this same order but may be missing things.
4882  SmallVector<const void*, 32> IdealInitKeys;
4883 
4884  const CXXRecordDecl *ClassDecl = Constructor->getParent();
4885 
4886  // 1. Virtual bases.
4887  for (const auto &VBase : ClassDecl->vbases())
4888  IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase.getType()));
4889 
4890  // 2. Non-virtual bases.
4891  for (const auto &Base : ClassDecl->bases()) {
4892  if (Base.isVirtual())
4893  continue;
4894  IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base.getType()));
4895  }
4896 
4897  // 3. Direct fields.
4898  for (auto *Field : ClassDecl->fields()) {
4899  if (Field->isUnnamedBitfield())
4900  continue;
4901 
4902  PopulateKeysForFields(Field, IdealInitKeys);
4903  }
4904 
4905  unsigned NumIdealInits = IdealInitKeys.size();
4906  unsigned IdealIndex = 0;
4907 
4908  CXXCtorInitializer *PrevInit = nullptr;
4909  for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
4910  CXXCtorInitializer *Init = Inits[InitIndex];
4911  const void *InitKey = GetKeyForMember(SemaRef.Context, Init);
4912 
4913  // Scan forward to try to find this initializer in the idealized
4914  // initializers list.
4915  for (; IdealIndex != NumIdealInits; ++IdealIndex)
4916  if (InitKey == IdealInitKeys[IdealIndex])
4917  break;
4918 
4919  // If we didn't find this initializer, it must be because we
4920  // scanned past it on a previous iteration. That can only
4921  // happen if we're out of order; emit a warning.
4922  if (IdealIndex == NumIdealInits && PrevInit) {
4924  SemaRef.Diag(PrevInit->getSourceLocation(),
4925  diag::warn_initializer_out_of_order);
4926 
4927  if (PrevInit->isAnyMemberInitializer())
4928  D << 0 << PrevInit->getAnyMember()->getDeclName();
4929  else
4930  D << 1 << PrevInit->getTypeSourceInfo()->getType();
4931 
4932  if (Init->isAnyMemberInitializer())
4933  D << 0 << Init->getAnyMember()->getDeclName();
4934  else
4935  D << 1 << Init->getTypeSourceInfo()->getType();
4936 
4937  // Move back to the initializer's location in the ideal list.
4938  for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
4939  if (InitKey == IdealInitKeys[IdealIndex])
4940  break;
4941 
4942  assert(IdealIndex < NumIdealInits &&
4943  "initializer not found in initializer list");
4944  }
4945 
4946  PrevInit = Init;
4947  }
4948 }
4949 
4950 namespace {
4951 bool CheckRedundantInit(Sema &S,
4952  CXXCtorInitializer *Init,
4953  CXXCtorInitializer *&PrevInit) {
4954  if (!PrevInit) {
4955  PrevInit = Init;
4956  return false;
4957  }
4958 
4959  if (FieldDecl *Field = Init->getAnyMember())
4960  S.Diag(Init->getSourceLocation(),
4961  diag::err_multiple_mem_initialization)
4962  << Field->getDeclName()
4963  << Init->getSourceRange();
4964  else {
4965  const Type *BaseClass = Init->getBaseClass();
4966  assert(BaseClass && "neither field nor base");
4967  S.Diag(Init->getSourceLocation(),
4968  diag::err_multiple_base_initialization)
4969  << QualType(BaseClass, 0)
4970  << Init->getSourceRange();
4971  }
4972  S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer)
4973  << 0 << PrevInit->getSourceRange();
4974 
4975  return true;
4976 }
4977 
4978 typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
4979 typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
4980 
4981 bool CheckRedundantUnionInit(Sema &S,
4982  CXXCtorInitializer *Init,
4983  RedundantUnionMap &Unions) {
4984  FieldDecl *Field = Init->getAnyMember();
4985  RecordDecl *Parent = Field->getParent();
4986  NamedDecl *Child = Field;
4987 
4988  while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {
4989  if (Parent->isUnion()) {
4990  UnionEntry &En = Unions[Parent];
4991  if (En.first && En.first != Child) {
4992  S.Diag(Init->getSourceLocation(),
4993  diag::err_multiple_mem_union_initialization)
4994  << Field->getDeclName()
4995  << Init->getSourceRange();
4996  S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
4997  << 0 << En.second->getSourceRange();
4998  return true;
4999  }
5000  if (!En.first) {
5001  En.first = Child;
5002  En.second = Init;
5003  }
5004  if (!Parent->isAnonymousStructOrUnion())
5005  return false;
5006  }
5007 
5008  Child = Parent;
5009  Parent = cast<RecordDecl>(Parent->getDeclContext());
5010  }
5011 
5012  return false;
5013 }
5014 }
5015 
5016 /// ActOnMemInitializers - Handle the member initializers for a constructor.
5017 void Sema::ActOnMemInitializers(Decl *ConstructorDecl,
5020  bool AnyErrors) {
5021  if (!ConstructorDecl)
5022  return;
5023 
5024  AdjustDeclIfTemplate(ConstructorDecl);
5025 
5026  CXXConstructorDecl *Constructor
5027  = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
5028 
5029  if (!Constructor) {
5030  Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
5031  return;
5032  }
5033 
5034  // Mapping for the duplicate initializers check.
5035  // For member initializers, this is keyed with a FieldDecl*.
5036  // For base initializers, this is keyed with a Type*.
5037  llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
5038 
5039  // Mapping for the inconsistent anonymous-union initializers check.
5040  RedundantUnionMap MemberUnions;
5041 
5042  bool HadError = false;
5043  for (unsigned i = 0; i < MemInits.size(); i++) {
5044  CXXCtorInitializer *Init = MemInits[i];
5045 
5046  // Set the source order index.
5047  Init->setSourceOrder(i);
5048 
5049  if (Init->isAnyMemberInitializer()) {
5050  const void *Key = GetKeyForMember(Context, Init);
5051  if (CheckRedundantInit(*this, Init, Members[Key]) ||
5052  CheckRedundantUnionInit(*this, Init, MemberUnions))
5053  HadError = true;
5054  } else if (Init->isBaseInitializer()) {
5055  const void *Key = GetKeyForMember(Context, Init);
5056  if (CheckRedundantInit(*this, Init, Members[Key]))
5057  HadError = true;
5058  } else {
5059  assert(Init->isDelegatingInitializer());
5060  // This must be the only initializer
5061  if (MemInits.size() != 1) {
5062  Diag(Init->getSourceLocation(),
5063  diag::err_delegating_initializer_alone)
5064  << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
5065  // We will treat this as being the only initializer.
5066  }
5067  SetDelegatingInitializer(Constructor, MemInits[i]);
5068  // Return immediately as the initializer is set.
5069  return;
5070  }
5071  }
5072 
5073  if (HadError)
5074  return;
5075 
5076  DiagnoseBaseOrMemInitializerOrder(*this, Constructor, MemInits);
5077 
5078  SetCtorInitializers(Constructor, AnyErrors, MemInits);
5079 
5080  DiagnoseUninitializedFields(*this, Constructor);
5081 }
5082 
5083 void
5085  CXXRecordDecl *ClassDecl) {
5086  // Ignore dependent contexts. Also ignore unions, since their members never
5087  // have destructors implicitly called.
5088  if (ClassDecl->isDependentContext() || ClassDecl->isUnion())
5089  return;
5090 
5091  // FIXME: all the access-control diagnostics are positioned on the
5092  // field/base declaration. That's probably good; that said, the
5093  // user might reasonably want to know why the destructor is being
5094  // emitted, and we currently don't say.
5095 
5096  // Non-static data members.
5097  for (auto *Field : ClassDecl->fields()) {
5098  if (Field->isInvalidDecl())
5099  continue;
5100 
5101  // Don't destroy incomplete or zero-length arrays.
5102  if (isIncompleteOrZeroLengthArrayType(Context, Field->getType()))
5103  continue;
5104 
5105  QualType FieldType = Context.getBaseElementType(Field->getType());
5106 
5107  const RecordType* RT = FieldType->getAs<RecordType>();
5108  if (!RT)
5109  continue;
5110 
5111  CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
5112  if (FieldClassDecl->isInvalidDecl())
5113  continue;
5114  if (FieldClassDecl->hasIrrelevantDestructor())
5115  continue;
5116  // The destructor for an implicit anonymous union member is never invoked.
5117  if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
5118  continue;
5119 
5120  CXXDestructorDecl *Dtor = LookupDestructor(FieldClassDecl);
5121  assert(Dtor && "No dtor found for FieldClassDecl!");
5122  CheckDestructorAccess(Field->getLocation(), Dtor,
5123  PDiag(diag::err_access_dtor_field)
5124  << Field->getDeclName()
5125  << FieldType);
5126 
5127  MarkFunctionReferenced(Location, Dtor);
5128  DiagnoseUseOfDecl(Dtor, Location);
5129  }
5130 
5131  // We only potentially invoke the destructors of potentially constructed
5132  // subobjects.
5133  bool VisitVirtualBases = !ClassDecl->isAbstract();
5134 
5135  llvm::SmallPtrSet<const RecordType *, 8> DirectVirtualBases;
5136 
5137  // Bases.
5138  for (const auto &Base : ClassDecl->bases()) {
5139  // Bases are always records in a well-formed non-dependent class.
5140  const RecordType *RT = Base.getType()->getAs<RecordType>();
5141 
5142  // Remember direct virtual bases.
5143  if (Base.isVirtual()) {
5144  if (!VisitVirtualBases)
5145  continue;
5146  DirectVirtualBases.insert(RT);
5147  }
5148 
5149  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
5150  // If our base class is invalid, we probably can't get its dtor anyway.
5151  if (BaseClassDecl->isInvalidDecl())
5152  continue;
5153  if (BaseClassDecl->hasIrrelevantDestructor())
5154  continue;
5155 
5156  CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
5157  assert(Dtor && "No dtor found for BaseClassDecl!");
5158 
5159  // FIXME: caret should be on the start of the class name
5160  CheckDestructorAccess(Base.getLocStart(), Dtor,
5161  PDiag(diag::err_access_dtor_base)
5162  << Base.getType()
5163  << Base.getSourceRange(),
5164  Context.getTypeDeclType(ClassDecl));
5165 
5166  MarkFunctionReferenced(Location, Dtor);
5167  DiagnoseUseOfDecl(Dtor, Location);
5168  }
5169 
5170  if (!VisitVirtualBases)
5171  return;
5172 
5173  // Virtual bases.
5174  for (const auto &VBase : ClassDecl->vbases()) {
5175  // Bases are always records in a well-formed non-dependent class.
5176  const RecordType *RT = VBase.getType()->castAs<RecordType>();
5177 
5178  // Ignore direct virtual bases.
5179  if (DirectVirtualBases.count(RT))
5180  continue;
5181 
5182  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
5183  // If our base class is invalid, we probably can't get its dtor anyway.
5184  if (BaseClassDecl->isInvalidDecl())
5185  continue;
5186  if (BaseClassDecl->hasIrrelevantDestructor())
5187  continue;
5188 
5189  CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
5190  assert(Dtor && "No dtor found for BaseClassDecl!");
5191  if (CheckDestructorAccess(
5192  ClassDecl->getLocation(), Dtor,
5193  PDiag(diag::err_access_dtor_vbase)
5194  << Context.getTypeDeclType(ClassDecl) << VBase.getType(),
5195  Context.getTypeDeclType(ClassDecl)) ==
5196  AR_accessible) {
5197  CheckDerivedToBaseConversion(
5198  Context.getTypeDeclType(ClassDecl), VBase.getType(),
5199  diag::err_access_dtor_vbase, 0, ClassDecl->getLocation(),
5200  SourceRange(), DeclarationName(), nullptr);
5201  }
5202 
5203  MarkFunctionReferenced(Location, Dtor);
5204  DiagnoseUseOfDecl(Dtor, Location);
5205  }
5206 }
5207 
5208 void Sema::ActOnDefaultCtorInitializers(Decl *CDtorDecl) {
5209  if (!CDtorDecl)
5210  return;
5211 
5212  if (CXXConstructorDecl *Constructor
5213  = dyn_cast<CXXConstructorDecl>(CDtorDecl)) {
5214  SetCtorInitializers(Constructor, /*AnyErrors=*/false);
5215  DiagnoseUninitializedFields(*this, Constructor);
5216  }
5217 }
5218 
5220  if (!getLangOpts().CPlusPlus)
5221  return false;
5222 
5223  const auto *RD = Context.getBaseElementType(T)->getAsCXXRecordDecl();
5224  if (!RD)
5225  return false;
5226 
5227  // FIXME: Per [temp.inst]p1, we are supposed to trigger instantiation of a
5228  // class template specialization here, but doing so breaks a lot of code.
5229 
5230  // We can't answer whether something is abstract until it has a
5231  // definition. If it's currently being defined, we'll walk back
5232  // over all the declarations when we have a full definition.
5233  const CXXRecordDecl *Def = RD->getDefinition();
5234  if (!Def || Def->isBeingDefined())
5235  return false;
5236 
5237  return RD->isAbstract();
5238 }
5239 
5241  TypeDiagnoser &Diagnoser) {
5242  if (!isAbstractType(Loc, T))
5243  return false;
5244 
5245  T = Context.getBaseElementType(T);
5246  Diagnoser.diagnose(*this, Loc, T);
5247  DiagnoseAbstractType(T->getAsCXXRecordDecl());
5248  return true;
5249 }
5250 
5252  // Check if we've already emitted the list of pure virtual functions
5253  // for this class.
5254  if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
5255  return;
5256 
5257  // If the diagnostic is suppressed, don't emit the notes. We're only
5258  // going to emit them once, so try to attach them to a diagnostic we're
5259  // actually going to show.
5260  if (Diags.isLastDiagnosticIgnored())
5261  return;
5262 
5263  CXXFinalOverriderMap FinalOverriders;
5264  RD->getFinalOverriders(FinalOverriders);
5265 
5266  // Keep a set of seen pure methods so we won't diagnose the same method
5267  // more than once.
5268  llvm::SmallPtrSet<const CXXMethodDecl *, 8> SeenPureMethods;
5269 
5270  for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
5271  MEnd = FinalOverriders.end();
5272  M != MEnd;
5273  ++M) {
5274  for (OverridingMethods::iterator SO = M->second.begin(),
5275  SOEnd = M->second.end();
5276  SO != SOEnd; ++SO) {
5277  // C++ [class.abstract]p4:
5278  // A class is abstract if it contains or inherits at least one
5279  // pure virtual function for which the final overrider is pure
5280  // virtual.
5281 
5282  //
5283  if (SO->second.size() != 1)
5284  continue;
5285 
5286  if (!SO->second.front().Method->isPure())
5287  continue;
5288 
5289  if (!SeenPureMethods.insert(SO->second.front().Method).second)
5290  continue;
5291 
5292  Diag(SO->second.front().Method->getLocation(),
5293  diag::note_pure_virtual_function)
5294  << SO->second.front().Method->getDeclName() << RD->getDeclName();
5295  }
5296  }
5297 
5298  if (!PureVirtualClassDiagSet)
5299  PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
5300  PureVirtualClassDiagSet->insert(RD);
5301 }
5302 
5303 namespace {
5304 struct AbstractUsageInfo {
5305  Sema &S;
5306  CXXRecordDecl *Record;
5307  CanQualType AbstractType;
5308  bool Invalid;
5309 
5310  AbstractUsageInfo(Sema &S, CXXRecordDecl *Record)
5311  : S(S), Record(Record),
5312  AbstractType(S.Context.getCanonicalType(
5313  S.Context.getTypeDeclType(Record))),
5314  Invalid(false) {}
5315 
5316  void DiagnoseAbstractType() {
5317  if (Invalid) return;
5318  S.DiagnoseAbstractType(Record);
5319  Invalid = true;
5320  }
5321 
5322  void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
5323 };
5324 
5325 struct CheckAbstractUsage {
5326  AbstractUsageInfo &Info;
5327  const NamedDecl *Ctx;
5328 
5329  CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
5330  : Info(Info), Ctx(Ctx) {}
5331 
5332  void Visit(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
5333  switch (TL.getTypeLocClass()) {
5334 #define ABSTRACT_TYPELOC(CLASS, PARENT)
5335 #define TYPELOC(CLASS, PARENT) \
5336  case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
5337 #include "clang/AST/TypeLocNodes.def"
5338  }
5339  }
5340 
5341  void Check(FunctionProtoTypeLoc TL, Sema::AbstractDiagSelID Sel) {
5343  for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {
5344  if (!TL.getParam(I))
5345  continue;
5346 
5347  TypeSourceInfo *TSI = TL.getParam(I)->getTypeSourceInfo();
5348  if (TSI) Visit(TSI->getTypeLoc(), Sema::AbstractParamType);
5349  }
5350  }
5351 
5352  void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) {
5354  }
5355 
5357  // Visit the type parameters from a permissive context.
5358  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
5359  TemplateArgumentLoc TAL = TL.getArgLoc(I);
5361  if (TypeSourceInfo *TSI = TAL.getTypeSourceInfo())
5362  Visit(TSI->getTypeLoc(), Sema::AbstractNone);
5363  // TODO: other template argument types?
5364  }
5365  }
5366 
5367  // Visit pointee types from a permissive context.
5368 #define CheckPolymorphic(Type) \
5369  void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
5370  Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
5371  }
5377 
5378  /// Handle all the types we haven't given a more specific
5379  /// implementation for above.
5380  void Check(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
5381  // Every other kind of type that we haven't called out already
5382  // that has an inner type is either (1) sugar or (2) contains that
5383  // inner type in some way as a subobject.
5384  if (TypeLoc Next = TL.getNextTypeLoc())
5385  return Visit(Next, Sel);
5386 
5387  // If there's no inner type and we're in a permissive context,
5388  // don't diagnose.
5389  if (Sel == Sema::AbstractNone) return;
5390 
5391  // Check whether the type matches the abstract type.
5392  QualType T = TL.getType();
5393  if (T->isArrayType()) {
5395  T = Info.S.Context.getBaseElementType(T);
5396  }
5398  if (CT != Info.AbstractType) return;
5399 
5400  // It matched; do some magic.
5401  if (Sel == Sema::AbstractArrayType) {
5402  Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type)
5403  << T << TL.getSourceRange();
5404  } else {
5405  Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl)
5406  << Sel << T << TL.getSourceRange();
5407  }
5408  Info.DiagnoseAbstractType();
5409  }
5410 };
5411 
5412 void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
5414  CheckAbstractUsage(*this, D).Visit(TL, Sel);
5415 }
5416 
5417 }
5418 
5419 /// Check for invalid uses of an abstract type in a method declaration.
5420 static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
5421  CXXMethodDecl *MD) {
5422  // No need to do the check on definitions, which require that
5423  // the return/param types be complete.
5424  if (MD->doesThisDeclarationHaveABody())
5425  return;
5426 
5427  // For safety's sake, just ignore it if we don't have type source
5428  // information. This should never happen for non-implicit methods,
5429  // but...
5430  if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
5431  Info.CheckType(MD, TSI->getTypeLoc(), Sema::AbstractNone);
5432 }
5433 
5434 /// Check for invalid uses of an abstract type within a class definition.
5435 static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
5436  CXXRecordDecl *RD) {
5437  for (auto *D : RD->decls()) {
5438  if (D->isImplicit()) continue;
5439 
5440  // Methods and method templates.
5441  if (isa<CXXMethodDecl>(D)) {
5442  CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(D));
5443  } else if (isa<FunctionTemplateDecl>(D)) {
5444  FunctionDecl *FD = cast<FunctionTemplateDecl>(D)->getTemplatedDecl();
5445  CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(FD));
5446 
5447  // Fields and static variables.
5448  } else if (isa<FieldDecl>(D)) {
5449  FieldDecl *FD = cast<FieldDecl>(D);
5450  if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
5451  Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractFieldType);
5452  } else if (isa<VarDecl>(D)) {
5453  VarDecl *VD = cast<VarDecl>(D);
5454  if (TypeSourceInfo *TSI = VD->getTypeSourceInfo())
5455  Info.CheckType(VD, TSI->getTypeLoc(), Sema::AbstractVariableType);
5456 
5457  // Nested classes and class templates.
5458  } else if (isa<CXXRecordDecl>(D)) {
5459  CheckAbstractClassUsage(Info, cast<CXXRecordDecl>(D));
5460  } else if (isa<ClassTemplateDecl>(D)) {
5462  cast<ClassTemplateDecl>(D)->getTemplatedDecl());
5463  }
5464  }
5465 }
5466 
5468  Attr *ClassAttr = getDLLAttr(Class);
5469  if (!ClassAttr)
5470  return;
5471 
5472  assert(ClassAttr->getKind() == attr::DLLExport);
5473 
5475 
5477  // Don't go any further if this is just an explicit instantiation
5478  // declaration.
5479  return;
5480 
5481  for (Decl *Member : Class->decls()) {
5482  auto *MD = dyn_cast<CXXMethodDecl>(Member);
5483  if (!MD)
5484  continue;
5485 
5486  if (Member->getAttr<DLLExportAttr>()) {
5487  if (MD->isUserProvided()) {
5488  // Instantiate non-default class member functions ...
5489 
5490  // .. except for certain kinds of template specializations.
5491  if (TSK == TSK_ImplicitInstantiation && !ClassAttr->isInherited())
5492  continue;
5493 
5494  S.MarkFunctionReferenced(Class->getLocation(), MD);
5495 
5496  // The function will be passed to the consumer when its definition is
5497  // encountered.
5498  } else if (!MD->isTrivial() || MD->isExplicitlyDefaulted() ||
5499  MD->isCopyAssignmentOperator() ||
5500  MD->isMoveAssignmentOperator()) {
5501  // Synthesize and instantiate non-trivial implicit methods, explicitly
5502  // defaulted methods, and the copy and move assignment operators. The
5503  // latter are exported even if they are trivial, because the address of
5504  // an operator can be taken and should compare equal across libraries.
5505  DiagnosticErrorTrap Trap(S.Diags);
5506  S.MarkFunctionReferenced(Class->getLocation(), MD);
5507  if (Trap.hasErrorOccurred()) {
5508  S.Diag(ClassAttr->getLocation(), diag::note_due_to_dllexported_class)
5509  << Class->getName() << !S.getLangOpts().CPlusPlus11;
5510  break;
5511  }
5512 
5513  // There is no later point when we will see the definition of this
5514  // function, so pass it to the consumer now.
5516  }
5517  }
5518  }
5519 }
5520 
5522  CXXRecordDecl *Class) {
5523  // Only the MS ABI has default constructor closures, so we don't need to do
5524  // this semantic checking anywhere else.
5526  return;
5527 
5528  CXXConstructorDecl *LastExportedDefaultCtor = nullptr;
5529  for (Decl *Member : Class->decls()) {
5530  // Look for exported default constructors.
5531  auto *CD = dyn_cast<CXXConstructorDecl>(Member);
5532  if (!CD || !CD->isDefaultConstructor())
5533  continue;
5534  auto *Attr = CD->getAttr<DLLExportAttr>();
5535  if (!Attr)
5536  continue;
5537 
5538  // If the class is non-dependent, mark the default arguments as ODR-used so
5539  // that we can properly codegen the constructor closure.
5540  if (!Class->isDependentContext()) {
5541  for (ParmVarDecl *PD : CD->parameters()) {
5542  (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), CD, PD);
5544  }
5545  }
5546 
5547  if (LastExportedDefaultCtor) {
5548  S.Diag(LastExportedDefaultCtor->getLocation(),
5549  diag::err_attribute_dll_ambiguous_default_ctor)
5550  << Class;
5551  S.Diag(CD->getLocation(), diag::note_entity_declared_at)
5552  << CD->getDeclName();
5553  return;
5554  }
5555  LastExportedDefaultCtor = CD;
5556  }
5557 }
5558 
5559 /// \brief Check class-level dllimport/dllexport attribute.
5561  Attr *ClassAttr = getDLLAttr(Class);
5562 
5563  // MSVC inherits DLL attributes to partial class template specializations.
5564  if (Context.getTargetInfo().getCXXABI().isMicrosoft() && !ClassAttr) {
5565  if (auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(Class)) {
5566  if (Attr *TemplateAttr =
5567  getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
5568  auto *A = cast<InheritableAttr>(TemplateAttr->clone(getASTContext()));
5569  A->setInherited(true);
5570  ClassAttr = A;
5571  }
5572  }
5573  }
5574 
5575  if (!ClassAttr)
5576  return;
5577 
5578  if (!Class->isExternallyVisible()) {
5579  Diag(Class->getLocation(), diag::err_attribute_dll_not_extern)
5580  << Class << ClassAttr;
5581  return;
5582  }
5583 
5584  if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
5585  !ClassAttr->isInherited()) {
5586  // Diagnose dll attributes on members of class with dll attribute.
5587  for (Decl *Member : Class->decls()) {
5588  if (!isa<VarDecl>(Member) && !isa<CXXMethodDecl>(Member))
5589  continue;
5590  InheritableAttr *MemberAttr = getDLLAttr(Member);
5591  if (!MemberAttr || MemberAttr->isInherited() || Member->isInvalidDecl())
5592  continue;
5593 
5594  Diag(MemberAttr->getLocation(),
5595  diag::err_attribute_dll_member_of_dll_class)
5596  << MemberAttr << ClassAttr;
5597  Diag(ClassAttr->getLocation(), diag::note_previous_attribute);
5598  Member->setInvalidDecl();
5599  }
5600  }
5601 
5602  if (Class->getDescribedClassTemplate())
5603  // Don't inherit dll attribute until the template is instantiated.
5604  return;
5605 
5606  // The class is either imported or exported.
5607  const bool ClassExported = ClassAttr->getKind() == attr::DLLExport;
5608 
5610 
5611  // Ignore explicit dllexport on explicit class template instantiation declarations.
5612  if (ClassExported && !ClassAttr->isInherited() &&
5614  Class->dropAttr<DLLExportAttr>();
5615  return;
5616  }
5617 
5618  // Force declaration of implicit members so they can inherit the attribute.
5619  ForceDeclarationOfImplicitMembers(Class);
5620 
5621  // FIXME: MSVC's docs say all bases must be exportable, but this doesn't
5622  // seem to be true in practice?
5623 
5624  for (Decl *Member : Class->decls()) {
5625  VarDecl *VD = dyn_cast<VarDecl>(Member);
5626  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Member);
5627 
5628  // Only methods and static fields inherit the attributes.
5629  if (!VD && !MD)
5630  continue;
5631 
5632  if (MD) {
5633  // Don't process deleted methods.
5634  if (MD->isDeleted())
5635  continue;
5636 
5637  if (MD->isInlined()) {
5638  // MinGW does not import or export inline methods.
5639  if (!Context.getTargetInfo().getCXXABI().isMicrosoft() &&
5640  !Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())
5641  continue;
5642 
5643  // MSVC versions before 2015 don't export the move assignment operators
5644  // and move constructor, so don't attempt to import/export them if
5645  // we have a definition.
5646  auto *Ctor = dyn_cast<CXXConstructorDecl>(MD);
5647  if ((MD->isMoveAssignmentOperator() ||
5648  (Ctor && Ctor->isMoveConstructor())) &&
5649  !getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015))
5650  continue;
5651 
5652  // MSVC2015 doesn't export trivial defaulted x-tor but copy assign
5653  // operator is exported anyway.
5654  if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
5655  (Ctor || isa<CXXDestructorDecl>(MD)) && MD->isTrivial())
5656  continue;
5657  }
5658  }
5659 
5660  if (!cast<NamedDecl>(Member)->isExternallyVisible())
5661  continue;
5662 
5663  if (!getDLLAttr(Member)) {
5664  auto *NewAttr =
5665  cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
5666  NewAttr->setInherited(true);
5667  Member->addAttr(NewAttr);
5668  }
5669  }
5670 
5671  if (ClassExported)
5672  DelayedDllExportClasses.push_back(Class);
5673 }
5674 
5675 /// \brief Perform propagation of DLL attributes from a derived class to a
5676 /// templated base class for MS compatibility.
5678  CXXRecordDecl *Class, Attr *ClassAttr,
5679  ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc) {
5680  if (getDLLAttr(
5681  BaseTemplateSpec->getSpecializedTemplate()->getTemplatedDecl())) {
5682  // If the base class template has a DLL attribute, don't try to change it.
5683  return;
5684  }
5685 
5686  auto TSK = BaseTemplateSpec->getSpecializationKind();
5687  if (!getDLLAttr(BaseTemplateSpec) &&
5689  TSK == TSK_ImplicitInstantiation)) {
5690  // The template hasn't been instantiated yet (or it has, but only as an
5691  // explicit instantiation declaration or implicit instantiation, which means
5692  // we haven't codegenned any members yet), so propagate the attribute.
5693  auto *NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
5694  NewAttr->setInherited(true);
5695  BaseTemplateSpec->addAttr(NewAttr);
5696 
5697  // If the template is already instantiated, checkDLLAttributeRedeclaration()
5698  // needs to be run again to work see the new attribute. Otherwise this will
5699  // get run whenever the template is instantiated.
5700  if (TSK != TSK_Undeclared)
5701  checkClassLevelDLLAttribute(BaseTemplateSpec);
5702 
5703  return;
5704  }
5705 
5706  if (getDLLAttr(BaseTemplateSpec)) {
5707  // The template has already been specialized or instantiated with an
5708  // attribute, explicitly or through propagation. We should not try to change
5709  // it.
5710  return;
5711  }
5712 
5713  // The template was previously instantiated or explicitly specialized without
5714  // a dll attribute, It's too late for us to add an attribute, so warn that
5715  // this is unsupported.
5716  Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)
5717  << BaseTemplateSpec->isExplicitSpecialization();
5718  Diag(ClassAttr->getLocation(), diag::note_attribute);
5719  if (BaseTemplateSpec->isExplicitSpecialization()) {
5720  Diag(BaseTemplateSpec->getLocation(),
5721  diag::note_template_class_explicit_specialization_was_here)
5722  << BaseTemplateSpec;
5723  } else {
5724  Diag(BaseTemplateSpec->getPointOfInstantiation(),
5725  diag::note_template_class_instantiation_was_here)
5726  << BaseTemplateSpec;
5727  }
5728 }
5729 
5731  SourceLocation DefaultLoc) {
5732  switch (S.getSpecialMember(MD)) {
5734  S.DefineImplicitDefaultConstructor(DefaultLoc,
5735  cast<CXXConstructorDecl>(MD));
5736  break;
5738  S.DefineImplicitCopyConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
5739  break;
5741  S.DefineImplicitCopyAssignment(DefaultLoc, MD);
5742  break;
5743  case Sema::CXXDestructor:
5744  S.DefineImplicitDestructor(DefaultLoc, cast<CXXDestructorDecl>(MD));
5745  break;
5747  S.DefineImplicitMoveConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
5748  break;
5750  S.DefineImplicitMoveAssignment(DefaultLoc, MD);
5751  break;
5752  case Sema::CXXInvalid:
5753  llvm_unreachable("Invalid special member.");
5754  }
5755 }
5756 
5757 /// Determine whether a type is permitted to be passed or returned in
5758 /// registers, per C++ [class.temporary]p3.
5760  if (D->isDependentType() || D->isInvalidDecl())
5761  return false;
5762 
5763  // Per C++ [class.temporary]p3, the relevant condition is:
5764  // each copy constructor, move constructor, and destructor of X is
5765  // either trivial or deleted, and X has at least one non-deleted copy
5766  // or move constructor
5767  bool HasNonDeletedCopyOrMove = false;
5768 
5769  if (D->needsImplicitCopyConstructor() &&
5771  if (!D->hasTrivialCopyConstructor())
5772  return false;
5773  HasNonDeletedCopyOrMove = true;
5774  }
5775 
5776  if (S.getLangOpts().CPlusPlus11 && D->needsImplicitMoveConstructor() &&
5778  if (!D->hasTrivialMoveConstructor())
5779  return false;
5780  HasNonDeletedCopyOrMove = true;
5781  }
5782 
5784  !D->hasTrivialDestructor())
5785  return false;
5786 
5787  for (const CXXMethodDecl *MD : D->methods()) {
5788  if (MD->isDeleted())
5789  continue;
5790 
5791  auto *CD = dyn_cast<CXXConstructorDecl>(MD);
5792  if (CD && CD->isCopyOrMoveConstructor())
5793  HasNonDeletedCopyOrMove = true;
5794  else if (!isa<CXXDestructorDecl>(MD))
5795  continue;
5796 
5797  if (!MD->isTrivial())
5798  return false;
5799  }
5800 
5801  return HasNonDeletedCopyOrMove;
5802 }
5803 
5804 /// \brief Perform semantic checks on a class definition that has been
5805 /// completing, introducing implicitly-declared members, checking for
5806 /// abstract types, etc.
5808  if (!Record)
5809  return;
5810 
5811  if (Record->isAbstract() && !Record->isInvalidDecl()) {
5812  AbstractUsageInfo Info(*this, Record);
5813  CheckAbstractClassUsage(Info, Record);
5814  }
5815 
5816  // If this is not an aggregate type and has no user-declared constructor,
5817  // complain about any non-static data members of reference or const scalar
5818  // type, since they will never get initializers.
5819  if (!Record->isInvalidDecl() && !Record->isDependentType() &&
5820  !Record->isAggregate() && !Record->hasUserDeclaredConstructor() &&
5821  !Record->isLambda()) {
5822  bool Complained = false;
5823  for (const auto *F : Record->fields()) {
5824  if (F->hasInClassInitializer() || F->isUnnamedBitfield())
5825  continue;
5826 
5827  if (F->getType()->isReferenceType() ||
5828  (F->getType().isConstQualified() && F->getType()->isScalarType())) {
5829  if (!Complained) {
5830  Diag(Record->getLocation(), diag::warn_no_constructor_for_refconst)
5831  << Record->getTagKind() << Record;
5832  Complained = true;
5833  }
5834 
5835  Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
5836  << F->getType()->isReferenceType()
5837  << F->getDeclName();
5838  }
5839  }
5840  }
5841 
5842  if (Record->getIdentifier()) {
5843  // C++ [class.mem]p13:
5844  // If T is the name of a class, then each of the following shall have a
5845  // name different from T:
5846  // - every member of every anonymous union that is a member of class T.
5847  //
5848  // C++ [class.mem]p14:
5849  // In addition, if class T has a user-declared constructor (12.1), every
5850  // non-static data member of class T shall have a name different from T.
5851  DeclContext::lookup_result R = Record->lookup(Record->getDeclName());
5852  for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
5853  ++I) {
5854  NamedDecl *D = *I;
5855  if ((isa<FieldDecl>(D) && Record->hasUserDeclaredConstructor()) ||
5856  isa<IndirectFieldDecl>(D)) {
5857  Diag(D->getLocation(), diag::err_member_name_of_class)
5858  << D->getDeclName();
5859  break;
5860  }
5861  }
5862  }
5863 
5864  // Warn if the class has virtual methods but non-virtual public destructor.
5865  if (Record->isPolymorphic() && !Record->isDependentType()) {
5866  CXXDestructorDecl *dtor = Record->getDestructor();
5867  if ((!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public)) &&
5868  !Record->hasAttr<FinalAttr>())
5869  Diag(dtor ? dtor->getLocation() : Record->getLocation(),
5870  diag::warn_non_virtual_dtor) << Context.getRecordType(Record);
5871  }
5872 
5873  if (Record->isAbstract()) {
5874  if (FinalAttr *FA = Record->getAttr<FinalAttr>()) {
5875  Diag(Record->getLocation(), diag::warn_abstract_final_class)
5876  << FA->isSpelledAsSealed();
5877  DiagnoseAbstractType(Record);
5878  }
5879  }
5880 
5881  bool HasMethodWithOverrideControl = false,
5882  HasOverridingMethodWithoutOverrideControl = false;
5883  if (!Record->isDependentType()) {
5884  for (auto *M : Record->methods()) {
5885  // See if a method overloads virtual methods in a base
5886  // class without overriding any.
5887  if (!M->isStatic())
5888  DiagnoseHiddenVirtualMethods(M);
5889  if (M->hasAttr<OverrideAttr>())
5890  HasMethodWithOverrideControl = true;
5891  else if (M->size_overridden_methods() > 0)
5892  HasOverridingMethodWithoutOverrideControl = true;
5893  // Check whether the explicitly-defaulted special members are valid.
5894  if (!M->isInvalidDecl() && M->isExplicitlyDefaulted())
5895  CheckExplicitlyDefaultedSpecialMember(M);
5896 
5897  // For an explicitly defaulted or deleted special member, we defer
5898  // determining triviality until the class is complete. That time is now!
5899  CXXSpecialMember CSM = getSpecialMember(M);
5900  if (!M->isImplicit() && !M->isUserProvided()) {
5901  if (CSM != CXXInvalid) {
5902  M->setTrivial(SpecialMemberIsTrivial(M, CSM));
5903 
5904  // Inform the class that we've finished declaring this member.
5906  }
5907  }
5908 
5909  if (!M->isInvalidDecl() && M->isExplicitlyDefaulted() &&
5910  M->hasAttr<DLLExportAttr>()) {
5911  if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
5912  M->isTrivial() &&
5913  (CSM == CXXDefaultConstructor || CSM == CXXCopyConstructor ||
5914  CSM == CXXDestructor))
5915  M->dropAttr<DLLExportAttr>();
5916 
5917  if (M->hasAttr<DLLExportAttr>()) {
5918  DefineImplicitSpecialMember(*this, M, M->getLocation());
5919  ActOnFinishInlineFunctionDef(M);
5920  }
5921  }
5922  }
5923  }
5924 
5925  if (HasMethodWithOverrideControl &&
5926  HasOverridingMethodWithoutOverrideControl) {
5927  // At least one method has the 'override' control declared.
5928  // Diagnose all other overridden methods which do not have 'override' specified on them.
5929  for (auto *M : Record->methods())
5930  DiagnoseAbsenceOfOverrideControl(M);
5931  }
5932 
5933  // ms_struct is a request to use the same ABI rules as MSVC. Check
5934  // whether this class uses any C++ features that are implemented
5935  // completely differently in MSVC, and if so, emit a diagnostic.
5936  // That diagnostic defaults to an error, but we allow projects to
5937  // map it down to a warning (or ignore it). It's a fairly common
5938  // practice among users of the ms_struct pragma to mass-annotate
5939  // headers, sweeping up a bunch of types that the project doesn't
5940  // really rely on MSVC-compatible layout for. We must therefore
5941  // support "ms_struct except for C++ stuff" as a secondary ABI.
5942  if (Record->isMsStruct(Context) &&
5943  (Record->isPolymorphic() || Record->getNumBases())) {
5944  Diag(Record->getLocation(), diag::warn_cxx_ms_struct);
5945  }
5946 
5947  checkClassLevelDLLAttribute(Record);
5948 
5949  Record->setCanPassInRegisters(computeCanPassInRegisters(*this, Record));
5950 }
5951 
5952 /// Look up the special member function that would be called by a special
5953 /// member function for a subobject of class type.
5954 ///
5955 /// \param Class The class type of the subobject.
5956 /// \param CSM The kind of special member function.
5957 /// \param FieldQuals If the subobject is a field, its cv-qualifiers.
5958 /// \param ConstRHS True if this is a copy operation with a const object
5959 /// on its RHS, that is, if the argument to the outer special member
5960 /// function is 'const' and this is not a field marked 'mutable'.
5962  Sema &S, CXXRecordDecl *Class, Sema::CXXSpecialMember CSM,
5963  unsigned FieldQuals, bool ConstRHS) {
5964  unsigned LHSQuals = 0;
5965  if (CSM == Sema::CXXCopyAssignment || CSM == Sema::CXXMoveAssignment)
5966  LHSQuals = FieldQuals;
5967 
5968  unsigned RHSQuals = FieldQuals;
5969  if (CSM == Sema::CXXDefaultConstructor || CSM == Sema::CXXDestructor)
5970  RHSQuals = 0;
5971  else if (ConstRHS)
5972  RHSQuals |= Qualifiers::Const;
5973 
5974  return S.LookupSpecialMember(Class, CSM,
5975  RHSQuals & Qualifiers::Const,
5976  RHSQuals & Qualifiers::Volatile,
5977  false,
5978  LHSQuals & Qualifiers::Const,
5979  LHSQuals & Qualifiers::Volatile);
5980 }
5981 
5983  Sema &S;
5984  SourceLocation UseLoc;
5985 
5986  /// A mapping from the base classes through which the constructor was
5987  /// inherited to the using shadow declaration in that base class (or a null
5988  /// pointer if the constructor was declared in that base class).
5989  llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
5990  InheritedFromBases;
5991 
5992 public:
5995  : S(S), UseLoc(UseLoc) {
5996  bool DiagnosedMultipleConstructedBases = false;
5997  CXXRecordDecl *ConstructedBase = nullptr;
5998  UsingDecl *ConstructedBaseUsing = nullptr;
5999 
6000  // Find the set of such base class subobjects and check that there's a
6001  // unique constructed subobject.
6002  for (auto *D : Shadow->redecls()) {
6003  auto *DShadow = cast<ConstructorUsingShadowDecl>(D);
6004  auto *DNominatedBase = DShadow->getNominatedBaseClass();
6005  auto *DConstructedBase = DShadow->getConstructedBaseClass();
6006 
6007  InheritedFromBases.insert(
6008  std::make_pair(DNominatedBase->getCanonicalDecl(),
6009  DShadow->getNominatedBaseClassShadowDecl()));
6010  if (DShadow->constructsVirtualBase())
6011  InheritedFromBases.insert(
6012  std::make_pair(DConstructedBase->getCanonicalDecl(),
6013  DShadow->getConstructedBaseClassShadowDecl()));
6014  else
6015  assert(DNominatedBase == DConstructedBase);
6016 
6017  // [class.inhctor.init]p2:
6018  // If the constructor was inherited from multiple base class subobjects
6019  // of type B, the program is ill-formed.
6020  if (!ConstructedBase) {
6021  ConstructedBase = DConstructedBase;
6022  ConstructedBaseUsing = D->getUsingDecl();
6023  } else if (ConstructedBase != DConstructedBase &&
6024  !Shadow->isInvalidDecl()) {
6025  if (!DiagnosedMultipleConstructedBases) {
6026  S.Diag(UseLoc, diag::err_ambiguous_inherited_constructor)
6027  << Shadow->getTargetDecl();
6028  S.Diag(ConstructedBaseUsing->getLocation(),
6029  diag::note_ambiguous_inherited_constructor_using)
6030  << ConstructedBase;
6031  DiagnosedMultipleConstructedBases = true;
6032  }
6033  S.Diag(D->getUsingDecl()->getLocation(),
6034  diag::note_ambiguous_inherited_constructor_using)
6035  << DConstructedBase;
6036  }
6037  }
6038 
6039  if (DiagnosedMultipleConstructedBases)
6040  Shadow->setInvalidDecl();
6041  }
6042 
6043  /// Find the constructor to use for inherited construction of a base class,
6044  /// and whether that base class constructor inherits the constructor from a
6045  /// virtual base class (in which case it won't actually invoke it).
6046  std::pair<CXXConstructorDecl *, bool>
6048  auto It = InheritedFromBases.find(Base->getCanonicalDecl());
6049  if (It == InheritedFromBases.end())
6050  return std::make_pair(nullptr, false);
6051 
6052  // This is an intermediary class.
6053  if (It->second)
6054  return std::make_pair(
6055  S.findInheritingConstructor(UseLoc, Ctor, It->second),
6056  It->second->constructsVirtualBase());
6057 
6058  // This is the base class from which the constructor was inherited.
6059  return std::make_pair(Ctor, false);
6060  }
6061 };
6062 
6063 /// Is the special member function which would be selected to perform the
6064 /// specified operation on the specified class type a constexpr constructor?
6065 static bool
6067  Sema::CXXSpecialMember CSM, unsigned Quals,
6068  bool ConstRHS,
6069  CXXConstructorDecl *InheritedCtor = nullptr,
6070  Sema::InheritedConstructorInfo *Inherited = nullptr) {
6071  // If we're inheriting a constructor, see if we need to call it for this base
6072  // class.
6073  if (InheritedCtor) {
6074  assert(CSM == Sema::CXXDefaultConstructor);
6075  auto BaseCtor =
6076  Inherited->findConstructorForBase(ClassDecl, InheritedCtor).first;
6077  if (BaseCtor)
6078  return BaseCtor->isConstexpr();
6079  }
6080 
6081  if (CSM == Sema::CXXDefaultConstructor)
6082  return ClassDecl->hasConstexprDefaultConstructor();
6083 
6085  lookupCallFromSpecialMember(S, ClassDecl, CSM, Quals, ConstRHS);
6086  if (!SMOR.getMethod())
6087  // A constructor we wouldn't select can't be "involved in initializing"
6088  // anything.
6089  return true;
6090  return SMOR.getMethod()->isConstexpr();
6091 }
6092 
6093 /// Determine whether the specified special member function would be constexpr
6094 /// if it were implicitly defined.
6096  Sema &S, CXXRecordDecl *ClassDecl, Sema::CXXSpecialMember CSM,
6097  bool ConstArg, CXXConstructorDecl *InheritedCtor = nullptr,
6098  Sema::InheritedConstructorInfo *Inherited = nullptr) {
6099  if (!S.getLangOpts().CPlusPlus11)
6100  return false;
6101 
6102  // C++11 [dcl.constexpr]p4:
6103  // In the definition of a constexpr constructor [...]
6104  bool Ctor = true;
6105  switch (CSM) {
6107  if (Inherited)
6108  break;
6109  // Since default constructor lookup is essentially trivial (and cannot
6110  // involve, for instance, template instantiation), we compute whether a
6111  // defaulted default constructor is constexpr directly within CXXRecordDecl.
6112  //
6113  // This is important for performance; we need to know whether the default
6114  // constructor is constexpr to determine whether the type is a literal type.
6115  return ClassDecl->defaultedDefaultConstructorIsConstexpr();
6116 
6119  // For copy or move constructors, we need to perform overload resolution.
6120  break;
6121 
6124  if (!S.getLangOpts().CPlusPlus14)
6125  return false;
6126  // In C++1y, we need to perform overload resolution.
6127  Ctor = false;
6128  break;
6129 
6130  case Sema::CXXDestructor:
6131  case Sema::CXXInvalid:
6132  return false;
6133  }
6134 
6135  // -- if the class is a non-empty union, or for each non-empty anonymous
6136  // union member of a non-union class, exactly one non-static data member
6137  // shall be initialized; [DR1359]
6138  //
6139  // If we squint, this is guaranteed, since exactly one non-static data member
6140  // will be initialized (if the constructor isn't deleted), we just don't know
6141  // which one.
6142  if (Ctor && ClassDecl->isUnion())
6143  return CSM == Sema::CXXDefaultConstructor
6144  ? ClassDecl->hasInClassInitializer() ||
6145  !ClassDecl->hasVariantMembers()
6146  : true;
6147 
6148  // -- the class shall not have any virtual base classes;
6149  if (Ctor && ClassDecl->getNumVBases())
6150  return false;
6151 
6152  // C++1y [class.copy]p26:
6153  // -- [the class] is a literal type, and
6154  if (!Ctor && !ClassDecl->isLiteral())
6155  return false;
6156 
6157  // -- every constructor involved in initializing [...] base class
6158  // sub-objects shall be a constexpr constructor;
6159  // -- the assignment operator selected to copy/move each direct base
6160  // class is a constexpr function, and
6161  for (const auto &B : ClassDecl->bases()) {
6162  const RecordType *BaseType = B.getType()->getAs<RecordType>();
6163  if (!BaseType) continue;
6164 
6165  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
6166  if (!specialMemberIsConstexpr(S, BaseClassDecl, CSM, 0, ConstArg,
6167  InheritedCtor, Inherited))
6168  return false;
6169  }
6170 
6171  // -- every constructor involved in initializing non-static data members
6172  // [...] shall be a constexpr constructor;
6173  // -- every non-static data member and base class sub-object shall be
6174  // initialized
6175  // -- for each non-static data member of X that is of class type (or array
6176  // thereof), the assignment operator selected to copy/move that member is
6177  // a constexpr function
6178  for (const auto *F : ClassDecl->fields()) {
6179  if (F->isInvalidDecl())
6180  continue;
6181  if (CSM == Sema::CXXDefaultConstructor && F->hasInClassInitializer())
6182  continue;
6183  QualType BaseType = S.Context.getBaseElementType(F->getType());
6184  if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
6185  CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
6186  if (!specialMemberIsConstexpr(S, FieldRecDecl, CSM,
6187  BaseType.getCVRQualifiers(),
6188  ConstArg && !F->isMutable()))
6189  return false;
6190  } else if (CSM == Sema::CXXDefaultConstructor) {
6191  return false;
6192  }
6193  }
6194 
6195  // All OK, it's constexpr!
6196  return true;
6197 }
6198 
6203 
6206  auto CSM = S.getSpecialMember(MD);
6207  if (CSM != Sema::CXXInvalid)
6208  return ComputeDefaultedSpecialMemberExceptionSpec(S, Loc, MD, CSM, nullptr);
6209 
6210  auto *CD = cast<CXXConstructorDecl>(MD);
6211  assert(CD->getInheritedConstructor() &&
6212  "only special members have implicit exception specs");
6214  S, Loc, CD->getInheritedConstructor().getShadowDecl());
6216  S, Loc, CD, Sema::CXXDefaultConstructor, &ICI);
6217 }
6218 
6220  CXXMethodDecl *MD) {
6222 
6223  // Build an exception specification pointing back at this member.
6225  EPI.ExceptionSpec.SourceDecl = MD;
6226 
6227  // Set the calling convention to the default for C++ instance methods.
6228  EPI.ExtInfo = EPI.ExtInfo.withCallingConv(
6229  S.Context.getDefaultCallingConvention(/*IsVariadic=*/false,
6230  /*IsCXXMethod=*/true));
6231  return EPI;
6232 }
6233 
6235  const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
6236  if (FPT->getExceptionSpecType() != EST_Unevaluated)
6237  return;
6238 
6239  // Evaluate the exception specification.
6240  auto IES = computeImplicitExceptionSpec(*this, Loc, MD);
6241  auto ESI = IES.getExceptionSpec();
6242 
6243  // Update the type of the special member to use it.
6244  UpdateExceptionSpec(MD, ESI);
6245 
6246  // A user-provided destructor can be defined outside the class. When that
6247  // happens, be sure to update the exception specification on both
6248  // declarations.
6249  const FunctionProtoType *CanonicalFPT =
6251  if (CanonicalFPT->getExceptionSpecType() == EST_Unevaluated)
6252  UpdateExceptionSpec(MD->getCanonicalDecl(), ESI);
6253 }
6254 
6256  CXXRecordDecl *RD = MD->getParent();
6257  CXXSpecialMember CSM = getSpecialMember(MD);
6258 
6259  assert(MD->isExplicitlyDefaulted() && CSM != CXXInvalid &&
6260  "not an explicitly-defaulted special member");
6261 
6262  // Whether this was the first-declared instance of the constructor.
6263  // This affects whether we implicitly add an exception spec and constexpr.
6264  bool First = MD == MD->getCanonicalDecl();
6265 
6266  bool HadError = false;
6267 
6268  // C++11 [dcl.fct.def.default]p1:
6269  // A function that is explicitly defaulted shall
6270  // -- be a special member function (checked elsewhere),
6271  // -- have the same type (except for ref-qualifiers, and except that a
6272  // copy operation can take a non-const reference) as an implicit
6273  // declaration, and
6274  // -- not have default arguments.
6275  unsigned ExpectedParams = 1;
6276  if (CSM == CXXDefaultConstructor || CSM == CXXDestructor)
6277  ExpectedParams = 0;
6278  if (MD->getNumParams() != ExpectedParams) {
6279  // This also checks for default arguments: a copy or move constructor with a
6280  // default argument is classified as a default constructor, and assignment
6281  // operations and destructors can't have default arguments.
6282  Diag(MD->getLocation(), diag::err_defaulted_special_member_params)
6283  << CSM << MD->getSourceRange();
6284  HadError = true;
6285  } else if (MD->isVariadic()) {
6286  Diag(MD->getLocation(), diag::err_defaulted_special_member_variadic)
6287  << CSM << MD->getSourceRange();
6288  HadError = true;
6289  }
6290 
6292 
6293  bool CanHaveConstParam = false;
6294  if (CSM == CXXCopyConstructor)
6295  CanHaveConstParam = RD->implicitCopyConstructorHasConstParam();
6296  else if (CSM == CXXCopyAssignment)
6297  CanHaveConstParam = RD->implicitCopyAssignmentHasConstParam();
6298 
6299  QualType ReturnType = Context.VoidTy;
6300  if (CSM == CXXCopyAssignment || CSM == CXXMoveAssignment) {
6301  // Check for return type matching.
6302  ReturnType = Type->getReturnType();
6303  QualType ExpectedReturnType =
6304  Context.getLValueReferenceType(Context.getTypeDeclType(RD));
6305  if (!Context.hasSameType(ReturnType, ExpectedReturnType)) {
6306  Diag(MD->getLocation(), diag::err_defaulted_special_member_return_type)
6307  << (CSM == CXXMoveAssignment) << ExpectedReturnType;
6308  HadError = true;
6309  }
6310 
6311  // A defaulted special member cannot have cv-qualifiers.
6312  if (Type->getTypeQuals()) {
6313  Diag(MD->getLocation(), diag::err_defaulted_special_member_quals)
6314  << (CSM == CXXMoveAssignment) << getLangOpts().CPlusPlus14;
6315  HadError = true;
6316  }
6317  }
6318 
6319  // Check for parameter type matching.
6320  QualType ArgType = ExpectedParams ? Type->getParamType(0) : QualType();
6321  bool HasConstParam = false;
6322  if (ExpectedParams && ArgType->isReferenceType()) {
6323  // Argument must be reference to possibly-const T.
6324  QualType ReferentType = ArgType->getPointeeType();
6325  HasConstParam = ReferentType.isConstQualified();
6326 
6327  if (ReferentType.isVolatileQualified()) {
6328  Diag(MD->getLocation(),
6329  diag::err_defaulted_special_member_volatile_param) << CSM;
6330  HadError = true;
6331  }
6332 
6333  if (HasConstParam && !CanHaveConstParam) {
6334  if (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment) {
6335  Diag(MD->getLocation(),
6336  diag::err_defaulted_special_member_copy_const_param)
6337  << (CSM == CXXCopyAssignment);
6338  // FIXME: Explain why this special member can't be const.
6339  } else {
6340  Diag(MD->getLocation(),
6341  diag::err_defaulted_special_member_move_const_param)
6342  << (CSM == CXXMoveAssignment);
6343  }
6344  HadError = true;
6345  }
6346  } else if (ExpectedParams) {
6347  // A copy assignment operator can take its argument by value, but a
6348  // defaulted one cannot.
6349  assert(CSM == CXXCopyAssignment && "unexpected non-ref argument");
6350  Diag(MD->getLocation(), diag::err_defaulted_copy_assign_not_ref);
6351  HadError = true;
6352  }
6353 
6354  // C++11 [dcl.fct.def.default]p2:
6355  // An explicitly-defaulted function may be declared constexpr only if it
6356  // would have been implicitly declared as constexpr,
6357  // Do not apply this rule to members of class templates, since core issue 1358
6358  // makes such functions always instantiate to constexpr functions. For
6359  // functions which cannot be constexpr (for non-constructors in C++11 and for
6360  // destructors in C++1y), this is checked elsewhere.
6361  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
6362  HasConstParam);
6363  if ((getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD)
6364  : isa<CXXConstructorDecl>(MD)) &&
6365  MD->isConstexpr() && !Constexpr &&
6367  Diag(MD->getLocStart(), diag::err_incorrect_defaulted_constexpr) << CSM;
6368  // FIXME: Explain why the special member can't be constexpr.
6369  HadError = true;
6370  }
6371 
6372  // and may have an explicit exception-specification only if it is compatible
6373  // with the exception-specification on the implicit declaration.
6374  if (Type->hasExceptionSpec()) {
6375  // Delay the check if this is the first declaration of the special member,
6376  // since we may not have parsed some necessary in-class initializers yet.
6377  if (First) {
6378  // If the exception specification needs to be instantiated, do so now,
6379  // before we clobber it with an EST_Unevaluated specification below.
6380  if (Type->getExceptionSpecType() == EST_Uninstantiated) {
6381  InstantiateExceptionSpec(MD->getLocStart(), MD);
6382  Type = MD->getType()->getAs<FunctionProtoType>();
6383  }
6384  DelayedDefaultedMemberExceptionSpecs.push_back(std::make_pair(MD, Type));
6385  } else
6386  CheckExplicitlyDefaultedMemberExceptionSpec(MD, Type);
6387  }
6388 
6389  // If a function is explicitly defaulted on its first declaration,
6390  if (First) {
6391  // -- it is implicitly considered to be constexpr if the implicit
6392  // definition would be,
6393  MD->setConstexpr(Constexpr);
6394 
6395  // -- it is implicitly considered to have the same exception-specification
6396  // as if it had been implicitly declared,
6399  EPI.ExceptionSpec.SourceDecl = MD;
6400  MD->setType(Context.getFunctionType(ReturnType,
6401  llvm::makeArrayRef(&ArgType,
6402  ExpectedParams),
6403  EPI));
6404  }
6405 
6406  if (ShouldDeleteSpecialMember(MD, CSM)) {
6407  if (First) {
6408  SetDeclDeleted(MD, MD->getLocation());
6409  } else {
6410  // C++11 [dcl.fct.def.default]p4:
6411  // [For a] user-provided explicitly-defaulted function [...] if such a
6412  // function is implicitly defined as deleted, the program is ill-formed.
6413  Diag(MD->getLocation(), diag::err_out_of_line_default_deletes) << CSM;
6414  ShouldDeleteSpecialMember(MD, CSM, nullptr, /*Diagnose*/true);
6415  HadError = true;
6416  }
6417  }
6418 
6419  if (HadError)
6420  MD->setInvalidDecl();
6421 }
6422 
6423 /// Check whether the exception specification provided for an
6424 /// explicitly-defaulted special member matches the exception specification
6425 /// that would have been generated for an implicit special member, per
6426 /// C++11 [dcl.fct.def.default]p2.
6428  CXXMethodDecl *MD, const FunctionProtoType *SpecifiedType) {
6429  // If the exception specification was explicitly specified but hadn't been
6430  // parsed when the method was defaulted, grab it now.
6431  if (SpecifiedType->getExceptionSpecType() == EST_Unparsed)
6432  SpecifiedType =
6434 
6435  // Compute the implicit exception specification.
6436  CallingConv CC = Context.getDefaultCallingConvention(/*IsVariadic=*/false,
6437  /*IsCXXMethod=*/true);
6439  auto IES = computeImplicitExceptionSpec(*this, MD->getLocation(), MD);
6440  EPI.ExceptionSpec = IES.getExceptionSpec();
6441  const FunctionProtoType *ImplicitType = cast<FunctionProtoType>(
6442  Context.getFunctionType(Context.VoidTy, None, EPI));
6443 
6444  // Ensure that it matches.
6445  CheckEquivalentExceptionSpec(
6446  PDiag(diag::err_incorrect_defaulted_exception_spec)
6447  << getSpecialMember(MD), PDiag(),
6448  ImplicitType, SourceLocation(),
6449  SpecifiedType, MD->getLocation());
6450 }
6451 
6453  decltype(DelayedExceptionSpecChecks) Checks;
6454  decltype(DelayedDefaultedMemberExceptionSpecs) Specs;
6455 
6456  std::swap(Checks, DelayedExceptionSpecChecks);
6457  std::swap(Specs, DelayedDefaultedMemberExceptionSpecs);
6458 
6459  // Perform any deferred checking of exception specifications for virtual
6460  // destructors.
6461  for (auto &Check : Checks)
6462  CheckOverridingFunctionExceptionSpec(Check.first, Check.second);
6463 
6464  // Check that any explicitly-defaulted methods have exception specifications
6465  // compatible with their implicit exception specifications.
6466  for (auto &Spec : Specs)
6467  CheckExplicitlyDefaultedMemberExceptionSpec(Spec.first, Spec.second);
6468 }
6469 
6470 namespace {
6471 /// CRTP base class for visiting operations performed by a special member
6472 /// function (or inherited constructor).
6473 template<typename Derived>
6474 struct SpecialMemberVisitor {
6475  Sema &S;
6476  CXXMethodDecl *MD;
6479 
6480  // Properties of the special member, computed for convenience.
6481  bool IsConstructor = false, IsAssignment = false, ConstArg = false;
6482 
6483  SpecialMemberVisitor(Sema &S, CXXMethodDecl *MD, Sema::CXXSpecialMember CSM,
6485  : S(S), MD(MD), CSM(CSM), ICI(ICI) {
6486  switch (CSM) {
6490  IsConstructor = true;
6491  break;
6494  IsAssignment = true;
6495  break;
6496  case Sema::CXXDestructor:
6497  break;
6498  case Sema::CXXInvalid:
6499  llvm_unreachable("invalid special member kind");
6500  }
6501 
6502  if (MD->getNumParams()) {
6503  if (const ReferenceType *RT =
6504  MD->getParamDecl(0)->getType()->getAs<ReferenceType>())
6505  ConstArg = RT->getPointeeType().isConstQualified();
6506  }
6507  }
6508 
6509  Derived &getDerived() { return static_cast<Derived&>(*this); }
6510 
6511  /// Is this a "move" special member?
6512  bool isMove() const {
6513  return CSM == Sema::CXXMoveConstructor || CSM == Sema::CXXMoveAssignment;
6514  }
6515 
6516  /// Look up the corresponding special member in the given class.
6518  unsigned Quals, bool IsMutable) {
6519  return lookupCallFromSpecialMember(S, Class, CSM, Quals,
6520  ConstArg && !IsMutable);
6521  }
6522 
6523  /// Look up the constructor for the specified base class to see if it's
6524  /// overridden due to this being an inherited constructor.
6525  Sema::SpecialMemberOverloadResult lookupInheritedCtor(CXXRecordDecl *Class) {
6526  if (!ICI)
6527  return {};
6528  assert(CSM == Sema::CXXDefaultConstructor);
6529  auto *BaseCtor =
6530  cast<CXXConstructorDecl>(MD)->getInheritedConstructor().getConstructor();
6531  if (auto *MD = ICI->findConstructorForBase(Class, BaseCtor).first)
6532  return MD;
6533  return {};
6534  }
6535 
6536  /// A base or member subobject.
6537  typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
6538 
6539  /// Get the location to use for a subobject in diagnostics.
6540  static SourceLocation getSubobjectLoc(Subobject Subobj) {
6541  // FIXME: For an indirect virtual base, the direct base leading to
6542  // the indirect virtual base would be a more useful choice.
6543  if (auto *B = Subobj.dyn_cast<CXXBaseSpecifier*>())
6544  return B->getBaseTypeLoc();
6545  else
6546  return Subobj.get<FieldDecl*>()->getLocation();
6547  }
6548 
6549  enum BasesToVisit {
6550  /// Visit all non-virtual (direct) bases.
6551  VisitNonVirtualBases,
6552  /// Visit all direct bases, virtual or not.
6553  VisitDirectBases,
6554  /// Visit all non-virtual bases, and all virtual bases if the class
6555  /// is not abstract.
6556  VisitPotentiallyConstructedBases,
6557  /// Visit all direct or virtual bases.
6558  VisitAllBases
6559  };
6560 
6561  // Visit the bases and members of the class.
6562  bool visit(BasesToVisit Bases) {
6563  CXXRecordDecl *RD = MD->getParent();
6564 
6565  if (Bases == VisitPotentiallyConstructedBases)
6566  Bases = RD->isAbstract() ? VisitNonVirtualBases : VisitAllBases;
6567 
6568  for (auto &B : RD->bases())
6569  if ((Bases == VisitDirectBases || !B.isVirtual()) &&
6570  getDerived().visitBase(&B))
6571  return true;
6572 
6573  if (Bases == VisitAllBases)
6574  for (auto &B : RD->vbases())
6575  if (getDerived().visitBase(&B))
6576  return true;
6577 
6578  for (auto *F : RD->fields())
6579  if (!F->isInvalidDecl() && !F->isUnnamedBitfield() &&
6580  getDerived().visitField(F))
6581  return true;
6582 
6583  return false;
6584  }
6585 };
6586 }
6587 
6588 namespace {
6589 struct SpecialMemberDeletionInfo
6590  : SpecialMemberVisitor<SpecialMemberDeletionInfo> {
6591  bool Diagnose;
6592 
6593  SourceLocation Loc;
6594 
6595  bool AllFieldsAreConst;
6596 
6597  SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD,
6599  Sema::InheritedConstructorInfo *ICI, bool Diagnose)
6600  : SpecialMemberVisitor(S, MD, CSM, ICI), Diagnose(Diagnose),
6601  Loc(MD->getLocation()), AllFieldsAreConst(true) {}
6602 
6603  bool inUnion() const { return MD->getParent()->isUnion(); }
6604 
6605  Sema::CXXSpecialMember getEffectiveCSM() {
6606  return ICI ? Sema::CXXInvalid : CSM;
6607  }
6608 
6609  bool visitBase(CXXBaseSpecifier *Base) { return shouldDeleteForBase(Base); }
6610  bool visitField(FieldDecl *Field) { return shouldDeleteForField(Field); }
6611 
6612  bool shouldDeleteForBase(CXXBaseSpecifier *Base);
6613  bool shouldDeleteForField(FieldDecl *FD);
6614  bool shouldDeleteForAllConstMembers();
6615 
6616  bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
6617  unsigned Quals);
6618  bool shouldDeleteForSubobjectCall(Subobject Subobj,
6620  bool IsDtorCallInCtor);
6621 
6622  bool isAccessible(Subobject Subobj, CXXMethodDecl *D);
6623 };
6624 }
6625 
6626 /// Is the given special member inaccessible when used on the given
6627 /// sub-object.
6628 bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
6629  CXXMethodDecl *target) {
6630  /// If we're operating on a base class, the object type is the
6631  /// type of this special member.
6632  QualType objectTy;
6633  AccessSpecifier access = target->getAccess();
6634  if (CXXBaseSpecifier *base = Subobj.dyn_cast<CXXBaseSpecifier*>()) {
6635  objectTy = S.Context.getTypeDeclType(MD->getParent());
6636  access = CXXRecordDecl::MergeAccess(base->getAccessSpecifier(), access);
6637 
6638  // If we're operating on a field, the object type is the type of the field.
6639  } else {
6640  objectTy = S.Context.getTypeDeclType(target->getParent());
6641  }
6642 
6643  return S.isSpecialMemberAccessibleForDeletion(target, access, objectTy);
6644 }
6645 
6646 /// Check whether we should delete a special member due to the implicit
6647 /// definition containing a call to a special member of a subobject.
6648 bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
6649  Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR,
6650  bool IsDtorCallInCtor) {
6651  CXXMethodDecl *Decl = SMOR.getMethod();
6652  FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
6653 
6654  int DiagKind = -1;
6655 
6657  DiagKind = !Decl ? 0 : 1;
6659  DiagKind = 2;
6660  else if (!isAccessible(Subobj, Decl))
6661  DiagKind = 3;
6662  else if (!IsDtorCallInCtor && Field && Field->getParent()->isUnion() &&
6663  !Decl->isTrivial()) {
6664  // A member of a union must have a trivial corresponding special member.
6665  // As a weird special case, a destructor call from a union's constructor
6666  // must be accessible and non-deleted, but need not be trivial. Such a
6667  // destructor is never actually called, but is semantically checked as
6668  // if it were.
6669  DiagKind = 4;
6670  }
6671 
6672  if (DiagKind == -1)
6673  return false;
6674 
6675  if (Diagnose) {
6676  if (Field) {
6677  S.Diag(Field->getLocation(),
6678  diag::note_deleted_special_member_class_subobject)
6679  << getEffectiveCSM() << MD->getParent() << /*IsField*/true
6680  << Field << DiagKind << IsDtorCallInCtor;
6681  } else {
6682  CXXBaseSpecifier *Base = Subobj.get<CXXBaseSpecifier*>();
6683  S.Diag(Base->getLocStart(),
6684  diag::note_deleted_special_member_class_subobject)
6685  << getEffectiveCSM() << MD->getParent() << /*IsField*/false
6686  << Base->getType() << DiagKind << IsDtorCallInCtor;
6687  }
6688 
6689  if (DiagKind == 1)
6690  S.NoteDeletedFunction(Decl);
6691  // FIXME: Explain inaccessibility if DiagKind == 3.
6692  }
6693 
6694  return true;
6695 }
6696 
6697 /// Check whether we should delete a special member function due to having a
6698 /// direct or virtual base class or non-static data member of class type M.
6699 bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
6700  CXXRecordDecl *Class, Subobject Subobj, unsigned Quals) {
6701  FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
6702  bool IsMutable = Field && Field->isMutable();
6703 
6704  // C++11 [class.ctor]p5:
6705  // -- any direct or virtual base class, or non-static data member with no
6706  // brace-or-equal-initializer, has class type M (or array thereof) and
6707  // either M has no default constructor or overload resolution as applied
6708  // to M's default constructor results in an ambiguity or in a function
6709  // that is deleted or inaccessible
6710  // C++11 [class.copy]p11, C++11 [class.copy]p23:
6711  // -- a direct or virtual base class B that cannot be copied/moved because
6712  // overload resolution, as applied to B's corresponding special member,
6713  // results in an ambiguity or a function that is deleted or inaccessible
6714  // from the defaulted special member
6715  // C++11 [class.dtor]p5:
6716  // -- any direct or virtual base class [...] has a type with a destructor
6717  // that is deleted or inaccessible
6718  if (!(CSM == Sema::CXXDefaultConstructor &&
6719  Field && Field->hasInClassInitializer()) &&
6720  shouldDeleteForSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable),
6721  false))
6722  return true;
6723 
6724  // C++11 [class.ctor]p5, C++11 [class.copy]p11:
6725  // -- any direct or virtual base class or non-static data member has a
6726  // type with a destructor that is deleted or inaccessible
6727  if (IsConstructor) {
6730  false, false, false, false, false);
6731  if (shouldDeleteForSubobjectCall(Subobj, SMOR, true))
6732  return true;
6733  }
6734 
6735  return false;
6736 }
6737 
6738 /// Check whether we should delete a special member function due to the class
6739 /// having a particular direct or virtual base class.
6740 bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
6741  CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
6742  // If program is correct, BaseClass cannot be null, but if it is, the error
6743  // must be reported elsewhere.
6744  if (!BaseClass)
6745  return false;
6746  // If we have an inheriting constructor, check whether we're calling an
6747  // inherited constructor instead of a default constructor.
6748  Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
6749  if (auto *BaseCtor = SMOR.getMethod()) {
6750  // Note that we do not check access along this path; other than that,
6751  // this is the same as shouldDeleteForSubobjectCall(Base, BaseCtor, false);
6752  // FIXME: Check that the base has a usable destructor! Sink this into
6753  // shouldDeleteForClassSubobject.
6754  if (BaseCtor->isDeleted() && Diagnose) {
6755  S.Diag(Base->getLocStart(),
6756  diag::note_deleted_special_member_class_subobject)
6757  << getEffectiveCSM() << MD->getParent() << /*IsField*/false
6758  << Base->getType() << /*Deleted*/1 << /*IsDtorCallInCtor*/false;
6759  S.NoteDeletedFunction(BaseCtor);
6760  }
6761  return BaseCtor->isDeleted();
6762  }
6763  return shouldDeleteForClassSubobject(BaseClass, Base, 0);
6764 }
6765 
6766 /// Check whether we should delete a special member function due to the class
6767 /// having a particular non-static data member.
6768 bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) {
6769  QualType FieldType = S.Context.getBaseElementType(FD->getType());
6770  CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl();
6771 
6772  if (CSM == Sema::CXXDefaultConstructor) {
6773  // For a default constructor, all references must be initialized in-class
6774  // and, if a union, it must have a non-const member.
6775  if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) {
6776  if (Diagnose)
6777  S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
6778  << !!ICI << MD->getParent() << FD << FieldType << /*Reference*/0;
6779  return true;
6780  }
6781  // C++11 [class.ctor]p5: any non-variant non-static data member of
6782  // const-qualified type (or array thereof) with no
6783  // brace-or-equal-initializer does not have a user-provided default
6784  // constructor.
6785  if (!inUnion() && FieldType.isConstQualified() &&
6786  !FD->hasInClassInitializer() &&
6787  (!FieldRecord || !FieldRecord->hasUserProvidedDefaultConstructor())) {
6788  if (Diagnose)
6789  S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
6790  << !!ICI << MD->getParent() << FD << FD->getType() << /*Const*/1;
6791  return true;
6792  }
6793 
6794  if (inUnion() && !FieldType.isConstQualified())
6795  AllFieldsAreConst = false;
6796  } else if (CSM == Sema::CXXCopyConstructor) {
6797  // For a copy constructor, data members must not be of rvalue reference
6798  // type.
6799  if (FieldType->isRValueReferenceType()) {
6800  if (Diagnose)
6801  S.Diag(FD->getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
6802  << MD->getParent() << FD << FieldType;
6803  return true;
6804  }
6805  } else if (IsAssignment) {
6806  // For an assignment operator, data members must not be of reference type.
6807  if (FieldType->isReferenceType()) {
6808  if (Diagnose)
6809  S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
6810  << isMove() << MD->getParent() << FD << FieldType << /*Reference*/0;
6811  return true;
6812  }
6813  if (!FieldRecord && FieldType.isConstQualified()) {
6814  // C++11 [class.copy]p23:
6815  // -- a non-static data member of const non-class type (or array thereof)
6816  if (Diagnose)
6817  S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
6818  << isMove() << MD->getParent() << FD << FD->getType() << /*Const*/1;
6819  return true;
6820  }
6821  }
6822 
6823  if (FieldRecord) {
6824  // Some additional restrictions exist on the variant members.
6825  if (!inUnion() && FieldRecord->isUnion() &&
6826  FieldRecord->isAnonymousStructOrUnion()) {
6827  bool AllVariantFieldsAreConst = true;
6828 
6829  // FIXME: Handle anonymous unions declared within anonymous unions.
6830  for (auto *UI : FieldRecord->fields()) {
6831  QualType UnionFieldType = S.Context.getBaseElementType(UI->getType());
6832 
6833  if (!UnionFieldType.isConstQualified())
6834  AllVariantFieldsAreConst = false;
6835 
6836  CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl();
6837  if (UnionFieldRecord &&
6838  shouldDeleteForClassSubobject(UnionFieldRecord, UI,
6839  UnionFieldType.getCVRQualifiers()))
6840  return true;
6841  }
6842 
6843  // At least one member in each anonymous union must be non-const
6844  if (CSM == Sema::CXXDefaultConstructor && AllVariantFieldsAreConst &&
6845  !FieldRecord->field_empty()) {
6846  if (Diagnose)
6847  S.Diag(FieldRecord->getLocation(),
6848  diag::note_deleted_default_ctor_all_const)
6849  << !!ICI << MD->getParent() << /*anonymous union*/1;
6850  return true;
6851  }
6852 
6853  // Don't check the implicit member of the anonymous union type.
6854  // This is technically non-conformant, but sanity demands it.
6855  return false;
6856  }
6857 
6858  if (shouldDeleteForClassSubobject(FieldRecord, FD,
6859  FieldType.getCVRQualifiers()))
6860  return true;
6861  }
6862 
6863  return false;
6864 }
6865 
6866 /// C++11 [class.ctor] p5:
6867 /// A defaulted default constructor for a class X is defined as deleted if
6868 /// X is a union and all of its variant members are of const-qualified type.
6869 bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
6870  // This is a silly definition, because it gives an empty union a deleted
6871  // default constructor. Don't do that.
6872  if (CSM == Sema::CXXDefaultConstructor && inUnion() && AllFieldsAreConst) {
6873  bool AnyFields = false;
6874  for (auto *F : MD->getParent()->fields())
6875  if ((AnyFields = !F->isUnnamedBitfield()))
6876  break;
6877  if (!AnyFields)
6878  return false;
6879  if (Diagnose)
6880  S.Diag(MD->getParent()->getLocation(),
6881  diag::note_deleted_default_ctor_all_const)
6882  << !!ICI << MD->getParent() << /*not anonymous union*/0;
6883  return true;
6884  }
6885  return false;
6886 }
6887 
6888 /// Determine whether a defaulted special member function should be defined as
6889 /// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11,
6890 /// C++11 [class.copy]p23, and C++11 [class.dtor]p5.
6893  bool Diagnose) {
6894  if (MD->isInvalidDecl())
6895  return false;
6896  CXXRecordDecl *RD = MD->getParent();
6897  assert(!RD->isDependentType() && "do deletion after instantiation");
6898  if (!LangOpts.CPlusPlus11 || RD->isInvalidDecl())
6899  return false;
6900 
6901  // C++11 [expr.lambda.prim]p19:
6902  // The closure type associated with a lambda-expression has a
6903  // deleted (8.4.3) default constructor and a deleted copy
6904  // assignment operator.
6905  if (RD->isLambda() &&
6906  (CSM == CXXDefaultConstructor || CSM == CXXCopyAssignment)) {
6907  if (Diagnose)
6908  Diag(RD->getLocation(), diag::note_lambda_decl);
6909  return true;
6910  }
6911 
6912  // For an anonymous struct or union, the copy and assignment special members
6913  // will never be used, so skip the check. For an anonymous union declared at
6914  // namespace scope, the constructor and destructor are used.
6915  if (CSM != CXXDefaultConstructor && CSM != CXXDestructor &&
6917  return false;
6918 
6919  // C++11 [class.copy]p7, p18:
6920  // If the class definition declares a move constructor or move assignment
6921  // operator, an implicitly declared copy constructor or copy assignment
6922  // operator is defined as deleted.
6923  if (MD->isImplicit() &&
6924  (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment)) {
6925  CXXMethodDecl *UserDeclaredMove = nullptr;
6926 
6927  // In Microsoft mode up to MSVC 2013, a user-declared move only causes the
6928  // deletion of the corresponding copy operation, not both copy operations.
6929  // MSVC 2015 has adopted the standards conforming behavior.
6930  bool DeletesOnlyMatchingCopy =
6931  getLangOpts().MSVCCompat &&
6932  !getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015);
6933 
6934  if (RD->hasUserDeclaredMoveConstructor() &&
6935  (!DeletesOnlyMatchingCopy || CSM == CXXCopyConstructor)) {
6936  if (!Diagnose) return true;
6937 
6938  // Find any user-declared move constructor.
6939  for (auto *I : RD->ctors()) {
6940  if (I->isMoveConstructor()) {
6941  UserDeclaredMove = I;
6942  break;
6943  }
6944  }
6945  assert(UserDeclaredMove);
6946  } else if (RD->hasUserDeclaredMoveAssignment() &&
6947  (!DeletesOnlyMatchingCopy || CSM == CXXCopyAssignment)) {
6948  if (!Diagnose) return true;
6949 
6950  // Find any user-declared move assignment operator.
6951  for (auto *I : RD->methods()) {
6952  if (I->isMoveAssignmentOperator()) {
6953  UserDeclaredMove = I;
6954  break;
6955  }
6956  }
6957  assert(UserDeclaredMove);
6958  }
6959 
6960  if (UserDeclaredMove) {
6961  Diag(UserDeclaredMove->getLocation(),
6962  diag::note_deleted_copy_user_declared_move)
6963  << (CSM == CXXCopyAssignment) << RD
6964  << UserDeclaredMove->isMoveAssignmentOperator();
6965  return true;
6966  }
6967  }
6968 
6969  // Do access control from the special member function
6970  ContextRAII MethodContext(*this, MD);
6971 
6972  // C++11 [class.dtor]p5:
6973  // -- for a virtual destructor, lookup of the non-array deallocation function
6974  // results in an ambiguity or in a function that is deleted or inaccessible
6975  if (CSM == CXXDestructor && MD->isVirtual()) {
6976  FunctionDecl *OperatorDelete = nullptr;
6977  DeclarationName Name =
6978  Context.DeclarationNames.getCXXOperatorName(OO_Delete);
6979  if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name,
6980  OperatorDelete, /*Diagnose*/false)) {
6981  if (Diagnose)
6982  Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete);
6983  return true;
6984  }
6985  }
6986 
6987  SpecialMemberDeletionInfo SMI(*this, MD, CSM, ICI, Diagnose);
6988 
6989  // Per DR1611, do not consider virtual bases of constructors of abstract
6990  // classes, since we are not going to construct them.
6991  // Per DR1658, do not consider virtual bases of destructors of abstract
6992  // classes either.
6993  // Per DR2180, for assignment operators we only assign (and thus only
6994  // consider) direct bases.
6995  if (SMI.visit(SMI.IsAssignment ? SMI.VisitDirectBases
6996  : SMI.VisitPotentiallyConstructedBases))
6997  return true;
6998 
6999  if (SMI.shouldDeleteForAllConstMembers())
7000  return true;
7001 
7002  if (getLangOpts().CUDA) {
7003  // We should delete the special member in CUDA mode if target inference
7004  // failed.
7005  return inferCUDATargetForImplicitSpecialMember(RD, CSM, MD, SMI.ConstArg,
7006  Diagnose);
7007  }
7008 
7009  return false;
7010 }
7011 
7012 /// Perform lookup for a special member of the specified kind, and determine
7013 /// whether it is trivial. If the triviality can be determined without the
7014 /// lookup, skip it. This is intended for use when determining whether a
7015 /// special member of a containing object is trivial, and thus does not ever
7016 /// perform overload resolution for default constructors.
7017 ///
7018 /// If \p Selected is not \c NULL, \c *Selected will be filled in with the
7019 /// member that was most likely to be intended to be trivial, if any.
7021  Sema::CXXSpecialMember CSM, unsigned Quals,
7022  bool ConstRHS, CXXMethodDecl **Selected) {
7023  if (Selected)
7024  *Selected = nullptr;
7025 
7026  switch (CSM) {
7027  case Sema::CXXInvalid:
7028  llvm_unreachable("not a special member");
7029 
7031  // C++11 [class.ctor]p5:
7032  // A default constructor is trivial if:
7033  // - all the [direct subobjects] have trivial default constructors
7034  //
7035  // Note, no overload resolution is performed in this case.
7036  if (RD->hasTrivialDefaultConstructor())
7037  return true;
7038 
7039  if (Selected) {
7040  // If there's a default constructor which could have been trivial, dig it
7041  // out. Otherwise, if there's any user-provided default constructor, point
7042  // to that as an example of why there's not a trivial one.
7043  CXXConstructorDecl *DefCtor = nullptr;
7046  for (auto *CI : RD->ctors()) {
7047  if (!CI->isDefaultConstructor())
7048  continue;
7049  DefCtor = CI;
7050  if (!DefCtor->isUserProvided())
7051  break;
7052  }
7053 
7054  *Selected = DefCtor;
7055  }
7056 
7057  return false;
7058 
7059  case Sema::CXXDestructor:
7060  // C++11 [class.dtor]p5:
7061  // A destructor is trivial if:
7062  // - all the direct [subobjects] have trivial destructors
7063  if (RD->hasTrivialDestructor())
7064  return true;
7065 
7066  if (Selected) {
7067  if (RD->needsImplicitDestructor())
7069  *Selected = RD->getDestructor();
7070  }
7071 
7072  return false;
7073 
7075  // C++11 [class.copy]p12:
7076  // A copy constructor is trivial if:
7077  // - the constructor selected to copy each direct [subobject] is trivial
7078  if (RD->hasTrivialCopyConstructor()) {
7079  if (Quals == Qualifiers::Const)
7080  // We must either select the trivial copy constructor or reach an
7081  // ambiguity; no need to actually perform overload resolution.
7082  return true;
7083  } else if (!Selected) {
7084  return false;
7085  }
7086  // In C++98, we are not supposed to perform overload resolution here, but we
7087  // treat that as a language defect, as suggested on cxx-abi-dev, to treat
7088  // cases like B as having a non-trivial copy constructor:
7089  // struct A { template<typename T> A(T&); };
7090  // struct B { mutable A a; };
7091  goto NeedOverloadResolution;
7092 
7094  // C++11 [class.copy]p25:
7095  // A copy assignment operator is trivial if:
7096  // - the assignment operator selected to copy each direct [subobject] is
7097  // trivial
7098  if (RD->hasTrivialCopyAssignment()) {
7099  if (Quals == Qualifiers::Const)
7100  return true;
7101  } else if (!Selected) {
7102  return false;
7103  }
7104  // In C++98, we are not supposed to perform overload resolution here, but we
7105  // treat that as a language defect.
7106  goto NeedOverloadResolution;
7107 
7110  NeedOverloadResolution:
7112  lookupCallFromSpecialMember(S, RD, CSM, Quals, ConstRHS);
7113 
7114  // The standard doesn't describe how to behave if the lookup is ambiguous.
7115  // We treat it as not making the member non-trivial, just like the standard
7116  // mandates for the default constructor. This should rarely matter, because
7117  // the member will also be deleted.
7119  return true;
7120 
7121  if (!SMOR.getMethod()) {
7122  assert(SMOR.getKind() ==
7124  return false;
7125  }
7126 
7127  // We deliberately don't check if we found a deleted special member. We're
7128  // not supposed to!
7129  if (Selected)
7130  *Selected = SMOR.getMethod();
7131  return SMOR.getMethod()->isTrivial();
7132  }
7133 
7134  llvm_unreachable("unknown special method kind");
7135 }
7136 
7138  for (auto *CI : RD->ctors())
7139  if (!CI->isImplicit())
7140  return CI;
7141 
7142  // Look for constructor templates.
7143  typedef CXXRecordDecl::specific_decl_iterator<FunctionTemplateDecl> tmpl_iter;
7144  for (tmpl_iter TI(RD->decls_begin()), TE(RD->decls_end()); TI != TE; ++TI) {
7145  if (CXXConstructorDecl *CD =
7146  dyn_cast<CXXConstructorDecl>(TI->getTemplatedDecl()))
7147  return CD;
7148  }
7149 
7150  return nullptr;
7151 }
7152 
7153 /// The kind of subobject we are checking for triviality. The values of this
7154 /// enumeration are used in diagnostics.
7156  /// The subobject is a base class.
7158  /// The subobject is a non-static data member.
7160  /// The object is actually the complete object.
7162 };
7163 
7164 /// Check whether the special member selected for a given type would be trivial.
7166  QualType SubType, bool ConstRHS,
7169  bool Diagnose) {
7170  CXXRecordDecl *SubRD = SubType->getAsCXXRecordDecl();
7171  if (!SubRD)
7172  return true;
7173 
7174  CXXMethodDecl *Selected;
7175  if (findTrivialSpecialMember(S, SubRD, CSM, SubType.getCVRQualifiers(),
7176  ConstRHS, Diagnose ? &Selected : nullptr))
7177  return true;
7178 
7179  if (Diagnose) {
7180  if (ConstRHS)
7181  SubType.addConst();
7182 
7183  if (!Selected && CSM == Sema::CXXDefaultConstructor) {
7184  S.Diag(SubobjLoc, diag::note_nontrivial_no_def_ctor)
7185  << Kind << SubType.getUnqualifiedType();
7186  if (CXXConstructorDecl *CD = findUserDeclaredCtor(SubRD))
7187  S.Diag(CD->getLocation(), diag::note_user_declared_ctor);
7188  } else if (!Selected)
7189  S.Diag(SubobjLoc, diag::note_nontrivial_no_copy)
7190  << Kind << SubType.getUnqualifiedType() << CSM << SubType;
7191  else if (Selected->isUserProvided()) {
7192  if (Kind == TSK_CompleteObject)
7193  S.Diag(Selected->getLocation(), diag::note_nontrivial_user_provided)
7194  << Kind << SubType.getUnqualifiedType() << CSM;
7195  else {
7196  S.Diag(SubobjLoc, diag::note_nontrivial_user_provided)
7197  << Kind << SubType.getUnqualifiedType() << CSM;
7198  S.Diag(Selected->getLocation(), diag::note_declared_at);
7199  }
7200  } else {
7201  if (Kind != TSK_CompleteObject)
7202  S.Diag(SubobjLoc, diag::note_nontrivial_subobject)
7203  << Kind << SubType.getUnqualifiedType() << CSM;
7204 
7205  // Explain why the defaulted or deleted special member isn't trivial.
7206  S.SpecialMemberIsTrivial(Selected, CSM, Diagnose);
7207  }
7208  }
7209 
7210  return false;
7211 }
7212 
7213 /// Check whether the members of a class type allow a special member to be
7214 /// trivial.
7217  bool ConstArg, bool Diagnose) {
7218  for (const auto *FI : RD->fields()) {
7219  if (FI->isInvalidDecl() || FI->isUnnamedBitfield())
7220  continue;
7221 
7222  QualType FieldType = S.Context.getBaseElementType(FI->getType());
7223 
7224  // Pretend anonymous struct or union members are members of this class.
7225  if (FI->isAnonymousStructOrUnion()) {
7226  if (!checkTrivialClassMembers(S, FieldType->getAsCXXRecordDecl(),
7227  CSM, ConstArg, Diagnose))
7228  return false;
7229  continue;
7230  }
7231 
7232  // C++11 [class.ctor]p5:
7233  // A default constructor is trivial if [...]
7234  // -- no non-static data member of its class has a
7235  // brace-or-equal-initializer
7236  if (CSM == Sema::CXXDefaultConstructor && FI->hasInClassInitializer()) {
7237  if (Diagnose)
7238  S.Diag(FI->getLocation(), diag::note_nontrivial_in_class_init) << FI;
7239  return false;
7240  }
7241 
7242  // Objective C ARC 4.3.5:
7243  // [...] nontrivally ownership-qualified types are [...] not trivially
7244  // default constructible, copy constructible, move constructible, copy
7245  // assignable, move assignable, or destructible [...]
7246  if (FieldType.hasNonTrivialObjCLifetime()) {
7247  if (Diagnose)
7248  S.Diag(FI->getLocation(), diag::note_nontrivial_objc_ownership)
7249  << RD << FieldType.getObjCLifetime();
7250  return false;
7251  }
7252 
7253  bool ConstRHS = ConstArg && !FI->isMutable();
7254  if (!checkTrivialSubobjectCall(S, FI->getLocation(), FieldType, ConstRHS,
7255  CSM, TSK_Field, Diagnose))
7256  return false;
7257  }
7258 
7259  return true;
7260 }
7261 
7262 /// Diagnose why the specified class does not have a trivial special member of
7263 /// the given kind.
7265  QualType Ty = Context.getRecordType(RD);
7266 
7267  bool ConstArg = (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment);
7268  checkTrivialSubobjectCall(*this, RD->getLocation(), Ty, ConstArg, CSM,
7269  TSK_CompleteObject, /*Diagnose*/true);
7270 }
7271 
7272 /// Determine whether a defaulted or deleted special member function is trivial,
7273 /// as specified in C++11 [class.ctor]p5, C++11 [class.copy]p12,
7274 /// C++11 [class.copy]p25, and C++11 [class.dtor]p5.
7276  bool Diagnose) {
7277  assert(!MD->isUserProvided() && CSM != CXXInvalid && "not special enough");
7278 
7279  CXXRecordDecl *RD = MD->getParent();
7280 
7281  bool ConstArg = false;
7282 
7283  // C++11 [class.copy]p12, p25: [DR1593]
7284  // A [special member] is trivial if [...] its parameter-type-list is
7285  // equivalent to the parameter-type-list of an implicit declaration [...]
7286  switch (CSM) {
7287  case CXXDefaultConstructor:
7288  case CXXDestructor:
7289  // Trivial default constructors and destructors cannot have parameters.
7290  break;
7291 
7292  case CXXCopyConstructor:
7293  case CXXCopyAssignment: {
7294  // Trivial copy operations always have const, non-volatile parameter types.
7295  ConstArg = true;
7296  const ParmVarDecl *Param0 = MD->getParamDecl(0);
7297  const ReferenceType *RT = Param0->getType()->getAs<ReferenceType>();
7298  if (!RT || RT->getPointeeType().getCVRQualifiers() != Qualifiers::Const) {
7299  if (Diagnose)
7300  Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
7301  << Param0->getSourceRange() << Param0->getType()
7302  << Context.getLValueReferenceType(
7303  Context.getRecordType(RD).withConst());
7304  return false;
7305  }
7306  break;
7307  }
7308 
7309  case CXXMoveConstructor:
7310  case CXXMoveAssignment: {
7311  // Trivial move operations always have non-cv-qualified parameters.
7312  const ParmVarDecl *Param0 = MD->getParamDecl(0);
7313  const RValueReferenceType *RT =
7314  Param0->getType()->getAs<RValueReferenceType>();
7315  if (!RT || RT->getPointeeType().getCVRQualifiers()) {
7316  if (Diagnose)
7317  Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
7318  << Param0->getSourceRange() << Param0->getType()
7319  << Context.getRValueReferenceType(Context.getRecordType(RD));
7320  return false;
7321  }
7322  break;
7323  }
7324 
7325  case CXXInvalid:
7326  llvm_unreachable("not a special member");
7327  }
7328 
7329  if (MD->getMinRequiredArguments() < MD->getNumParams()) {
7330  if (Diagnose)
7331  Diag(MD->getParamDecl(MD->getMinRequiredArguments())->getLocation(),
7332  diag::note_nontrivial_default_arg)
7334  return false;
7335  }
7336  if (MD->isVariadic()) {
7337  if (Diagnose)
7338  Diag(MD->getLocation(), diag::note_nontrivial_variadic);
7339  return false;
7340  }
7341 
7342  // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
7343  // A copy/move [constructor or assignment operator] is trivial if
7344  // -- the [member] selected to copy/move each direct base class subobject
7345  // is trivial
7346  //
7347  // C++11 [class.copy]p12, C++11 [class.copy]p25:
7348  // A [default constructor or destructor] is trivial if
7349  // -- all the direct base classes have trivial [default constructors or
7350  // destructors]
7351  for (const auto &BI : RD->bases())
7352  if (!checkTrivialSubobjectCall(*this, BI.getLocStart(), BI.getType(),
7353  ConstArg, CSM, TSK_BaseClass, Diagnose))
7354  return false;
7355 
7356  // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
7357  // A copy/move [constructor or assignment operator] for a class X is
7358  // trivial if
7359  // -- for each non-static data member of X that is of class type (or array
7360  // thereof), the constructor selected to copy/move that member is
7361  // trivial
7362  //
7363  // C++11 [class.copy]p12, C++11 [class.copy]p25:
7364  // A [default constructor or destructor] is trivial if
7365  // -- for all of the non-static data members of its class that are of class
7366  // type (or array thereof), each such class has a trivial [default
7367  // constructor or destructor]
7368  if (!checkTrivialClassMembers(*this, RD, CSM, ConstArg, Diagnose))
7369  return false;
7370 
7371  // C++11 [class.dtor]p5:
7372  // A destructor is trivial if [...]
7373  // -- the destructor is not virtual
7374  if (CSM == CXXDestructor && MD->isVirtual()) {
7375  if (Diagnose)
7376  Diag(MD->getLocation(), diag::note_nontrivial_virtual_dtor) << RD;
7377  return false;
7378  }
7379 
7380  // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
7381  // A [special member] for class X is trivial if [...]
7382  // -- class X has no virtual functions and no virtual base classes
7383  if (CSM != CXXDestructor && MD->getParent()->isDynamicClass()) {
7384  if (!Diagnose)
7385  return false;
7386 
7387  if (RD->getNumVBases()) {
7388  // Check for virtual bases. We already know that the corresponding
7389  // member in all bases is trivial, so vbases must all be direct.
7390  CXXBaseSpecifier &BS = *RD->vbases_begin();
7391  assert(BS.isVirtual());
7392  Diag(BS.getLocStart(), diag::note_nontrivial_has_virtual) << RD << 1;
7393  return false;
7394  }
7395 
7396  // Must have a virtual method.
7397  for (const auto *MI : RD->methods()) {
7398  if (MI->isVirtual()) {
7399  SourceLocation MLoc = MI->getLocStart();
7400  Diag(MLoc, diag::note_nontrivial_has_virtual) << RD << 0;
7401  return false;
7402  }
7403  }
7404 
7405  llvm_unreachable("dynamic class with no vbases and no virtual functions");
7406  }
7407 
7408  // Looks like it's trivial!
7409  return true;
7410 }
7411 
7412 namespace {
7413 struct FindHiddenVirtualMethod {
7414  Sema *S;
7415  CXXMethodDecl *Method;
7416  llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
7417  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
7418 
7419 private:
7420  /// Check whether any most overriden method from MD in Methods
7421  static bool CheckMostOverridenMethods(
7422  const CXXMethodDecl *MD,
7423  const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
7424  if (MD->size_overridden_methods() == 0)
7425  return Methods.count(MD->getCanonicalDecl());
7426  for (const CXXMethodDecl *O : MD->overridden_methods())
7427  if (CheckMostOverridenMethods(O, Methods))
7428  return true;
7429  return false;
7430  }
7431 
7432 public:
7433  /// Member lookup function that determines whether a given C++
7434  /// method overloads virtual methods in a base class without overriding any,
7435  /// to be used with CXXRecordDecl::lookupInBases().
7436  bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
7437  RecordDecl *BaseRecord =
7438  Specifier->getType()->getAs<RecordType>()->getDecl();
7439 
7440  DeclarationName Name = Method->getDeclName();
7441  assert(Name.getNameKind() == DeclarationName::Identifier);
7442 
7443  bool foundSameNameMethod = false;
7444  SmallVector<CXXMethodDecl *, 8> overloadedMethods;
7445  for (Path.Decls = BaseRecord->lookup(Name); !Path.Decls.empty();
7446  Path.Decls = Path.Decls.slice(1)) {
7447  NamedDecl *D = Path.Decls.front();
7448  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
7449  MD = MD->getCanonicalDecl();
7450  foundSameNameMethod = true;
7451  // Interested only in hidden virtual methods.
7452  if (!MD->isVirtual())
7453  continue;
7454  // If the method we are checking overrides a method from its base
7455  // don't warn about the other overloaded methods. Clang deviates from
7456  // GCC by only diagnosing overloads of inherited virtual functions that
7457  // do not override any other virtual functions in the base. GCC's
7458  // -Woverloaded-virtual diagnoses any derived function hiding a virtual
7459  // function from a base class. These cases may be better served by a
7460  // warning (not specific to virtual functions) on call sites when the
7461  // call would select a different function from the base class, were it
7462  // visible.
7463  // See FIXME in test/SemaCXX/warn-overload-virtual.cpp for an example.
7464  if (!S->IsOverload(Method, MD, false))
7465  return true;
7466  // Collect the overload only if its hidden.
7467  if (!CheckMostOverridenMethods(MD, OverridenAndUsingBaseMethods))
7468  overloadedMethods.push_back(MD);
7469  }
7470  }
7471 
7472  if (foundSameNameMethod)
7473  OverloadedMethods.append(overloadedMethods.begin(),
7474  overloadedMethods.end());
7475  return foundSameNameMethod;
7476  }
7477 };
7478 } // end anonymous namespace
7479 
7480 /// \brief Add the most overriden methods from MD to Methods
7482  llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
7483  if (MD->size_overridden_methods() == 0)
7484  Methods.insert(MD->getCanonicalDecl());
7485  else
7486  for (const CXXMethodDecl *O : MD->overridden_methods())
7487  AddMostOverridenMethods(O, Methods);
7488 }
7489 
7490 /// \brief Check if a method overloads virtual methods in a base class without
7491 /// overriding any.
7493  SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
7494  if (!MD->getDeclName().isIdentifier())
7495  return;
7496 
7497  CXXBasePaths Paths(/*FindAmbiguities=*/true, // true to look in all bases.
7498  /*bool RecordPaths=*/false,
7499  /*bool DetectVirtual=*/false);
7500  FindHiddenVirtualMethod FHVM;
7501  FHVM.Method = MD;
7502  FHVM.S = this;
7503 
7504  // Keep the base methods that were overriden or introduced in the subclass
7505  // by 'using' in a set. A base method not in this set is hidden.
7506  CXXRecordDecl *DC = MD->getParent();
7508  for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
7509  NamedDecl *ND = *I;
7510  if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*I))
7511  ND = shad->getTargetDecl();
7512  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND))
7513  AddMostOverridenMethods(MD, FHVM.OverridenAndUsingBaseMethods);
7514  }
7515 
7516  if (DC->lookupInBases(FHVM, Paths))
7517  OverloadedMethods = FHVM.OverloadedMethods;
7518 }
7519 
7521  SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
7522  for (unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) {
7523  CXXMethodDecl *overloadedMD = OverloadedMethods[i];
7524  PartialDiagnostic PD = PDiag(
7525  diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
7526  HandleFunctionTypeMismatch(PD, MD->getType(), overloadedMD->getType());
7527  Diag(overloadedMD->getLocation(), PD);
7528  }
7529 }
7530 
7531 /// \brief Diagnose methods which overload virtual methods in a base class
7532 /// without overriding any.
7534  if (MD->isInvalidDecl())
7535  return;
7536 
7537  if (Diags.isIgnored(diag::warn_overloaded_virtual, MD->getLocation()))
7538  return;
7539 
7540  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
7541  FindHiddenVirtualMethods(MD, OverloadedMethods);
7542  if (!OverloadedMethods.empty()) {
7543  Diag(MD->getLocation(), diag::warn_overloaded_virtual)
7544  << MD << (OverloadedMethods.size() > 1);
7545 
7546  NoteHiddenVirtualMethods(MD, OverloadedMethods);
7547  }
7548 }
7549 
7551  Decl *TagDecl,
7552  SourceLocation LBrac,
7553  SourceLocation RBrac,
7554  AttributeList *AttrList) {
7555  if (!TagDecl)
7556  return;
7557 
7558  AdjustDeclIfTemplate(TagDecl);
7559 
7560  for (const AttributeList* l = AttrList; l; l = l->getNext()) {
7561  if (l->getKind() != AttributeList::AT_Visibility)
7562  continue;
7563  l->setInvalid();
7564  Diag(l->getLoc(), diag::warn_attribute_after_definition_ignored) <<
7565  l->getName();
7566  }
7567 
7568  ActOnFields(S, RLoc, TagDecl, llvm::makeArrayRef(
7569  // strict aliasing violation!
7570  reinterpret_cast<Decl**>(FieldCollector->getCurFields()),
7571  FieldCollector->getCurNumFields()), LBrac, RBrac, AttrList);
7572 
7573  CheckCompletedCXXClass(dyn_cast_or_null<CXXRecordDecl>(TagDecl));
7574 }
7575 
7576 /// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
7577 /// special functions, such as the default constructor, copy
7578 /// constructor, or destructor, to the given C++ class (C++
7579 /// [special]p1). This routine can only be executed just before the
7580 /// definition of the class is complete.
7582  if (ClassDecl->needsImplicitDefaultConstructor()) {
7584 
7585  if (ClassDecl->hasInheritedConstructor())
7586  DeclareImplicitDefaultConstructor(ClassDecl);
7587  }
7588 
7589  if (ClassDecl->needsImplicitCopyConstructor()) {
7591 
7592  // If the properties or semantics of the copy constructor couldn't be
7593  // determined while the class was being declared, force a declaration
7594  // of it now.
7595  if (ClassDecl->needsOverloadResolutionForCopyConstructor() ||
7596  ClassDecl->hasInheritedConstructor())
7597  DeclareImplicitCopyConstructor(ClassDecl);
7598  // For the MS ABI we need to know whether the copy ctor is deleted. A
7599  // prerequisite for deleting the implicit copy ctor is that the class has a
7600  // move ctor or move assignment that is either user-declared or whose
7601  // semantics are inherited from a subobject. FIXME: We should provide a more
7602  // direct way for CodeGen to ask whether the constructor was deleted.
7603  else if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
7604  (ClassDecl->hasUserDeclaredMoveConstructor() ||
7606  ClassDecl->hasUserDeclaredMoveAssignment() ||
7608  DeclareImplicitCopyConstructor(ClassDecl);
7609  }
7610 
7611  if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveConstructor()) {
7613 
7614  if (ClassDecl->needsOverloadResolutionForMoveConstructor() ||
7615  ClassDecl->hasInheritedConstructor())
7616  DeclareImplicitMoveConstructor(ClassDecl);
7617  }
7618 
7619  if (ClassDecl->needsImplicitCopyAssignment()) {
7621 
7622  // If we have a dynamic class, then the copy assignment operator may be
7623  // virtual, so we have to declare it immediately. This ensures that, e.g.,
7624  // it shows up in the right place in the vtable and that we diagnose
7625  // problems with the implicit exception specification.
7626  if (ClassDecl->isDynamicClass() ||
7628  ClassDecl->hasInheritedAssignment())
7629  DeclareImplicitCopyAssignment(ClassDecl);
7630  }
7631 
7632  if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveAssignment()) {
7634 
7635  // Likewise for the move assignment operator.
7636  if (ClassDecl->isDynamicClass() ||
7638  ClassDecl->hasInheritedAssignment())
7639  DeclareImplicitMoveAssignment(ClassDecl);
7640  }
7641 
7642  if (ClassDecl->needsImplicitDestructor()) {
7644 
7645  // If we have a dynamic class, then the destructor may be virtual, so we
7646  // have to declare the destructor immediately. This ensures that, e.g., it
7647  // shows up in the right place in the vtable and that we diagnose problems
7648  // with the implicit exception specification.
7649  if (ClassDecl->isDynamicClass() ||
7651  DeclareImplicitDestructor(ClassDecl);
7652  }
7653 }
7654 
7656  if (!D)
7657  return 0;
7658 
7659  // The order of template parameters is not important here. All names
7660  // get added to the same scope.
7662 
7663  if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
7664  D = TD->getTemplatedDecl();
7665 
7666  if (auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
7667  ParameterLists.push_back(PSD->getTemplateParameters());
7668 
7669  if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
7670  for (unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
7671  ParameterLists.push_back(DD->getTemplateParameterList(i));
7672 
7673  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
7674  if (FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
7675  ParameterLists.push_back(FTD->getTemplateParameters());
7676  }
7677  }
7678 
7679  if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
7680  for (unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
7681  ParameterLists.push_back(TD->getTemplateParameterList(i));
7682 
7683  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD)) {
7685  ParameterLists.push_back(CTD->getTemplateParameters());
7686  }
7687  }
7688 
7689  unsigned Count = 0;
7690  for (TemplateParameterList *Params : ParameterLists) {
7691  if (Params->size() > 0)
7692  // Ignore explicit specializations; they don't contribute to the template
7693  // depth.
7694  ++Count;
7695  for (NamedDecl *Param : *Params) {
7696  if (Param->getDeclName()) {
7697  S->AddDecl(Param);
7698  IdResolver.AddDecl(Param);
7699  }
7700  }
7701  }
7702 
7703  return Count;
7704 }
7705 
7707  if (!RecordD) return;
7708  AdjustDeclIfTemplate(RecordD);
7709  CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD);
7710  PushDeclContext(S, Record);
7711 }
7712 
7714  if (!RecordD) return;
7715  PopDeclContext();
7716 }
7717 
7718 /// This is used to implement the constant expression evaluation part of the
7719 /// attribute enable_if extension. There is nothing in standard C++ which would
7720 /// require reentering parameters.
7722  if (!Param)
7723  return;
7724 
7725  S->AddDecl(Param);
7726  if (Param->getDeclName())
7727  IdResolver.AddDecl(Param);
7728 }
7729 
7730 /// ActOnStartDelayedCXXMethodDeclaration - We have completed
7731 /// parsing a top-level (non-nested) C++ class, and we are now
7732 /// parsing those parts of the given Method declaration that could
7733 /// not be parsed earlier (C++ [class.mem]p2), such as default
7734 /// arguments. This action should enter the scope of the given
7735 /// Method declaration as if we had just parsed the qualified method
7736 /// name. However, it should not bring the parameters into scope;
7737 /// that will be performed by ActOnDelayedCXXMethodParameter.
7739 }
7740 
7741 /// ActOnDelayedCXXMethodParameter - We've already started a delayed
7742 /// C++ method declaration. We're (re-)introducing the given
7743 /// function parameter into scope for use in parsing later parts of
7744 /// the method declaration. For example, we could see an
7745 /// ActOnParamDefaultArgument event for this parameter.
7747  if (!ParamD)
7748  return;
7749 
7750  ParmVarDecl *Param = cast<ParmVarDecl>(ParamD);
7751 
7752  // If this parameter has an unparsed default argument, clear it out
7753  // to make way for the parsed default argument.
7754  if (Param->hasUnparsedDefaultArg())
7755  Param->setDefaultArg(nullptr);
7756 
7757  S->AddDecl(Param);
7758  if (Param->getDeclName())
7759  IdResolver.AddDecl(Param);
7760 }
7761 
7762 /// ActOnFinishDelayedCXXMethodDeclaration - We have finished
7763 /// processing the delayed method declaration for Method. The method
7764 /// declaration is now considered finished. There may be a separate
7765 /// ActOnStartOfFunctionDef action later (not necessarily
7766 /// immediately!) for this method, if it was also defined inside the
7767 /// class body.
7769  if (!MethodD)
7770  return;
7771 
7772  AdjustDeclIfTemplate(MethodD);
7773 
7774  FunctionDecl *Method = cast<FunctionDecl>(MethodD);
7775 
7776  // Now that we have our default arguments, check the constructor
7777  // again. It could produce additional diagnostics or affect whether
7778  // the class has implicitly-declared destructors, among other
7779  // things.
7780  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
7781  CheckConstructor(Constructor);
7782 
7783  // Check the default arguments, which we may have added.
7784  if (!Method->isInvalidDecl())
7785  CheckCXXDefaultArguments(Method);
7786 }
7787 
7788 /// CheckConstructorDeclarator - Called by ActOnDeclarator to check
7789 /// the well-formedness of the constructor declarator @p D with type @p
7790 /// R. If there are any errors in the declarator, this routine will
7791 /// emit diagnostics and set the invalid bit to true. In any case, the type
7792 /// will be updated to reflect a well-formed type for the constructor and
7793 /// returned.
7795  StorageClass &SC) {
7796  bool isVirtual = D.getDeclSpec().isVirtualSpecified();
7797 
7798  // C++ [class.ctor]p3:
7799  // A constructor shall not be virtual (10.3) or static (9.4). A
7800  // constructor can be invoked for a const, volatile or const
7801  // volatile object. A constructor shall not be declared const,
7802  // volatile, or const volatile (9.3.2).
7803  if (isVirtual) {
7804  if (!D.isInvalidType())
7805  Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
7806  << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
7807  << SourceRange(D.getIdentifierLoc());
7808  D.setInvalidType();
7809  }
7810  if (SC == SC_Static) {
7811  if (!D.isInvalidType())
7812  Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
7813  << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
7814  << SourceRange(D.getIdentifierLoc());
7815  D.setInvalidType();
7816  SC = SC_None;
7817  }
7818 
7819  if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
7820  diagnoseIgnoredQualifiers(
7821  diag::err_constructor_return_type, TypeQuals, SourceLocation(),
7825  D.setInvalidType();
7826  }
7827 
7829  if (FTI.TypeQuals != 0) {
7830  if (FTI.TypeQuals & Qualifiers::Const)
7831  Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
7832  << "const" << SourceRange(D.getIdentifierLoc());
7833  if (FTI.TypeQuals & Qualifiers::Volatile)
7834  Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
7835  << "volatile" << SourceRange(D.getIdentifierLoc());
7836  if (FTI.TypeQuals & Qualifiers::Restrict)
7837  Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
7838  << "restrict" << SourceRange(D.getIdentifierLoc());
7839  D.setInvalidType();
7840  }
7841 
7842  // C++0x [class.ctor]p4:
7843  // A constructor shall not be declared with a ref-qualifier.
7844  if (FTI.hasRefQualifier()) {
7845  Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_constructor)
7848  D.setInvalidType();
7849  }
7850 
7851  // Rebuild the function type "R" without any type qualifiers (in
7852  // case any of the errors above fired) and with "void" as the
7853  // return type, since constructors don't have return types.
7854  const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
7855  if (Proto->getReturnType() == Context.VoidTy && !D.isInvalidType())
7856  return R;
7857 
7859  EPI.TypeQuals = 0;
7860  EPI.RefQualifier = RQ_None;
7861 
7862  return Context.getFunctionType(Context.VoidTy, Proto->getParamTypes(), EPI);
7863 }
7864 
7865 /// CheckConstructor - Checks a fully-formed constructor for
7866 /// well-formedness, issuing any diagnostics required. Returns true if
7867 /// the constructor declarator is invalid.
7869  CXXRecordDecl *ClassDecl
7870  = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
7871  if (!ClassDecl)
7872  return Constructor->setInvalidDecl();
7873 
7874  // C++ [class.copy]p3:
7875  // A declaration of a constructor for a class X is ill-formed if
7876  // its first parameter is of type (optionally cv-qualified) X and
7877  // either there are no other parameters or else all other
7878  // parameters have default arguments.
7879  if (!Constructor->isInvalidDecl() &&
7880  ((Constructor->getNumParams() == 1) ||
7881  (Constructor->getNumParams() > 1 &&
7882  Constructor->getParamDecl(1)->hasDefaultArg())) &&
7883  Constructor->getTemplateSpecializationKind()
7885  QualType ParamType = Constructor->getParamDecl(0)->getType();
7886  QualType ClassTy = Context.getTagDeclType(ClassDecl);
7887  if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
7888  SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
7889  const char *ConstRef
7890  = Constructor->getParamDecl(0)->getIdentifier() ? "const &"
7891  : " const &";
7892  Diag(ParamLoc, diag::err_constructor_byvalue_arg)
7893  << FixItHint::CreateInsertion(ParamLoc, ConstRef);
7894 
7895  // FIXME: Rather that making the constructor invalid, we should endeavor
7896  // to fix the type.
7897  Constructor->setInvalidDecl();
7898  }
7899  }
7900 }
7901 
7902 /// CheckDestructor - Checks a fully-formed destructor definition for
7903 /// well-formedness, issuing any diagnostics required. Returns true
7904 /// on error.
7906  CXXRecordDecl *RD = Destructor->getParent();
7907 
7908  if (!Destructor->getOperatorDelete() && Destructor->isVirtual()) {
7909  SourceLocation Loc;
7910 
7911  if (!Destructor->isImplicit())
7912  Loc = Destructor->getLocation();
7913  else
7914  Loc = RD->getLocation();
7915 
7916  // If we have a virtual destructor, look up the deallocation function
7917  if (FunctionDecl *OperatorDelete =
7918  FindDeallocationFunctionForDestructor(Loc, RD)) {
7919  Expr *ThisArg = nullptr;
7920 
7921  // If the notional 'delete this' expression requires a non-trivial
7922  // conversion from 'this' to the type of a destroying operator delete's
7923  // first parameter, perform that conversion now.
7924  if (OperatorDelete->isDestroyingOperatorDelete()) {
7925  QualType ParamType = OperatorDelete->getParamDecl(0)->getType();
7926  if (!declaresSameEntity(ParamType->getAsCXXRecordDecl(), RD)) {
7927  // C++ [class.dtor]p13:
7928  // ... as if for the expression 'delete this' appearing in a
7929  // non-virtual destructor of the destructor's class.
7930  ContextRAII SwitchContext(*this, Destructor);
7931  ExprResult This =
7932  ActOnCXXThis(OperatorDelete->getParamDecl(0)->getLocation());
7933  assert(!This.isInvalid() && "couldn't form 'this' expr in dtor?");
7934  This = PerformImplicitConversion(This.get(), ParamType, AA_Passing);
7935  if (This.isInvalid()) {
7936  // FIXME: Register this as a context note so that it comes out
7937  // in the right order.
7938  Diag(Loc, diag::note_implicit_delete_this_in_destructor_here);
7939  return true;
7940  }
7941  ThisArg = This.get();
7942  }
7943  }
7944 
7945  MarkFunctionReferenced(Loc, OperatorDelete);
7946  Destructor->setOperatorDelete(OperatorDelete, ThisArg);
7947  }
7948  }
7949 
7950  return false;
7951 }
7952 
7953 /// CheckDestructorDeclarator - Called by ActOnDeclarator to check
7954 /// the well-formednes of the destructor declarator @p D with type @p
7955 /// R. If there are any errors in the declarator, this routine will
7956 /// emit diagnostics and set the declarator to invalid. Even if this happens,
7957 /// will be updated to reflect a well-formed type for the destructor and
7958 /// returned.
7960  StorageClass& SC) {
7961  // C++ [class.dtor]p1:
7962  // [...] A typedef-name that names a class is a class-name
7963  // (7.1.3); however, a typedef-name that names a class shall not
7964  // be used as the identifier in the declarator for a destructor
7965  // declaration.
7966  QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
7967  if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
7968  Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
7969  << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
7970  else if (const TemplateSpecializationType *TST =
7971  DeclaratorType->getAs<TemplateSpecializationType>())
7972  if (TST->isTypeAlias())
7973  Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
7974  << DeclaratorType << 1;
7975 
7976  // C++ [class.dtor]p2:
7977  // A destructor is used to destroy objects of its class type. A
7978  // destructor takes no parameters, and no return type can be
7979  // specified for it (not even void). The address of a destructor
7980  // shall not be taken. A destructor shall not be static. A
7981  // destructor can be invoked for a const, volatile or const
7982  // volatile object. A destructor shall not be declared const,
7983  // volatile or const volatile (9.3.2).
7984  if (SC == SC_Static) {
7985  if (!D.isInvalidType())
7986  Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
7987  << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
7990 
7991  SC = SC_None;
7992  }
7993  if (!D.isInvalidType()) {
7994  // Destructors don't have return types, but the parser will
7995  // happily parse something like:
7996  //
7997  // class X {
7998  // float ~X();
7999  // };
8000  //
8001  // The return type will be eliminated later.
8002  if (D.getDeclSpec().hasTypeSpecifier())
8003  Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
8005  << SourceRange(D.getIdentifierLoc());
8006  else if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
8007  diagnoseIgnoredQualifiers(diag::err_destructor_return_type, TypeQuals,
8008  SourceLocation(),
8013  D.setInvalidType();
8014  }
8015  }
8016 
8018  if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
8019  if (FTI.TypeQuals & Qualifiers::Const)
8020  Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
8021  << "const" << SourceRange(D.getIdentifierLoc());
8022  if (FTI.TypeQuals & Qualifiers::Volatile)
8023  Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
8024  << "volatile" << SourceRange(D.getIdentifierLoc());
8025  if (FTI.TypeQuals & Qualifiers::Restrict)
8026  Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
8027  << "restrict" << SourceRange(D.getIdentifierLoc());
8028  D.setInvalidType();
8029  }
8030 
8031  // C++0x [class.dtor]p2:
8032  // A destructor shall not be declared with a ref-qualifier.
8033  if (FTI.hasRefQualifier()) {
8034  Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_destructor)
8037  D.setInvalidType();
8038  }
8039 
8040  // Make sure we don't have any parameters.
8041  if (FTIHasNonVoidParameters(FTI)) {
8042  Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
8043 
8044  // Delete the parameters.
8045  FTI.freeParams();
8046  D.setInvalidType();
8047  }
8048 
8049  // Make sure the destructor isn't variadic.
8050  if (FTI.isVariadic) {
8051  Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
8052  D.setInvalidType();
8053  }
8054 
8055  // Rebuild the function type "R" without any type qualifiers or
8056  // parameters (in case any of the errors above fired) and with
8057  // "void" as the return type, since destructors don't have return
8058  // types.
8059  if (!D.isInvalidType())
8060  return R;
8061 
8062  const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
8064  EPI.Variadic = false;
8065  EPI.TypeQuals = 0;
8066  EPI.RefQualifier = RQ_None;
8067  return Context.getFunctionType(Context.VoidTy, None, EPI);
8068 }
8069 
8070 static void extendLeft(SourceRange &R, SourceRange Before) {
8071  if (Before.isInvalid())
8072  return;
8073  R.setBegin(Before.getBegin());
8074  if (R.getEnd().isInvalid())
8075  R.setEnd(Before.getEnd());
8076 }
8077 
8079  if (After.isInvalid())
8080  return;
8081  if (R.getBegin().isInvalid())
8082  R.setBegin(After.getBegin());
8083  R.setEnd(After.getEnd());
8084 }
8085 
8086 /// CheckConversionDeclarator - Called by ActOnDeclarator to check the
8087 /// well-formednes of the conversion function declarator @p D with
8088 /// type @p R. If there are any errors in the declarator, this routine
8089 /// will emit diagnostics and return true. Otherwise, it will return
8090 /// false. Either way, the type @p R will be updated to reflect a
8091 /// well-formed type for the conversion operator.
8093  StorageClass& SC) {
8094  // C++ [class.conv.fct]p1:
8095  // Neither parameter types nor return type can be specified. The
8096  // type of a conversion function (8.3.5) is "function taking no
8097  // parameter returning conversion-type-id."
8098  if (SC == SC_Static) {
8099  if (!D.isInvalidType())
8100  Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
8102  << D.getName().getSourceRange();
8103  D.setInvalidType();
8104  SC = SC_None;
8105  }
8106 
8107  TypeSourceInfo *ConvTSI = nullptr;
8108  QualType ConvType =
8109  GetTypeFromParser(D.getName().ConversionFunctionId, &ConvTSI);
8110 
8111  if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
8112  // Conversion functions don't have return types, but the parser will
8113  // happily parse something like:
8114  //
8115  // class X {
8116  // float operator bool();
8117  // };
8118  //
8119  // The return type will be changed later anyway.
8120  Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
8122  << SourceRange(D.getIdentifierLoc());
8123  D.setInvalidType();
8124  }
8125 
8126  const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
8127 
8128  // Make sure we don't have any parameters.
8129  if (Proto->getNumParams() > 0) {
8130  Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
8131 
8132  // Delete the parameters.
8134  D.setInvalidType();
8135  } else if (Proto->isVariadic()) {
8136  Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
8137  D.setInvalidType();
8138  }
8139 
8140  // Diagnose "&operator bool()" and other such nonsense. This
8141  // is actually a gcc extension which we don't support.
8142  if (Proto->getReturnType() != ConvType) {
8143  bool NeedsTypedef = false;
8144  SourceRange Before, After;
8145 
8146  // Walk the chunks and extract information on them for our diagnostic.
8147  bool PastFunctionChunk = false;
8148  for (auto &Chunk : D.type_objects()) {
8149  switch (Chunk.Kind) {
8151  if (!PastFunctionChunk) {
8152  if (Chunk.Fun.HasTrailingReturnType) {
8153  TypeSourceInfo *TRT = nullptr;
8154  GetTypeFromParser(Chunk.Fun.getTrailingReturnType(), &TRT);
8155  if (TRT) extendRight(After, TRT->getTypeLoc().getSourceRange());
8156  }
8157  PastFunctionChunk = true;
8158  break;
8159  }
8160  LLVM_FALLTHROUGH;
8162  NeedsTypedef = true;
8163  extendRight(After, Chunk.getSourceRange());
8164  break;
8165 
8170  case DeclaratorChunk::Pipe:
8171  extendLeft(Before, Chunk.getSourceRange());
8172  break;
8173 
8175  extendLeft(Before, Chunk.Loc);
8176  extendRight(After, Chunk.EndLoc);
8177  break;
8178  }
8179  }
8180 
8181  SourceLocation Loc = Before.isValid() ? Before.getBegin() :
8182  After.isValid() ? After.getBegin() :
8183  D.getIdentifierLoc();
8184  auto &&DB = Diag(Loc, diag::err_conv_function_with_complex_decl);
8185  DB << Before << After;
8186 
8187  if (!NeedsTypedef) {
8188  DB << /*don't need a typedef*/0;
8189 
8190  // If we can provide a correct fix-it hint, do so.
8191  if (After.isInvalid() && ConvTSI) {
8192  SourceLocation InsertLoc =
8193  getLocForEndOfToken(ConvTSI->getTypeLoc().getLocEnd());
8194  DB << FixItHint::CreateInsertion(InsertLoc, " ")
8196  InsertLoc, CharSourceRange::getTokenRange(Before))
8197  << FixItHint::CreateRemoval(Before);
8198  }
8199  } else if (!Proto->getReturnType()->isDependentType()) {
8200  DB << /*typedef*/1 << Proto->getReturnType();
8201  } else if (getLangOpts().CPlusPlus11) {
8202  DB << /*alias template*/2 << Proto->getReturnType();
8203  } else {
8204  DB << /*might not be fixable*/3;
8205  }
8206 
8207  // Recover by incorporating the other type chunks into the result type.
8208  // Note, this does *not* change the name of the function. This is compatible
8209  // with the GCC extension:
8210  // struct S { &operator int(); } s;
8211  // int &r = s.operator int(); // ok in GCC
8212  // S::operator int&() {} // error in GCC, function name is 'operator int'.
8213  ConvType = Proto->getReturnType();
8214  }
8215 
8216  // C++ [class.conv.fct]p4:
8217  // The conversion-type-id shall not represent a function type nor
8218  // an array type.
8219  if (ConvType->isArrayType()) {
8220  Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
8221  ConvType = Context.getPointerType(ConvType);
8222  D.setInvalidType();
8223  } else if (ConvType->isFunctionType()) {
8224  Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
8225  ConvType = Context.getPointerType(ConvType);
8226  D.setInvalidType();
8227  }
8228 
8229  // Rebuild the function type "R" without any parameters (in case any
8230  // of the errors above fired) and with the conversion type as the
8231  // return type.
8232  if (D.isInvalidType())
8233  R = Context.getFunctionType(ConvType, None, Proto->getExtProtoInfo());
8234 
8235  // C++0x explicit conversion operators.
8236  if (D.getDeclSpec().isExplicitSpecified())
8238  getLangOpts().CPlusPlus11 ?
8239  diag::warn_cxx98_compat_explicit_conversion_functions :
8240  diag::ext_explicit_conversion_functions)
8242 }
8243 
8244 /// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
8245 /// the declaration of the given C++ conversion function. This routine
8246 /// is responsible for recording the conversion function in the C++
8247 /// class, if possible.
8249  assert(Conversion && "Expected to receive a conversion function declaration");
8250 
8251  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
8252 
8253  // Make sure we aren't redeclaring the conversion function.
8254  QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
8255 
8256  // C++ [class.conv.fct]p1:
8257  // [...] A conversion function is never used to convert a
8258  // (possibly cv-qualified) object to the (possibly cv-qualified)
8259  // same object type (or a reference to it), to a (possibly
8260  // cv-qualified) base class of that type (or a reference to it),
8261  // or to (possibly cv-qualified) void.
8262  // FIXME: Suppress this warning if the conversion function ends up being a
8263  // virtual function that overrides a virtual function in a base class.
8264  QualType ClassType
8265  = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
8266  if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
8267  ConvType = ConvTypeRef->getPointeeType();
8268  if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared &&
8270  /* Suppress diagnostics for instantiations. */;
8271  else if (ConvType->isRecordType()) {
8272  ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
8273  if (ConvType == ClassType)
8274  Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
8275  << ClassType;
8276  else if (IsDerivedFrom(Conversion->getLocation(), ClassType, ConvType))
8277  Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
8278  << ClassType << ConvType;
8279  } else if (ConvType->isVoidType()) {
8280  Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
8281  << ClassType << ConvType;
8282  }
8283 
8284  if (FunctionTemplateDecl *ConversionTemplate
8285  = Conversion->getDescribedFunctionTemplate())
8286  return ConversionTemplate;
8287 
8288  return Conversion;
8289 }
8290 
8291 namespace {
8292 /// Utility class to accumulate and print a diagnostic listing the invalid
8293 /// specifier(s) on a declaration.
8294 struct BadSpecifierDiagnoser {
8295  BadSpecifierDiagnoser(Sema &S, SourceLocation Loc, unsigned DiagID)
8296  : S(S), Diagnostic(S.Diag(Loc, DiagID)) {}
8297  ~BadSpecifierDiagnoser() {
8298  Diagnostic << Specifiers;
8299  }
8300 
8301  template<typename T> void check(SourceLocation SpecLoc, T Spec) {
8302  return check(SpecLoc, DeclSpec::getSpecifierName(Spec));
8303  }
8304  void check(SourceLocation SpecLoc, DeclSpec::TST Spec) {
8305  return check(SpecLoc,
8307  }
8308  void check(SourceLocation SpecLoc, const char *Spec) {
8309  if (SpecLoc.isInvalid()) return;
8310  Diagnostic << SourceRange(SpecLoc, SpecLoc);
8311  if (!Specifiers.empty()) Specifiers += " ";
8312  Specifiers += Spec;
8313  }
8314 
8315  Sema &S;
8317  std::string Specifiers;
8318 };
8319 }
8320 
8321 /// Check the validity of a declarator that we parsed for a deduction-guide.
8322 /// These aren't actually declarators in the grammar, so we need to check that
8323 /// the user didn't specify any pieces that are not part of the deduction-guide
8324 /// grammar.
8326  StorageClass &SC) {
8327  TemplateName GuidedTemplate = D.getName().TemplateName.get().get();
8328  TemplateDecl *GuidedTemplateDecl = GuidedTemplate.getAsTemplateDecl();
8329  assert(GuidedTemplateDecl && "missing template decl for deduction guide");
8330 
8331  // C++ [temp.deduct.guide]p3:
8332  // A deduction-gide shall be declared in the same scope as the
8333  // corresponding class template.
8334  if (!CurContext->getRedeclContext()->Equals(
8335  GuidedTemplateDecl->getDeclContext()->getRedeclContext())) {
8336  Diag(D.getIdentifierLoc(), diag::err_deduction_guide_wrong_scope)
8337  << GuidedTemplateDecl;
8338  Diag(GuidedTemplateDecl->getLocation(), diag::note_template_decl_here);
8339  }
8340 
8341  auto &DS = D.getMutableDeclSpec();
8342  // We leave 'friend' and 'virtual' to be rejected in the normal way.
8343  if (DS.hasTypeSpecifier() || DS.getTypeQualifiers() ||
8344  DS.getStorageClassSpecLoc().isValid() || DS.isInlineSpecified() ||
8345  DS.isNoreturnSpecified() || DS.isConstexprSpecified()) {
8346  BadSpecifierDiagnoser Diagnoser(
8347  *this, D.getIdentifierLoc(),
8348  diag::err_deduction_guide_invalid_specifier);
8349 
8350  Diagnoser.check(DS.getStorageClassSpecLoc(), DS.getStorageClassSpec());
8352  SC = SC_None;
8353 
8354  // 'explicit' is permitted.
8355  Diagnoser.check(DS.getInlineSpecLoc(), "inline");
8356  Diagnoser.check(DS.getNoreturnSpecLoc(), "_Noreturn");
8357  Diagnoser.check(DS.getConstexprSpecLoc(), "constexpr");
8358  DS.ClearConstexprSpec();
8359 
8360  Diagnoser.check(DS.getConstSpecLoc(), "const");
8361  Diagnoser.check(DS.getRestrictSpecLoc(), "__restrict");
8362  Diagnoser.check(DS.getVolatileSpecLoc(), "volatile");
8363  Diagnoser.check(DS.getAtomicSpecLoc(), "_Atomic");
8364  Diagnoser.check(DS.getUnalignedSpecLoc(), "__unaligned");
8365  DS.ClearTypeQualifiers();
8366 
8367  Diagnoser.check(DS.getTypeSpecComplexLoc(), DS.getTypeSpecComplex());
8368  Diagnoser.check(DS.getTypeSpecSignLoc(), DS.getTypeSpecSign());
8369  Diagnoser.check(DS.getTypeSpecWidthLoc(), DS.getTypeSpecWidth());
8370  Diagnoser.check(DS.getTypeSpecTypeLoc(), DS.getTypeSpecType());
8371  DS.ClearTypeSpecType();
8372  }
8373 
8374  if (D.isInvalidType())
8375  return;
8376 
8377  // Check the declarator is simple enough.
8378  bool FoundFunction = false;
8379  for (const DeclaratorChunk &Chunk : llvm::reverse(D.type_objects())) {
8380  if (Chunk.Kind == DeclaratorChunk::Paren)
8381  continue;
8382  if (Chunk.Kind != DeclaratorChunk::Function || FoundFunction) {
8384  diag::err_deduction_guide_with_complex_decl)
8385  << D.getSourceRange();
8386  break;
8387  }
8388  if (!Chunk.Fun.hasTrailingReturnType()) {
8389  Diag(D.getName().getLocStart(),
8390  diag::err_deduction_guide_no_trailing_return_type);
8391  break;
8392  }
8393 
8394  // Check that the return type is written as a specialization of
8395  // the template specified as the deduction-guide's name.
8396  ParsedType TrailingReturnType = Chunk.Fun.getTrailingReturnType();
8397  TypeSourceInfo *TSI = nullptr;
8398  QualType RetTy = GetTypeFromParser(TrailingReturnType, &TSI);
8399  assert(TSI && "deduction guide has valid type but invalid return type?");
8400  bool AcceptableReturnType = false;
8401  bool MightInstantiateToSpecialization = false;
8402  if (auto RetTST =
8404  TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
8405  bool TemplateMatches =
8406  Context.hasSameTemplateName(SpecifiedName, GuidedTemplate);
8407  if (SpecifiedName.getKind() == TemplateName::Template && TemplateMatches)
8408  AcceptableReturnType = true;
8409  else {
8410  // This could still instantiate to the right type, unless we know it
8411  // names the wrong class template.
8412  auto *TD = SpecifiedName.getAsTemplateDecl();
8413  MightInstantiateToSpecialization = !(TD && isa<ClassTemplateDecl>(TD) &&
8414  !TemplateMatches);
8415  }
8416  } else if (!RetTy.hasQualifiers() && RetTy->isDependentType()) {
8417  MightInstantiateToSpecialization = true;
8418  }
8419 
8420  if (!AcceptableReturnType) {
8421  Diag(TSI->getTypeLoc().getLocStart(),
8422  diag::err_deduction_guide_bad_trailing_return_type)
8423  << GuidedTemplate << TSI->getType() << MightInstantiateToSpecialization
8424  << TSI->getTypeLoc().getSourceRange();
8425  }
8426 
8427  // Keep going to check that we don't have any inner declarator pieces (we
8428  // could still have a function returning a pointer to a function).
8429  FoundFunction = true;
8430  }
8431 
8432  if (D.isFunctionDefinition())
8433  Diag(D.getIdentifierLoc(), diag::err_deduction_guide_defines_function);
8434 }
8435 
8436 //===----------------------------------------------------------------------===//
8437 // Namespace Handling
8438 //===----------------------------------------------------------------------===//
8439 
8440 /// \brief Diagnose a mismatch in 'inline' qualifiers when a namespace is
8441 /// reopened.
8443  SourceLocation Loc,
8444  IdentifierInfo *II, bool *IsInline,
8445  NamespaceDecl *PrevNS) {
8446  assert(*IsInline != PrevNS->isInline());
8447 
8448  // HACK: Work around a bug in libstdc++4.6's <atomic>, where
8449  // std::__atomic[0,1,2] are defined as non-inline namespaces, then reopened as
8450  // inline namespaces, with the intention of bringing names into namespace std.
8451  //
8452  // We support this just well enough to get that case working; this is not
8453  // sufficient to support reopening namespaces as inline in general.
8454  if (*IsInline && II && II->getName().startswith("__atomic") &&
8456  // Mark all prior declarations of the namespace as inline.
8457  for (NamespaceDecl *NS = PrevNS->getMostRecentDecl(); NS;
8458  NS = NS->getPreviousDecl())
8459  NS->setInline(*IsInline);
8460  // Patch up the lookup table for the containing namespace. This isn't really
8461  // correct, but it's good enough for this particular case.
8462  for (auto *I : PrevNS->decls())
8463  if (auto *ND = dyn_cast<NamedDecl>(I))
8464  PrevNS->getParent()->makeDeclVisibleInContext(ND);
8465  return;
8466  }
8467 
8468  if (PrevNS->isInline())
8469  // The user probably just forgot the 'inline', so suggest that it
8470  // be added back.
8471  S.Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
8472  << FixItHint::CreateInsertion(KeywordLoc, "inline ");
8473  else
8474  S.Diag(Loc, diag::err_inline_namespace_mismatch);
8475 
8476  S.Diag(PrevNS->getLocation(), diag::note_previous_definition);
8477  *IsInline = PrevNS->isInline();
8478 }
8479 
8480 /// ActOnStartNamespaceDef - This is called at the start of a namespace
8481 /// definition.
8483  SourceLocation InlineLoc,
8484  SourceLocation NamespaceLoc,
8485  SourceLocation IdentLoc,
8486  IdentifierInfo *II,
8487  SourceLocation LBrace,
8488  AttributeList *AttrList,
8489  UsingDirectiveDecl *&UD) {
8490  SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc;
8491  // For anonymous namespace, take the location of the left brace.
8492  SourceLocation Loc = II ? IdentLoc : LBrace;
8493  bool IsInline = InlineLoc.isValid();
8494  bool IsInvalid = false;
8495  bool IsStd = false;
8496  bool AddToKnown = false;
8497  Scope *DeclRegionScope = NamespcScope->getParent();
8498 
8499  NamespaceDecl *PrevNS = nullptr;
8500  if (II) {
8501  // C++ [namespace.def]p2:
8502  // The identifier in an original-namespace-definition shall not
8503  // have been previously defined in the declarative region in
8504  // which the original-namespace-definition appears. The
8505  // identifier in an original-namespace-definition is the name of
8506  // the namespace. Subsequently in that declarative region, it is
8507  // treated as an original-namespace-name.
8508  //
8509  // Since namespace names are unique in their scope, and we don't
8510  // look through using directives, just look for any ordinary names
8511  // as if by qualified name lookup.
8512  LookupResult R(*this, II, IdentLoc, LookupOrdinaryName,
8513  ForExternalRedeclaration);
8514  LookupQualifiedName(R, CurContext->getRedeclContext());
8515  NamedDecl *PrevDecl =
8516  R.isSingleResult() ? R.getRepresentativeDecl() : nullptr;
8517  PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
8518 
8519  if (PrevNS) {
8520  // This is an extended namespace definition.
8521  if (IsInline != PrevNS->isInline())
8522  DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, Loc, II,
8523  &IsInline, PrevNS);
8524  } else if (PrevDecl) {
8525  // This is an invalid name redefinition.
8526  Diag(Loc, diag::err_redefinition_different_kind)
8527  << II;
8528  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
8529  IsInvalid = true;
8530  // Continue on to push Namespc as current DeclContext and return it.
8531  } else if (II->isStr("std") &&
8532  CurContext->getRedeclContext()->isTranslationUnit()) {
8533  // This is the first "real" definition of the namespace "std", so update
8534  // our cache of the "std" namespace to point at this definition.
8535  PrevNS = getStdNamespace();
8536  IsStd = true;
8537  AddToKnown = !IsInline;
8538  } else {
8539  // We've seen this namespace for the first time.
8540  AddToKnown = !IsInline;
8541  }
8542  } else {
8543  // Anonymous namespaces.
8544 
8545  // Determine whether the parent already has an anonymous namespace.
8546  DeclContext *Parent = CurContext->getRedeclContext();
8547  if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
8548  PrevNS = TU->getAnonymousNamespace();
8549  } else {
8550  NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
8551  PrevNS = ND->getAnonymousNamespace();
8552  }
8553 
8554  if (PrevNS && IsInline != PrevNS->isInline())
8555  DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, NamespaceLoc, II,
8556  &IsInline, PrevNS);
8557  }
8558 
8559  NamespaceDecl *Namespc = NamespaceDecl::Create(Context, CurContext, IsInline,
8560  StartLoc, Loc, II, PrevNS);
8561  if (IsInvalid)
8562  Namespc->setInvalidDecl();
8563 
8564  ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
8565  AddPragmaAttributes(DeclRegionScope, Namespc);
8566 
8567  // FIXME: Should we be merging attributes?
8568  if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
8569  PushNamespaceVisibilityAttr(Attr, Loc);
8570 
8571  if (IsStd)
8572  StdNamespace = Namespc;
8573  if (AddToKnown)
8574  KnownNamespaces[Namespc] = false;
8575 
8576  if (II) {
8577  PushOnScopeChains(Namespc, DeclRegionScope);
8578  } else {
8579  // Link the anonymous namespace into its parent.
8580  DeclContext *Parent = CurContext->getRedeclContext();
8581  if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
8582  TU->setAnonymousNamespace(Namespc);
8583  } else {
8584  cast<NamespaceDecl>(Parent)->setAnonymousNamespace(Namespc);
8585  }
8586 
8587  CurContext->addDecl(Namespc);
8588 
8589  // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
8590  // behaves as if it were replaced by
8591  // namespace unique { /* empty body */ }
8592  // using namespace unique;
8593  // namespace unique { namespace-body }
8594  // where all occurrences of 'unique' in a translation unit are
8595  // replaced by the same identifier and this identifier differs
8596  // from all other identifiers in the entire program.
8597 
8598  // We just create the namespace with an empty name and then add an
8599  // implicit using declaration, just like the standard suggests.
8600  //
8601  // CodeGen enforces the "universally unique" aspect by giving all
8602  // declarations semantically contained within an anonymous
8603  // namespace internal linkage.
8604 
8605  if (!PrevNS) {
8606  UD = UsingDirectiveDecl::Create(Context, Parent,
8607  /* 'using' */ LBrace,
8608  /* 'namespace' */ SourceLocation(),
8609  /* qualifier */ NestedNameSpecifierLoc(),
8610  /* identifier */ SourceLocation(),
8611  Namespc,
8612  /* Ancestor */ Parent);
8613  UD->setImplicit();
8614  Parent->addDecl(UD);
8615  }
8616  }
8617 
8618  ActOnDocumentableDecl(Namespc);
8619 
8620  // Although we could have an invalid decl (i.e. the namespace name is a
8621  // redefinition), push it as current DeclContext and try to continue parsing.
8622  // FIXME: We should be able to push Namespc here, so that the each DeclContext
8623  // for the namespace has the declarations that showed up in that particular
8624  // namespace definition.
8625  PushDeclContext(NamespcScope, Namespc);
8626  return Namespc;
8627 }
8628 
8629 /// getNamespaceDecl - Returns the namespace a decl represents. If the decl
8630 /// is a namespace alias, returns the namespace it points to.
8632  if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
8633  return AD->getNamespace();
8634  return dyn_cast_or_null<NamespaceDecl>(D);
8635 }
8636 
8637 /// ActOnFinishNamespaceDef - This callback is called after a namespace is
8638 /// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
8640  NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
8641  assert(Namespc && "Invalid parameter, expected NamespaceDecl");
8642  Namespc->setRBraceLoc(RBrace);
8643  PopDeclContext();
8644  if (Namespc->hasAttr<VisibilityAttr>())
8645  PopPragmaVisibility(true, RBrace);
8646 }
8647 
8649  return cast_or_null<CXXRecordDecl>(
8650  StdBadAlloc.get(Context.getExternalSource()));
8651 }
8652 
8654  return cast_or_null<EnumDecl>(StdAlignValT.get(Context.getExternalSource()));
8655 }
8656 
8658  return cast_or_null<NamespaceDecl>(
8659  StdNamespace.get(Context.getExternalSource()));
8660 }
8661 
8663  if (!StdExperimentalNamespaceCache) {
8664  if (auto Std = getStdNamespace()) {
8665  LookupResult Result(*this, &PP.getIdentifierTable().get("experimental"),
8666  SourceLocation(), LookupNamespaceName);
8667  if (!LookupQualifiedName(Result, Std) ||
8668  !(StdExperimentalNamespaceCache =
8669  Result.getAsSingle<NamespaceDecl>()))
8670  Result.suppressDiagnostics();
8671  }
8672  }
8673  return StdExperimentalNamespaceCache;
8674 }
8675 
8676 /// \brief Retrieve the special "std" namespace, which may require us to
8677 /// implicitly define the namespace.
8679  if (!StdNamespace) {
8680  // The "std" namespace has not yet been defined, so build one implicitly.
8681  StdNamespace = NamespaceDecl::Create(Context,
8682  Context.getTranslationUnitDecl(),
8683  /*Inline=*/false,
8685  &PP.getIdentifierTable().get("std"),
8686  /*PrevDecl=*/nullptr);
8687  getStdNamespace()->setImplicit(true);
8688  }
8689 
8690  return getStdNamespace();
8691 }
8692 
8694  assert(getLangOpts().CPlusPlus &&
8695  "Looking for std::initializer_list outside of C++.");
8696 
8697  // We're looking for implicit instantiations of
8698  // template <typename E> class std::initializer_list.
8699 
8700  if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it.
8701  return false;
8702 
8703  ClassTemplateDecl *Template = nullptr;
8704  const TemplateArgument *Arguments = nullptr;
8705 
8706  if (const RecordType *RT = Ty->getAs<RecordType>()) {
8707 
8708  ClassTemplateSpecializationDecl *Specialization =
8709  dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
8710  if (!Specialization)
8711  return false;
8712 
8713  Template = Specialization->getSpecializedTemplate();
8714  Arguments = Specialization->getTemplateArgs().data();
8715  } else if (const TemplateSpecializationType *TST =
8717  Template = dyn_cast_or_null<ClassTemplateDecl>(
8718  TST->getTemplateName().getAsTemplateDecl());
8719  Arguments = TST->getArgs();
8720  }
8721  if (!Template)
8722  return false;
8723 
8724  if (!StdInitializerList) {
8725  // Haven't recognized std::initializer_list yet, maybe this is it.
8726  CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
8727  if (TemplateClass->getIdentifier() !=
8728  &PP.getIdentifierTable().get("initializer_list") ||
8729  !getStdNamespace()->InEnclosingNamespaceSetOf(
8730  TemplateClass->getDeclContext()))
8731  return false;
8732  // This is a template called std::initializer_list, but is it the right
8733  // template?
8734  TemplateParameterList *Params = Template->getTemplateParameters();
8735  if (Params->getMinRequiredArguments() != 1)
8736  return false;
8737  if (!isa<TemplateTypeParmDecl>(Params->getParam(0)))
8738  return false;
8739 
8740  // It's the right template.
8741  StdInitializerList = Template;
8742  }
8743 
8744  if (Template->getCanonicalDecl() != StdInitializerList->getCanonicalDecl())
8745  return false;
8746 
8747  // This is an instance of std::initializer_list. Find the argument type.
8748  if (Element)
8749  *Element = Arguments[0].getAsType();
8750  return true;
8751 }
8752 
8754  NamespaceDecl *Std = S.getStdNamespace();
8755  if (!Std) {
8756  S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
8757  return nullptr;
8758  }
8759 
8760  LookupResult Result(S, &S.PP.getIdentifierTable().get("initializer_list"),
8762  if (!S.LookupQualifiedName(Result, Std)) {
8763  S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
8764  return nullptr;
8765  }
8766  ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>();
8767  if (!Template) {
8768  Result.suppressDiagnostics();
8769  // We found something weird. Complain about the first thing we found.
8770  NamedDecl *Found = *Result.begin();
8771  S.Diag(Found->getLocation(), diag::err_malformed_std_initializer_list);
8772  return nullptr;
8773  }
8774 
8775  // We found some template called std::initializer_list. Now verify that it's
8776  // correct.
8777  TemplateParameterList *Params = Template->getTemplateParameters();
8778  if (Params->getMinRequiredArguments() != 1 ||
8779  !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
8780  S.Diag(Template->getLocation(), diag::err_malformed_std_initializer_list);
8781  return nullptr;
8782  }
8783 
8784  return Template;
8785 }
8786 
8788  if (!StdInitializerList) {
8789  StdInitializerList = LookupStdInitializerList(*this, Loc);
8790  if (!StdInitializerList)
8791  return QualType();
8792  }
8793 
8794  TemplateArgumentListInfo Args(Loc, Loc);
8796  Context.getTrivialTypeSourceInfo(Element,
8797  Loc)));
8798  return Context.getCanonicalType(
8799  CheckTemplateIdType(TemplateName(StdInitializerList), Loc, Args));
8800 }
8801 
8803  // C++ [dcl.init.list]p2:
8804  // A constructor is an initializer-list constructor if its first parameter
8805  // is of type std::initializer_list<E> or reference to possibly cv-qualified
8806  // std::initializer_list<E> for some type E, and either there are no other
8807  // parameters or else all other parameters have default arguments.
8808  if (Ctor->getNumParams() < 1 ||
8809  (Ctor->getNumParams() > 1 && !Ctor->getParamDecl(1)->hasDefaultArg()))
8810  return false;
8811 
8812  QualType ArgType = Ctor->getParamDecl(0)->getType();
8813  if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
8814  ArgType = RT->getPointeeType().getUnqualifiedType();
8815 
8816  return isStdInitializerList(ArgType, nullptr);
8817 }
8818 
8819 /// \brief Determine whether a using statement is in a context where it will be
8820 /// apply in all contexts.
8822  switch (CurContext->getDeclKind()) {
8823  case Decl::TranslationUnit:
8824  return true;
8825  case Decl::LinkageSpec:
8826  return IsUsingDirectiveInToplevelContext(CurContext->getParent());
8827  default:
8828  return false;
8829  }
8830 }
8831 
8832 namespace {
8833 
8834 // Callback to only accept typo corrections that are namespaces.
8835 class NamespaceValidatorCCC : public CorrectionCandidateCallback {
8836 public:
8837  bool ValidateCandidate(const TypoCorrection &candidate) override {
8838  if (NamedDecl *ND = candidate.getCorrectionDecl())
8839  return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
8840  return false;
8841  }
8842 };
8843 
8844 }
8845 
8847  CXXScopeSpec &SS,
8848  SourceLocation IdentLoc,
8849  IdentifierInfo *Ident) {
8850  R.clear();
8851  if (TypoCorrection Corrected =
8852  S.CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), Sc, &SS,
8853  llvm::make_unique<NamespaceValidatorCCC>(),
8855  if (DeclContext *DC = S.computeDeclContext(SS, false)) {
8856  std::string CorrectedStr(Corrected.getAsString(S.getLangOpts()));
8857  bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
8858  Ident->getName().equals(CorrectedStr);
8859  S.diagnoseTypo(Corrected,
8860  S.PDiag(diag::err_using_directive_member_suggest)
8861  << Ident << DC << DroppedSpecifier << SS.getRange(),
8862  S.PDiag(diag::note_namespace_defined_here));
8863  } else {
8864  S.diagnoseTypo(Corrected,
8865  S.PDiag(diag::err_using_directive_suggest) << Ident,
8866  S.PDiag(diag::note_namespace_defined_here));
8867  }
8868  R.addDecl(Corrected.getFoundDecl());
8869  return true;
8870  }
8871  return false;
8872 }
8873 
8875  SourceLocation UsingLoc,
8876  SourceLocation NamespcLoc,
8877  CXXScopeSpec &SS,
8878  SourceLocation IdentLoc,
8879  IdentifierInfo *NamespcName,
8880  AttributeList *AttrList) {
8881  assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
8882  assert(NamespcName && "Invalid NamespcName.");
8883  assert(IdentLoc.isValid() && "Invalid NamespceName location.");
8884 
8885  // This can only happen along a recovery path.
8886  while (S->isTemplateParamScope())
8887  S = S->getParent();
8888  assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
8889 
8890  UsingDirectiveDecl *UDir = nullptr;
8891  NestedNameSpecifier *Qualifier = nullptr;
8892  if (SS.isSet())
8893  Qualifier = SS.getScopeRep();
8894 
8895  // Lookup namespace name.
8896  LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
8897  LookupParsedName(R, S, &SS);
8898  if (R.isAmbiguous())
8899  return nullptr;
8900 
8901  if (R.empty()) {
8902  R.clear();
8903  // Allow "using namespace std;" or "using namespace ::std;" even if
8904  // "std" hasn't been defined yet, for GCC compatibility.
8905  if ((!Qualifier || Qualifier->getKind() == NestedNameSpecifier::Global) &&
8906  NamespcName->isStr("std")) {
8907  Diag(IdentLoc, diag::ext_using_undefined_std);
8908  R.addDecl(getOrCreateStdNamespace());
8909  R.resolveKind();
8910  }
8911  // Otherwise, attempt typo correction.
8912  else TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, NamespcName);
8913  }
8914 
8915  if (!R.empty()) {
8916  NamedDecl *Named = R.getRepresentativeDecl();
8918  assert(NS && "expected namespace decl");
8919 
8920  // The use of a nested name specifier may trigger deprecation warnings.
8921  DiagnoseUseOfDecl(Named, IdentLoc);
8922 
8923  // C++ [namespace.udir]p1:
8924  // A using-directive specifies that the names in the nominated
8925  // namespace can be used in the scope in which the
8926  // using-directive appears after the using-directive. During
8927  // unqualified name lookup (3.4.1), the names appear as if they
8928  // were declared in the nearest enclosing namespace which
8929  // contains both the using-directive and the nominated
8930  // namespace. [Note: in this context, "contains" means "contains
8931  // directly or indirectly". ]
8932 
8933  // Find enclosing context containing both using-directive and
8934  // nominated namespace.
8935  DeclContext *CommonAncestor = cast<DeclContext>(NS);
8936  while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
8937  CommonAncestor = CommonAncestor->getParent();
8938 
8939  UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
8940  SS.getWithLocInContext(Context),
8941  IdentLoc, Named, CommonAncestor);
8942 
8943  if (IsUsingDirectiveInToplevelContext(CurContext) &&
8944  !SourceMgr.isInMainFile(SourceMgr.getExpansionLoc(IdentLoc))) {
8945  Diag(IdentLoc, diag::warn_using_directive_in_header);
8946  }
8947 
8948  PushUsingDirective(S, UDir);
8949  } else {
8950  Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
8951  }
8952 
8953  if (UDir)
8954  ProcessDeclAttributeList(S, UDir, AttrList);
8955 
8956  return UDir;
8957 }
8958 
8960  // If the scope has an associated entity and the using directive is at
8961  // namespace or translation unit scope, add the UsingDirectiveDecl into
8962  // its lookup structure so qualified name lookup can find it.
8963  DeclContext *Ctx = S->getEntity();
8964  if (Ctx && !Ctx->isFunctionOrMethod())
8965  Ctx->addDecl(UDir);
8966  else
8967  // Otherwise, it is at block scope. The using-directives will affect lookup
8968  // only to the end of the scope.
8969  S->PushUsingDirective(UDir);
8970 }
8971 
8972 
8974  AccessSpecifier AS,
8975  SourceLocation UsingLoc,
8976  SourceLocation TypenameLoc,
8977  CXXScopeSpec &SS,
8978  UnqualifiedId &Name,
8979  SourceLocation EllipsisLoc,
8980  AttributeList *AttrList) {
8981  assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
8982 
8983  if (SS.isEmpty()) {
8984  Diag(Name.getLocStart(), diag::err_using_requires_qualname);
8985  return nullptr;
8986  }
8987 
8988  switch (Name.getKind()) {
8994  break;
8995 
8998  // C++11 inheriting constructors.
8999  Diag(Name.getLocStart(),
9000  getLangOpts().CPlusPlus11 ?
9001  diag::warn_cxx98_compat_using_decl_constructor :
9002  diag::err_using_decl_constructor)
9003  << SS.getRange();
9004 
9005  if (getLangOpts().CPlusPlus11) break;
9006 
9007  return nullptr;
9008 
9010  Diag(Name.getLocStart(), diag::err_using_decl_destructor)
9011  << SS.getRange();
9012  return nullptr;
9013 
9015  Diag(Name.getLocStart(), diag::err_using_decl_template_id)
9017  return nullptr;
9018 
9020  llvm_unreachable("cannot parse qualified deduction guide name");
9021  }
9022 
9023  DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
9024  DeclarationName TargetName = TargetNameInfo.getName();
9025  if (!TargetName)
9026  return nullptr;
9027 
9028  // Warn about access declarations.
9029  if (UsingLoc.isInvalid()) {
9030  Diag(Name.getLocStart(),
9031  getLangOpts().CPlusPlus11 ? diag::err_access_decl
9032  : diag::warn_access_decl_deprecated)
9033  << FixItHint::CreateInsertion(SS.getRange().getBegin(), "using ");
9034  }
9035 
9036  if (EllipsisLoc.isInvalid()) {
9037  if (DiagnoseUnexpandedParameterPack(SS, UPPC_UsingDeclaration) ||
9038  DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC_UsingDeclaration))
9039  return nullptr;
9040  } else {
9042  !TargetNameInfo.containsUnexpandedParameterPack()) {
9043  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
9044  << SourceRange(SS.getBeginLoc(), TargetNameInfo.getEndLoc());
9045  EllipsisLoc = SourceLocation();
9046  }
9047  }
9048 
9049  NamedDecl *UD =
9050  BuildUsingDeclaration(S, AS, UsingLoc, TypenameLoc.isValid(), TypenameLoc,
9051  SS, TargetNameInfo, EllipsisLoc, AttrList,
9052  /*IsInstantiation*/false);
9053  if (UD)
9054  PushOnScopeChains(UD, S, /*AddToContext*/ false);
9055 
9056  return UD;
9057 }
9058 
9059 /// \brief Determine whether a using declaration considers the given
9060 /// declarations as "equivalent", e.g., if they are redeclarations of
9061 /// the same entity or are both typedefs of the same type.
9062 static bool
9064  if (D1->getCanonicalDecl() == D2->getCanonicalDecl())
9065  return true;
9066 
9067  if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(D1))
9068  if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2))
9069  return Context.hasSameType(TD1->getUnderlyingType(),
9070  TD2->getUnderlyingType());
9071 
9072  return false;
9073 }
9074 
9075 
9076 /// Determines whether to create a using shadow decl for a particular
9077 /// decl, given the set of decls existing prior to this using lookup.
9079  const LookupResult &Previous,
9080  UsingShadowDecl *&PrevShadow) {
9081  // Diagnose finding a decl which is not from a base class of the
9082  // current class. We do this now because there are cases where this
9083  // function will silently decide not to build a shadow decl, which
9084  // will pre-empt further diagnostics.
9085  //
9086  // We don't need to do this in C++11 because we do the check once on
9087  // the qualifier.
9088  //
9089  // FIXME: diagnose the following if we care enough:
9090  // struct A { int foo; };
9091  // struct B : A { using A::foo; };
9092  // template <class T> struct C : A {};
9093  // template <class T> struct D : C<T> { using B::foo; } // <---
9094  // This is invalid (during instantiation) in C++03 because B::foo
9095  // resolves to the using decl in B, which is not a base class of D<T>.
9096  // We can't diagnose it immediately because C<T> is an unknown
9097  // specialization. The UsingShadowDecl in D<T> then points directly
9098  // to A::foo, which will look well-formed when we instantiate.
9099  // The right solution is to not collapse the shadow-decl chain.
9100  if (!getLangOpts().CPlusPlus11 && CurContext->isRecord()) {
9101  DeclContext *OrigDC = Orig->getDeclContext();
9102 
9103  // Handle enums and anonymous structs.
9104  if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
9105  CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
9106  while (OrigRec->isAnonymousStructOrUnion())
9107  OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
9108 
9109  if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
9110  if (OrigDC == CurContext) {
9111  Diag(Using->getLocation(),
9112  diag::err_using_decl_nested_name_specifier_is_current_class)
9113  << Using->getQualifierLoc().getSourceRange();
9114  Diag(Orig->getLocation(), diag::note_using_decl_target);
9115  Using->setInvalidDecl();
9116  return true;
9117  }
9118 
9119  Diag(Using->getQualifierLoc().getBeginLoc(),
9120  diag::err_using_decl_nested_name_specifier_is_not_base_class)
9121  << Using->getQualifier()
9122  << cast<CXXRecordDecl>(CurContext)
9123  << Using->getQualifierLoc().getSourceRange();
9124  Diag(Orig->getLocation(), diag::note_using_decl_target);
9125  Using->setInvalidDecl();
9126  return true;
9127  }
9128  }
9129 
9130  if (Previous.empty()) return false;
9131 
9132  NamedDecl *Target = Orig;
9133  if (isa<UsingShadowDecl>(Target))
9134  Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
9135 
9136  // If the target happens to be one of the previous declarations, we
9137  // don't have a conflict.
9138  //
9139  // FIXME: but we might be increasing its access, in which case we
9140  // should redeclare it.
9141  NamedDecl *NonTag = nullptr, *Tag = nullptr;
9142  bool FoundEquivalentDecl = false;
9143  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
9144  I != E; ++I) {
9145  NamedDecl *D = (*I)->getUnderlyingDecl();
9146  // We can have UsingDecls in our Previous results because we use the same
9147  // LookupResult for checking whether the UsingDecl itself is a valid
9148  // redeclaration.
9149  if (isa<UsingDecl>(D) || isa<UsingPackDecl>(D))
9150  continue;
9151 
9152  if (IsEquivalentForUsingDecl(Context, D, Target)) {
9153  if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(*I))
9154  PrevShadow = Shadow;
9155  FoundEquivalentDecl = true;
9156  } else if (isEquivalentInternalLinkageDeclaration(D, Target)) {
9157  // We don't conflict with an existing using shadow decl of an equivalent
9158  // declaration, but we're not a redeclaration of it.
9159  FoundEquivalentDecl = true;
9160  }
9161 
9162  if (isVisible(D))
9163  (isa<TagDecl>(D) ? Tag : NonTag) = D;
9164  }
9165 
9166  if (FoundEquivalentDecl)
9167  return false;
9168 
9169  if (FunctionDecl *FD = Target->getAsFunction()) {
9170  NamedDecl *OldDecl = nullptr;
9171  switch (CheckOverload(nullptr, FD, Previous, OldDecl,
9172  /*IsForUsingDecl*/ true)) {
9173  case Ovl_Overload:
9174  return false;
9175 
9176  case Ovl_NonFunction:
9177  Diag(Using->getLocation(), diag::err_using_decl_conflict);
9178  break;
9179 
9180  // We found a decl with the exact signature.
9181  case Ovl_Match:
9182  // If we're in a record, we want to hide the target, so we
9183  // return true (without a diagnostic) to tell the caller not to
9184  // build a shadow decl.
9185  if (CurContext->isRecord())
9186  return true;
9187 
9188  // If we're not in a record, this is an error.
9189  Diag(Using->getLocation(), diag::err_using_decl_conflict);
9190  break;
9191  }
9192 
9193  Diag(Target->getLocation(), diag::note_using_decl_target);
9194  Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
9195  Using->setInvalidDecl();
9196  return true;
9197  }
9198 
9199  // Target is not a function.
9200 
9201  if (isa<TagDecl>(Target)) {
9202  // No conflict between a tag and a non-tag.
9203  if (!Tag) return false;
9204 
9205  Diag(Using->getLocation(), diag::err_using_decl_conflict);
9206  Diag(Target->getLocation(), diag::note_using_decl_target);
9207  Diag(Tag->getLocation(), diag::note_using_decl_conflict);
9208  Using->setInvalidDecl();
9209  return true;
9210  }
9211 
9212  // No conflict between a tag and a non-tag.
9213  if (!NonTag) return false;
9214 
9215  Diag(Using->getLocation(), diag::err_using_decl_conflict);
9216  Diag(Target->getLocation(), diag::note_using_decl_target);
9217  Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
9218  Using->setInvalidDecl();
9219  return true;
9220 }
9221 
9222 /// Determine whether a direct base class is a virtual base class.
9223 static bool isVirtualDirectBase(CXXRecordDecl *Derived, CXXRecordDecl *Base) {
9224  if (!Derived->getNumVBases())
9225  return false;
9226  for (auto &B : Derived->bases())
9227  if (B.getType()->getAsCXXRecordDecl() == Base)
9228  return B.isVirtual();
9229  llvm_unreachable("not a direct base class");
9230 }
9231 
9232 /// Builds a shadow declaration corresponding to a 'using' declaration.
9234  UsingDecl *UD,
9235  NamedDecl *Orig,
9236  UsingShadowDecl *PrevDecl) {
9237  // If we resolved to another shadow declaration, just coalesce them.
9238  NamedDecl *Target = Orig;
9239  if (isa<UsingShadowDecl>(Target)) {
9240  Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
9241  assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
9242  }
9243 
9244  NamedDecl *NonTemplateTarget = Target;
9245  if (auto *TargetTD = dyn_cast<TemplateDecl>(Target))
9246  NonTemplateTarget = TargetTD->getTemplatedDecl();
9247 
9248  UsingShadowDecl *Shadow;
9249  if (isa<CXXConstructorDecl>(NonTemplateTarget)) {
9250  bool IsVirtualBase =
9251  isVirtualDirectBase(cast<CXXRecordDecl>(CurContext),
9252  UD->getQualifier()->getAsRecordDecl());
9254  Context, CurContext, UD->getLocation(), UD, Orig, IsVirtualBase);
9255  } else {
9256  Shadow = UsingShadowDecl::Create(Context, CurContext, UD->getLocation(), UD,
9257  Target);
9258  }
9259  UD->addShadowDecl(Shadow);
9260 
9261  Shadow->setAccess(UD->getAccess());
9262  if (Orig->isInvalidDecl() || UD->isInvalidDecl())
9263  Shadow->setInvalidDecl();
9264 
9265  Shadow->setPreviousDecl(PrevDecl);
9266 
9267  if (S)
9268  PushOnScopeChains(Shadow, S);
9269  else
9270  CurContext->addDecl(Shadow);
9271 
9272 
9273  return Shadow;
9274 }
9275 
9276 /// Hides a using shadow declaration. This is required by the current
9277 /// using-decl implementation when a resolvable using declaration in a
9278 /// class is followed by a declaration which would hide or override
9279 /// one or more of the using decl's targets; for example:
9280 ///
9281 /// struct Base { void foo(int); };
9282 /// struct Derived : Base {
9283 /// using Base::foo;
9284 /// void foo(int);
9285 /// };
9286 ///
9287 /// The governing language is C++03 [namespace.udecl]p12:
9288 ///
9289 /// When a using-declaration brings names from a base class into a
9290 /// derived class scope, member functions in the derived class
9291 /// override and/or hide member functions with the same name and
9292 /// parameter types in a base class (rather than conflicting).
9293 ///
9294 /// There are two ways to implement this:
9295 /// (1) optimistically create shadow decls when they're not hidden
9296 /// by existing declarations, or
9297 /// (2) don't create any shadow decls (or at least don't make them
9298 /// visible) until we've fully parsed/instantiated the class.
9299 /// The problem with (1) is that we might have to retroactively remove
9300 /// a shadow decl, which requires several O(n) operations because the
9301 /// decl structures are (very reasonably) not designed for removal.
9302 /// (2) avoids this but is very fiddly and phase-dependent.
9304  if (Shadow->getDeclName().getNameKind() ==
9306  cast<CXXRecordDecl>(Shadow->getDeclContext())->removeConversion(Shadow);
9307 
9308  // Remove it from the DeclContext...
9309  Shadow->getDeclContext()->removeDecl(Shadow);
9310 
9311  // ...and the scope, if applicable...
9312  if (S) {
9313  S->RemoveDecl(Shadow);
9314  IdResolver.RemoveDecl(Shadow);
9315  }
9316 
9317  // ...and the using decl.
9318  Shadow->getUsingDecl()->removeShadowDecl(Shadow);
9319 
9320  // TODO: complain somehow if Shadow was used. It shouldn't
9321  // be possible for this to happen, because...?
9322 }
9323 
9324 /// Find the base specifier for a base class with the given type.
9326  QualType DesiredBase,
9327  bool &AnyDependentBases) {
9328  // Check whether the named type is a direct base class.
9329  CanQualType CanonicalDesiredBase = DesiredBase->getCanonicalTypeUnqualified();
9330  for (auto &Base : Derived->bases()) {
9331  CanQualType BaseType = Base.getType()->getCanonicalTypeUnqualified();
9332  if (CanonicalDesiredBase == BaseType)
9333  return &Base;
9334  if (BaseType->isDependentType())
9335  AnyDependentBases = true;
9336  }
9337  return nullptr;
9338 }
9339 
9340 namespace {
9341 class UsingValidatorCCC : public CorrectionCandidateCallback {
9342 public:
9343  UsingValidatorCCC(bool HasTypenameKeyword, bool IsInstantiation,
9344  NestedNameSpecifier *NNS, CXXRecordDecl *RequireMemberOf)
9345  : HasTypenameKeyword(HasTypenameKeyword),
9346  IsInstantiation(IsInstantiation), OldNNS(NNS),
9347  RequireMemberOf(RequireMemberOf) {}
9348 
9349  bool ValidateCandidate(const TypoCorrection &Candidate) override {
9350  NamedDecl *ND = Candidate.getCorrectionDecl();
9351 
9352  // Keywords are not valid here.
9353  if (!ND || isa<NamespaceDecl>(ND))
9354  return false;
9355 
9356  // Completely unqualified names are invalid for a 'using' declaration.
9357  if (Candidate.WillReplaceSpecifier() && !Candidate.getCorrectionSpecifier())
9358  return false;
9359 
9360  // FIXME: Don't correct to a name that CheckUsingDeclRedeclaration would
9361  // reject.
9362 
9363  if (RequireMemberOf) {
9364  auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
9365  if (FoundRecord && FoundRecord->isInjectedClassName()) {
9366  // No-one ever wants a using-declaration to name an injected-class-name
9367  // of a base class, unless they're declaring an inheriting constructor.
9368  ASTContext &Ctx = ND->getASTContext();
9369  if (!Ctx.getLangOpts().CPlusPlus11)
9370  return false;
9371  QualType FoundType = Ctx.getRecordType(FoundRecord);
9372 
9373  // Check that the injected-class-name is named as a member of its own
9374  // type; we don't want to suggest 'using Derived::Base;', since that
9375  // means something else.
9377  Candidate.WillReplaceSpecifier()
9378  ? Candidate.getCorrectionSpecifier()
9379  : OldNNS;
9380  if (!Specifier->getAsType() ||
9381  !Ctx.hasSameType(QualType(Specifier->getAsType(), 0), FoundType))
9382  return false;
9383 
9384  // Check that this inheriting constructor declaration actually names a
9385  // direct base class of the current class.
9386  bool AnyDependentBases = false;
9387  if (!findDirectBaseWithType(RequireMemberOf,
9388  Ctx.getRecordType(FoundRecord),
9389  AnyDependentBases) &&
9390  !AnyDependentBases)
9391  return false;
9392  } else {
9393  auto *RD = dyn_cast<CXXRecordDecl>(ND->getDeclContext());
9394  if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(RD))
9395  return false;
9396 
9397  // FIXME: Check that the base class member is accessible?
9398  }
9399  } else {
9400  auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
9401  if (FoundRecord && FoundRecord->isInjectedClassName())
9402  return false;
9403  }
9404 
9405  if (isa<TypeDecl>(ND))
9406  return HasTypenameKeyword || !IsInstantiation;
9407 
9408  return !HasTypenameKeyword;
9409  }
9410 
9411 private:
9412  bool HasTypenameKeyword;
9413  bool IsInstantiation;
9414  NestedNameSpecifier *OldNNS;
9415  CXXRecordDecl *RequireMemberOf;
9416 };
9417 } // end anonymous namespace
9418 
9419 /// Builds a using declaration.
9420 ///
9421 /// \param IsInstantiation - Whether this call arises from an
9422 /// instantiation of an unresolved using declaration. We treat
9423 /// the lookup differently for these declarations.
9425  SourceLocation UsingLoc,
9426  bool HasTypenameKeyword,
9427  SourceLocation TypenameLoc,
9428  CXXScopeSpec &SS,
9429  DeclarationNameInfo NameInfo,
9430  SourceLocation EllipsisLoc,
9431  AttributeList *AttrList,
9432  bool IsInstantiation) {
9433  assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
9434  SourceLocation IdentLoc = NameInfo.getLoc();
9435  assert(IdentLoc.isValid() && "Invalid TargetName location.");
9436 
9437  // FIXME: We ignore attributes for now.
9438 
9439  // For an inheriting constructor declaration, the name of the using
9440  // declaration is the name of a constructor in this class, not in the
9441  // base class.
9442  DeclarationNameInfo UsingName = NameInfo;
9443  if (UsingName.getName().getNameKind() == DeclarationName::CXXConstructorName)
9444  if (auto *RD = dyn_cast<CXXRecordDecl>(CurContext))
9446  Context.getCanonicalType(Context.getRecordType(RD))));
9447 
9448  // Do the redeclaration lookup in the current scope.
9449  LookupResult Previous(*this, UsingName, LookupUsingDeclName,
9450  ForVisibleRedeclaration);
9451  Previous.setHideTags(false);
9452  if (S) {
9453  LookupName(Previous, S);
9454 
9455  // It is really dumb that we have to do this.
9456  LookupResult::Filter F = Previous.makeFilter();
9457  while (F.hasNext()) {
9458  NamedDecl *D = F.next();
9459  if (!isDeclInScope(D, CurContext, S))
9460  F.erase();
9461  // If we found a local extern declaration that's not ordinarily visible,
9462  // and this declaration is being added to a non-block scope, ignore it.
9463  // We're only checking for scope conflicts here, not also for violations
9464  // of the linkage rules.
9465  else if (!CurContext->isFunctionOrMethod() && D->isLocalExternDecl() &&
9467  F.erase();
9468  }
9469  F.done();
9470  } else {
9471  assert(IsInstantiation && "no scope in non-instantiation");
9472  if (CurContext->isRecord())
9473  LookupQualifiedName(Previous, CurContext);
9474  else {
9475  // No redeclaration check is needed here; in non-member contexts we
9476  // diagnosed all possible conflicts with other using-declarations when
9477  // building the template:
9478  //
9479  // For a dependent non-type using declaration, the only valid case is
9480  // if we instantiate to a single enumerator. We check for conflicts
9481  // between shadow declarations we introduce, and we check in the template
9482  // definition for conflicts between a non-type using declaration and any
9483  // other declaration, which together covers all cases.
9484  //
9485  // A dependent typename using declaration will never successfully
9486  // instantiate, since it will always name a class member, so we reject
9487  // that in the template definition.
9488  }
9489  }
9490 
9491  // Check for invalid redeclarations.
9492  if (CheckUsingDeclRedeclaration(UsingLoc, HasTypenameKeyword,
9493  SS, IdentLoc, Previous))
9494  return nullptr;
9495 
9496  // Check for bad qualifiers.
9497  if (CheckUsingDeclQualifier(UsingLoc, HasTypenameKeyword, SS, NameInfo,
9498  IdentLoc))
9499  return nullptr;
9500 
9501  DeclContext *LookupContext = computeDeclContext(SS);
9502  NamedDecl *D;
9503  NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
9504  if (!LookupContext || EllipsisLoc.isValid()) {
9505  if (HasTypenameKeyword) {
9506  // FIXME: not all declaration name kinds are legal here
9507  D = UnresolvedUsingTypenameDecl::Create(Context, CurContext,
9508  UsingLoc, TypenameLoc,
9509  QualifierLoc,
9510  IdentLoc, NameInfo.getName(),
9511  EllipsisLoc);
9512  } else {
9513  D = UnresolvedUsingValueDecl::Create(Context, CurContext, UsingLoc,
9514  QualifierLoc, NameInfo, EllipsisLoc);
9515  }
9516  D->setAccess(AS);
9517  CurContext->addDecl(D);
9518  return D;
9519  }
9520 
9521  auto Build = [&](bool Invalid) {
9522  UsingDecl *UD =
9523  UsingDecl::Create(Context, CurContext, UsingLoc, QualifierLoc,
9524  UsingName, HasTypenameKeyword);
9525  UD->setAccess(AS);
9526  CurContext->addDecl(UD);
9527  UD->setInvalidDecl(Invalid);
9528  return UD;
9529  };
9530  auto BuildInvalid = [&]{ return Build(true); };
9531  auto BuildValid = [&]{ return Build(false); };
9532 
9533  if (RequireCompleteDeclContext(SS, LookupContext))
9534  return BuildInvalid();
9535 
9536  // Look up the target name.
9537  LookupResult R(*this, NameInfo, LookupOrdinaryName);
9538 
9539  // Unlike most lookups, we don't always want to hide tag
9540  // declarations: tag names are visible through the using declaration
9541  // even if hidden by ordinary names, *except* in a dependent context
9542  // where it's important for the sanity of two-phase lookup.
9543  if (!IsInstantiation)
9544  R.setHideTags(false);
9545 
9546  // For the purposes of this lookup, we have a base object type
9547  // equal to that of the current context.
9548  if (CurContext->isRecord()) {
9550  Context.getTypeDeclType(cast<CXXRecordDecl>(CurContext)));
9551  }
9552 
9553  LookupQualifiedName(R, LookupContext);
9554 
9555  // Try to correct typos if possible. If constructor name lookup finds no
9556  // results, that means the named class has no explicit constructors, and we
9557  // suppressed declaring implicit ones (probably because it's dependent or
9558  // invalid).
9559  if (R.empty() &&
9561  // HACK: Work around a bug in libstdc++'s detection of ::gets. Sometimes
9562  // it will believe that glibc provides a ::gets in cases where it does not,
9563  // and will try to pull it into namespace std with a using-declaration.
9564  // Just ignore the using-declaration in that case.
9565  auto *II = NameInfo.getName().getAsIdentifierInfo();
9566  if (getLangOpts().CPlusPlus14 && II && II->isStr("gets") &&
9567  CurContext->isStdNamespace() &&
9568  isa<TranslationUnitDecl>(LookupContext) &&
9569  getSourceManager().isInSystemHeader(UsingLoc))
9570  return nullptr;
9571  if (TypoCorrection Corrected = CorrectTypo(
9572  R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
9573  llvm::make_unique<UsingValidatorCCC>(
9574  HasTypenameKeyword, IsInstantiation, SS.getScopeRep(),
9575  dyn_cast<CXXRecordDecl>(CurContext)),
9576  CTK_ErrorRecovery)) {
9577  // We reject candidates where DroppedSpecifier == true, hence the
9578  // literal '0' below.
9579  diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
9580  << NameInfo.getName() << LookupContext << 0
9581  << SS.getRange());
9582 
9583  // If we picked a correction with no attached Decl we can't do anything
9584  // useful with it, bail out.
9585  NamedDecl *ND = Corrected.getCorrectionDecl();
9586  if (!ND)
9587  return BuildInvalid();
9588 
9589  // If we corrected to an inheriting constructor, handle it as one.
9590  auto *RD = dyn_cast<CXXRecordDecl>(ND);
9591  if (RD && RD->isInjectedClassName()) {
9592  // The parent of the injected class name is the class itself.
9593  RD = cast<CXXRecordDecl>(RD->getParent());
9594 
9595  // Fix up the information we'll use to build the using declaration.
9596  if (Corrected.WillReplaceSpecifier()) {
9598  Builder.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
9599  QualifierLoc.getSourceRange());
9600  QualifierLoc = Builder.getWithLocInContext(Context);
9601  }
9602 
9603  // In this case, the name we introduce is the name of a derived class
9604  // constructor.
9605  auto *CurClass = cast<CXXRecordDecl>(CurContext);
9606  UsingName.setName(Context.DeclarationNames.getCXXConstructorName(
9607  Context.getCanonicalType(Context.getRecordType(CurClass))));
9608  UsingName.setNamedTypeInfo(nullptr);
9609  for (auto *Ctor : LookupConstructors(RD))
9610  R.addDecl(Ctor);
9611  R.resolveKind();
9612  } else {
9613  // FIXME: Pick up all the declarations if we found an overloaded
9614  // function.
9615  UsingName.setName(ND->getDeclName());
9616  R.addDecl(ND);
9617  }
9618  } else {
9619  Diag(IdentLoc, diag::err_no_member)
9620  << NameInfo.getName() << LookupContext << SS.getRange();
9621  return BuildInvalid();
9622  }
9623  }
9624 
9625  if (R.isAmbiguous())
9626  return BuildInvalid();
9627 
9628  if (HasTypenameKeyword) {
9629  // If we asked for a typename and got a non-type decl, error out.
9630  if (!R.getAsSingle<TypeDecl>()) {
9631  Diag(IdentLoc, diag::err_using_typename_non_type);
9632  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
9633  Diag((*I)->getUnderlyingDecl()->getLocation(),
9634  diag::note_using_decl_target);
9635  return BuildInvalid();
9636  }
9637  } else {
9638  // If we asked for a non-typename and we got a type, error out,
9639  // but only if this is an instantiation of an unresolved using
9640  // decl. Otherwise just silently find the type name.
9641  if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
9642  Diag(IdentLoc, diag::err_using_dependent_value_is_type);
9643  Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
9644  return BuildInvalid();
9645  }
9646  }
9647 
9648  // C++14 [namespace.udecl]p6:
9649  // A using-declaration shall not name a namespace.
9650  if (R.getAsSingle<NamespaceDecl>()) {
9651  Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
9652  << SS.getRange();
9653  return BuildInvalid();
9654  }
9655 
9656  // C++14 [namespace.udecl]p7:
9657  // A using-declaration shall not name a scoped enumerator.
9658  if (auto *ED = R.getAsSingle<EnumConstantDecl>()) {
9659  if (cast<EnumDecl>(ED->getDeclContext())->isScoped()) {
9660  Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_scoped_enum)
9661  << SS.getRange();
9662  return BuildInvalid();
9663  }
9664  }
9665 
9666  UsingDecl *UD = BuildValid();
9667 
9668  // Some additional rules apply to inheriting constructors.
9669  if (UsingName.getName().getNameKind() ==
9671  // Suppress access diagnostics; the access check is instead performed at the
9672  // point of use for an inheriting constructor.
9673  R.suppressDiagnostics();
9674  if (CheckInheritingConstructorUsingDecl(UD))
9675  return UD;
9676  }
9677 
9678  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
9679  UsingShadowDecl *PrevDecl = nullptr;
9680  if (!CheckUsingShadowDecl(UD, *I, Previous, PrevDecl))
9681  BuildUsingShadowDecl(S, UD, *I, PrevDecl);
9682  }
9683 
9684  return UD;
9685 }
9686 
9688  ArrayRef<NamedDecl *> Expansions) {
9689  assert(isa<UnresolvedUsingValueDecl>(InstantiatedFrom) ||
9690  isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) ||
9691  isa<UsingPackDecl>(InstantiatedFrom));
9692 
9693  auto *UPD =
9694  UsingPackDecl::Create(Context, CurContext, InstantiatedFrom, Expansions);
9695  UPD->setAccess(InstantiatedFrom->getAccess());
9696  CurContext->addDecl(UPD);
9697  return UPD;
9698 }
9699 
9700 /// Additional checks for a using declaration referring to a constructor name.
9702  assert(!UD->hasTypename() && "expecting a constructor name");
9703 
9704  const Type *SourceType = UD->getQualifier()->getAsType();
9705  assert(SourceType &&
9706  "Using decl naming constructor doesn't have type in scope spec.");
9707  CXXRecordDecl *TargetClass = cast<CXXRecordDecl>(CurContext);
9708 
9709  // Check whether the named type is a direct base class.
9710  bool AnyDependentBases = false;
9711  auto *Base = findDirectBaseWithType(TargetClass, QualType(SourceType, 0),
9712  AnyDependentBases);
9713  if (!Base && !AnyDependentBases) {
9714  Diag(UD->getUsingLoc(),
9715  diag::err_using_decl_constructor_not_in_direct_base)
9716  << UD->getNameInfo().getSourceRange()
9717  << QualType(SourceType, 0) << TargetClass;
9718  UD->setInvalidDecl();
9719  return true;
9720  }
9721 
9722  if (Base)
9723  Base->setInheritConstructors();
9724 
9725  return false;
9726 }
9727 
9728 /// Checks that the given using declaration is not an invalid
9729 /// redeclaration. Note that this is checking only for the using decl
9730 /// itself, not for any ill-formedness among the UsingShadowDecls.
9732  bool HasTypenameKeyword,
9733  const CXXScopeSpec &SS,
9734  SourceLocation NameLoc,
9735  const LookupResult &Prev) {
9736  NestedNameSpecifier *Qual = SS.getScopeRep();
9737 
9738  // C++03 [namespace.udecl]p8:
9739  // C++0x [namespace.udecl]p10:
9740  // A using-declaration is a declaration and can therefore be used
9741  // repeatedly where (and only where) multiple declarations are
9742  // allowed.
9743  //
9744  // That's in non-member contexts.
9745  if (!CurContext->getRedeclContext()->isRecord()) {
9746  // A dependent qualifier outside a class can only ever resolve to an
9747  // enumeration type. Therefore it conflicts with any other non-type
9748  // declaration in the same scope.
9749  // FIXME: How should we check for dependent type-type conflicts at block
9750  // scope?
9751  if (Qual->isDependent() && !HasTypenameKeyword) {
9752  for (auto *D : Prev) {
9753  if (!isa<TypeDecl>(D) && !isa<UsingDecl>(D) && !isa<UsingPackDecl>(D)) {
9754  bool OldCouldBeEnumerator =
9755  isa<UnresolvedUsingValueDecl>(D) || isa<EnumConstantDecl>(D);
9756  Diag(NameLoc,
9757  OldCouldBeEnumerator ? diag::err_redefinition
9758  : diag::err_redefinition_different_kind)
9759  << Prev.getLookupName();
9760  Diag(D->getLocation(), diag::note_previous_definition);
9761  return true;
9762  }
9763  }
9764  }
9765  return false;
9766  }
9767 
9768  for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
9769  NamedDecl *D = *I;
9770 
9771  bool DTypename;
9772  NestedNameSpecifier *DQual;
9773  if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
9774  DTypename = UD->hasTypename();
9775  DQual = UD->getQualifier();
9776  } else if (UnresolvedUsingValueDecl *UD
9777  = dyn_cast<UnresolvedUsingValueDecl>(D)) {
9778  DTypename = false;
9779  DQual = UD->getQualifier();
9780  } else if (UnresolvedUsingTypenameDecl *UD
9781  = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
9782  DTypename = true;
9783  DQual = UD->getQualifier();
9784  } else continue;
9785 
9786  // using decls differ if one says 'typename' and the other doesn't.
9787  // FIXME: non-dependent using decls?
9788  if (HasTypenameKeyword != DTypename) continue;
9789 
9790  // using decls differ if they name different scopes (but note that
9791  // template instantiation can cause this check to trigger when it
9792  // didn't before instantiation).
9793  if (Context.getCanonicalNestedNameSpecifier(Qual) !=
9794  Context.getCanonicalNestedNameSpecifier(DQual))
9795  continue;
9796 
9797  Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
9798  Diag(D->getLocation(), diag::note_using_decl) << 1;
9799  return true;
9800  }
9801 
9802  return false;
9803 }
9804 
9805 
9806 /// Checks that the given nested-name qualifier used in a using decl
9807 /// in the current context is appropriately related to the current
9808 /// scope. If an error is found, diagnoses it and returns true.
9810  bool HasTypename,
9811  const CXXScopeSpec &SS,
9812  const DeclarationNameInfo &NameInfo,
9813  SourceLocation NameLoc) {
9814  DeclContext *NamedContext = computeDeclContext(SS);
9815 
9816  if (!CurContext->isRecord()) {
9817  // C++03 [namespace.udecl]p3:
9818  // C++0x [namespace.udecl]p8:
9819  // A using-declaration for a class member shall be a member-declaration.
9820 
9821  // If we weren't able to compute a valid scope, it might validly be a
9822  // dependent class scope or a dependent enumeration unscoped scope. If
9823  // we have a 'typename' keyword, the scope must resolve to a class type.
9824  if ((HasTypename && !NamedContext) ||
9825  (NamedContext && NamedContext->getRedeclContext()->isRecord())) {
9826  auto *RD = NamedContext
9827  ? cast<CXXRecordDecl>(NamedContext->getRedeclContext())
9828  : nullptr;
9829  if (RD && RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), RD))
9830  RD = nullptr;
9831 
9832  Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member)
9833  << SS.getRange();
9834 
9835  // If we have a complete, non-dependent source type, try to suggest a
9836  // way to get the same effect.
9837  if (!RD)
9838  return true;
9839 
9840  // Find what this using-declaration was referring to.
9841  LookupResult R(*this, NameInfo, LookupOrdinaryName);
9842  R.setHideTags(false);
9843  R.suppressDiagnostics();
9844  LookupQualifiedName(R, RD);
9845 
9846  if (R.getAsSingle<TypeDecl>()) {
9847  if (getLangOpts().CPlusPlus11) {
9848  // Convert 'using X::Y;' to 'using Y = X::Y;'.
9849  Diag(SS.getBeginLoc(), diag::note_using_decl_class_member_workaround)
9850  << 0 // alias declaration
9852  NameInfo.getName().getAsString() +
9853  " = ");
9854  } else {
9855  // Convert 'using X::Y;' to 'typedef X::Y Y;'.
9856  SourceLocation InsertLoc =
9857  getLocForEndOfToken(NameInfo.getLocEnd());
9858  Diag(InsertLoc, diag::note_using_decl_class_member_workaround)
9859  << 1 // typedef declaration
9860  << FixItHint::CreateReplacement(UsingLoc, "typedef")
9862  InsertLoc, " " + NameInfo.getName().getAsString());
9863  }
9864  } else if (R.getAsSingle<VarDecl>()) {
9865  // Don't provide a fixit outside C++11 mode; we don't want to suggest
9866  // repeating the type of the static data member here.
9867  FixItHint FixIt;
9868  if (getLangOpts().CPlusPlus11) {
9869  // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
9871  UsingLoc, "auto &" + NameInfo.getName().getAsString() + " = ");
9872  }
9873 
9874  Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
9875  << 2 // reference declaration
9876  << FixIt;
9877  } else if (R.getAsSingle<EnumConstantDecl>()) {
9878  // Don't provide a fixit outside C++11 mode; we don't want to suggest
9879  // repeating the type of the enumeration here, and we can't do so if
9880  // the type is anonymous.
9881  FixItHint FixIt;
9882  if (getLangOpts().CPlusPlus11) {
9883  // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
9885  UsingLoc,
9886  "constexpr auto " + NameInfo.getName().getAsString() + " = ");
9887  }
9888 
9889  Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
9890  << (getLangOpts().CPlusPlus11 ? 4 : 3) // const[expr] variable
9891  << FixIt;
9892  }
9893  return true;
9894  }
9895 
9896  // Otherwise, this might be valid.
9897  return false;
9898  }
9899 
9900  // The current scope is a record.
9901 
9902  // If the named context is dependent, we can't decide much.
9903  if (!NamedContext) {
9904  // FIXME: in C++0x, we can diagnose if we can prove that the
9905  // nested-name-specifier does not refer to a base class, which is
9906  // still possible in some cases.
9907 
9908  // Otherwise we have to conservatively report that things might be
9909  // okay.
9910  return false;
9911  }
9912 
9913  if (!NamedContext->isRecord()) {
9914  // Ideally this would point at the last name in the specifier,
9915  // but we don't have that level of source info.
9916  Diag(SS.getRange().getBegin(),
9917  diag::err_using_decl_nested_name_specifier_is_not_class)
9918  << SS.getScopeRep() << SS.getRange();
9919  return true;
9920  }
9921 
9922  if (!NamedContext->isDependentContext() &&
9923  RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), NamedContext))
9924  return true;
9925 
9926  if (getLangOpts().CPlusPlus11) {
9927  // C++11 [namespace.udecl]p3:
9928  // In a using-declaration used as a member-declaration, the
9929  // nested-name-specifier shall name a base class of the class
9930  // being defined.
9931 
9932  if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
9933  cast<CXXRecordDecl>(NamedContext))) {
9934  if (CurContext == NamedContext) {
9935  Diag(NameLoc,
9936  diag::err_using_decl_nested_name_specifier_is_current_class)
9937  << SS.getRange();
9938  return true;
9939  }
9940 
9941  if (!cast<CXXRecordDecl>(NamedContext)->isInvalidDecl()) {
9942  Diag(SS.getRange().getBegin(),
9943  diag::err_using_decl_nested_name_specifier_is_not_base_class)
9944  << SS.getScopeRep()
9945  << cast<CXXRecordDecl>(CurContext)
9946  << SS.getRange();
9947  }
9948  return true;
9949  }
9950 
9951  return false;
9952  }
9953 
9954  // C++03 [namespace.udecl]p4:
9955  // A using-declaration used as a member-declaration shall refer
9956  // to a member of a base class of the class being defined [etc.].
9957 
9958  // Salient point: SS doesn't have to name a base class as long as
9959  // lookup only finds members from base classes. Therefore we can
9960  // diagnose here only if we can prove that that can't happen,
9961  // i.e. if the class hierarchies provably don't intersect.
9962 
9963  // TODO: it would be nice if "definitely valid" results were cached
9964  // in the UsingDecl and UsingShadowDecl so that these checks didn't
9965  // need to be repeated.
9966 
9967  llvm::SmallPtrSet<const CXXRecordDecl *, 4> Bases;
9968  auto Collect = [&Bases](const CXXRecordDecl *Base) {
9969  Bases.insert(Base);
9970  return true;
9971  };
9972 
9973  // Collect all bases. Return false if we find a dependent base.
9974  if (!cast<CXXRecordDecl>(CurContext)->forallBases(Collect))
9975  return false;
9976 
9977  // Returns true if the base is dependent or is one of the accumulated base
9978  // classes.
9979  auto IsNotBase = [&Bases](const CXXRecordDecl *Base) {
9980  return !Bases.count(Base);
9981  };
9982 
9983  // Return false if the class has a dependent base or if it or one
9984  // of its bases is present in the base set of the current context.
9985  if (Bases.count(cast<CXXRecordDecl>(NamedContext)) ||
9986  !cast<CXXRecordDecl>(NamedContext)->forallBases(IsNotBase))
9987  return false;
9988 
9989  Diag(SS.getRange().getBegin(),
9990  diag::err_using_decl_nested_name_specifier_is_not_base_class)
9991  << SS.getScopeRep()
9992  << cast<CXXRecordDecl>(CurContext)
9993  << SS.getRange();
9994 
9995  return true;
9996 }
9997 
9999  AccessSpecifier AS,
10000  MultiTemplateParamsArg TemplateParamLists,
10001  SourceLocation UsingLoc,
10002  UnqualifiedId &Name,
10003  AttributeList *AttrList,
10004  TypeResult Type,
10005  Decl *DeclFromDeclSpec) {
10006  // Skip up to the relevant declaration scope.
10007  while (S->isTemplateParamScope())
10008  S = S->getParent();
10009  assert((S->getFlags() & Scope::DeclScope) &&
10010  "got alias-declaration outside of declaration scope");
10011 
10012  if (Type.isInvalid())
10013  return nullptr;
10014 
10015  bool Invalid = false;
10016  DeclarationNameInfo NameInfo = GetNameFromUnqualifiedId(Name);
10017  TypeSourceInfo *TInfo = nullptr;
10018  GetTypeFromParser(Type.get(), &TInfo);
10019 
10020  if (DiagnoseClassNameShadow(CurContext, NameInfo))
10021  return nullptr;
10022 
10023  if (DiagnoseUnexpandedParameterPack(Name.StartLocation, TInfo,
10024  UPPC_DeclarationType)) {
10025  Invalid = true;
10026  TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
10027  TInfo->getTypeLoc().getBeginLoc());
10028  }
10029 
10030  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
10031  TemplateParamLists.size()
10032  ? forRedeclarationInCurContext()
10033  : ForVisibleRedeclaration);
10034  LookupName(Previous, S);
10035 
10036  // Warn about shadowing the name of a template parameter.
10037  if (Previous.isSingleResult() &&
10038  Previous.getFoundDecl()->isTemplateParameter()) {
10039  DiagnoseTemplateParameterShadow(Name.StartLocation,Previous.getFoundDecl());
10040  Previous.clear();
10041  }
10042 
10043  assert(Name.Kind == UnqualifiedIdKind::IK_Identifier &&
10044  "name in alias declaration must be an identifier");
10045  TypeAliasDecl *NewTD = TypeAliasDecl::Create(Context, CurContext, UsingLoc,
10046  Name.StartLocation,
10047  Name.Identifier, TInfo);
10048 
10049  NewTD->setAccess(AS);
10050 
10051  if (Invalid)
10052  NewTD->setInvalidDecl();
10053 
10054  ProcessDeclAttributeList(S, NewTD, AttrList);
10055  AddPragmaAttributes(S, NewTD);
10056 
10057  CheckTypedefForVariablyModifiedType(S, NewTD);
10058  Invalid |= NewTD->isInvalidDecl();
10059 
10060  bool Redeclaration = false;
10061 
10062  NamedDecl *NewND;
10063  if (TemplateParamLists.size()) {
10064  TypeAliasTemplateDecl *OldDecl = nullptr;
10065  TemplateParameterList *OldTemplateParams = nullptr;
10066 
10067  if (TemplateParamLists.size() != 1) {
10068  Diag(UsingLoc, diag::err_alias_template_extra_headers)
10069  << SourceRange(TemplateParamLists[1]->getTemplateLoc(),
10070  TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
10071  }
10072  TemplateParameterList *TemplateParams = TemplateParamLists[0];
10073 
10074  // Check that we can declare a template here.
10075  if (CheckTemplateDeclScope(S, TemplateParams))
10076  return nullptr;
10077 
10078  // Only consider previous declarations in the same scope.
10079  FilterLookupForScope(Previous, CurContext, S, /*ConsiderLinkage*/false,
10080  /*ExplicitInstantiationOrSpecialization*/false);
10081  if (!Previous.empty()) {
10082  Redeclaration = true;
10083 
10084  OldDecl = Previous.getAsSingle<TypeAliasTemplateDecl>();
10085  if (!OldDecl && !Invalid) {
10086  Diag(UsingLoc, diag::err_redefinition_different_kind)
10087  << Name.Identifier;
10088 
10089  NamedDecl *OldD = Previous.getRepresentativeDecl();
10090  if (OldD->getLocation().isValid())
10091  Diag(OldD->getLocation(), diag::note_previous_definition);
10092 
10093  Invalid = true;
10094  }
10095 
10096  if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) {
10097  if (TemplateParameterListsAreEqual(TemplateParams,
10098  OldDecl->getTemplateParameters(),
10099  /*Complain=*/true,
10100  TPL_TemplateMatch))
10101  OldTemplateParams = OldDecl->getTemplateParameters();
10102  else
10103  Invalid = true;
10104 
10105  TypeAliasDecl *OldTD = OldDecl->getTemplatedDecl();
10106  if (!Invalid &&
10107  !Context.hasSameType(OldTD->getUnderlyingType(),
10108  NewTD->getUnderlyingType())) {
10109  // FIXME: The C++0x standard does not clearly say this is ill-formed,
10110  // but we can't reasonably accept it.
10111  Diag(NewTD->getLocation(), diag::err_redefinition_different_typedef)
10112  << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType();
10113  if (OldTD->getLocation().isValid())
10114  Diag(OldTD->getLocation(), diag::note_previous_definition);
10115  Invalid = true;
10116  }
10117  }
10118  }
10119 
10120  // Merge any previous default template arguments into our parameters,
10121  // and check the parameter list.
10122  if (CheckTemplateParameterList(TemplateParams, OldTemplateParams,
10123  TPC_TypeAliasTemplate))
10124  return nullptr;
10125 
10126  TypeAliasTemplateDecl *NewDecl =
10127  TypeAliasTemplateDecl::Create(Context, CurContext, UsingLoc,
10128  Name.Identifier, TemplateParams,
10129  NewTD);
10130  NewTD->setDescribedAliasTemplate(NewDecl);
10131 
10132  NewDecl->setAccess(AS);
10133 
10134  if (Invalid)
10135  NewDecl->setInvalidDecl();
10136  else if (OldDecl) {
10137  NewDecl->setPreviousDecl(OldDecl);
10138  CheckRedeclarationModuleOwnership(NewDecl, OldDecl);
10139  }
10140 
10141  NewND = NewDecl;
10142  } else {
10143  if (auto *TD = dyn_cast_or_null<TagDecl>(DeclFromDeclSpec)) {
10144  setTagNameForLinkagePurposes(TD, NewTD);
10145  handleTagNumbering(TD, S);
10146  }
10147  ActOnTypedefNameDecl(S, CurContext, NewTD, Previous, Redeclaration);
10148  NewND = NewTD;
10149  }
10150 
10151  PushOnScopeChains(NewND, S);
10152  ActOnDocumentableDecl(NewND);
10153  return NewND;
10154 }
10155 
10157  SourceLocation AliasLoc,
10158  IdentifierInfo *Alias, CXXScopeSpec &SS,
10159  SourceLocation IdentLoc,
10160  IdentifierInfo *Ident) {
10161 
10162  // Lookup the namespace name.
10163  LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
10164  LookupParsedName(R, S, &SS);
10165 
10166  if (R.isAmbiguous())
10167  return nullptr;
10168 
10169  if (R.empty()) {
10170  if (!TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, Ident)) {
10171  Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
10172  return nullptr;
10173  }
10174  }
10175  assert(!R.isAmbiguous() && !R.empty());
10176  NamedDecl *ND = R.getRepresentativeDecl();
10177 
10178  // Check if we have a previous declaration with the same name.
10179  LookupResult PrevR(*this, Alias, AliasLoc, LookupOrdinaryName,
10180  ForVisibleRedeclaration);
10181  LookupName(PrevR, S);
10182 
10183  // Check we're not shadowing a template parameter.
10184  if (PrevR.isSingleResult() && PrevR.getFoundDecl()->isTemplateParameter()) {
10185  DiagnoseTemplateParameterShadow(AliasLoc, PrevR.getFoundDecl());
10186  PrevR.clear();
10187  }
10188 
10189  // Filter out any other lookup result from an enclosing scope.
10190  FilterLookupForScope(PrevR, CurContext, S, /*ConsiderLinkage*/false,
10191  /*AllowInlineNamespace*/false);
10192 
10193  // Find the previous declaration and check that we can redeclare it.
10194  NamespaceAliasDecl *Prev = nullptr;
10195  if (PrevR.isSingleResult()) {
10196  NamedDecl *PrevDecl = PrevR.getRepresentativeDecl();
10197  if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
10198  // We already have an alias with the same name that points to the same
10199  // namespace; check that it matches.
10200  if (AD->getNamespace()->Equals(getNamespaceDecl(ND))) {
10201  Prev = AD;
10202  } else if (isVisible(PrevDecl)) {
10203  Diag(AliasLoc, diag::err_redefinition_different_namespace_alias)
10204  << Alias;
10205  Diag(AD->getLocation(), diag::note_previous_namespace_alias)
10206  << AD->getNamespace();
10207  return nullptr;
10208  }
10209  } else if (isVisible(PrevDecl)) {
10210  unsigned DiagID = isa<NamespaceDecl>(PrevDecl->getUnderlyingDecl())
10211  ? diag::err_redefinition
10212  : diag::err_redefinition_different_kind;
10213  Diag(AliasLoc, DiagID) << Alias;
10214  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
10215  return nullptr;
10216  }
10217  }
10218 
10219  // The use of a nested name specifier may trigger deprecation warnings.
10220  DiagnoseUseOfDecl(ND, IdentLoc);
10221 
10222  NamespaceAliasDecl *AliasDecl =
10223  NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
10224  Alias, SS.getWithLocInContext(Context),
10225  IdentLoc, ND);
10226  if (Prev)
10227  AliasDecl->setPreviousDecl(Prev);
10228 
10229  PushOnScopeChains(AliasDecl, S);
10230  return AliasDecl;
10231 }
10232 
10233 namespace {
10234 struct SpecialMemberExceptionSpecInfo
10235  : SpecialMemberVisitor<SpecialMemberExceptionSpecInfo> {
10236  SourceLocation Loc;
10238 
10239  SpecialMemberExceptionSpecInfo(Sema &S, CXXMethodDecl *MD,
10242  SourceLocation Loc)
10243  : SpecialMemberVisitor(S, MD, CSM, ICI), Loc(Loc), ExceptSpec(S) {}
10244 
10245  bool visitBase(CXXBaseSpecifier *Base);
10246  bool visitField(FieldDecl *FD);
10247 
10248  void visitClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
10249  unsigned Quals);
10250 
10251  void visitSubobjectCall(Subobject Subobj,
10253 };
10254 }
10255 
10256 bool SpecialMemberExceptionSpecInfo::visitBase(CXXBaseSpecifier *Base) {
10257  auto *RT = Base->getType()->getAs<RecordType>();
10258  if (!RT)
10259  return false;
10260 
10261  auto *BaseClass = cast<CXXRecordDecl>(RT->getDecl());
10262  Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
10263  if (auto *BaseCtor = SMOR.getMethod()) {
10264  visitSubobjectCall(Base, BaseCtor);
10265  return false;
10266  }
10267 
10268  visitClassSubobject(BaseClass, Base, 0);
10269  return false;
10270 }
10271 
10272 bool SpecialMemberExceptionSpecInfo::visitField(FieldDecl *FD) {
10273  if (CSM == Sema::CXXDefaultConstructor && FD->hasInClassInitializer()) {
10274  Expr *E = FD->getInClassInitializer();
10275  if (!E)
10276  // FIXME: It's a little wasteful to build and throw away a
10277  // CXXDefaultInitExpr here.
10278  // FIXME: We should have a single context note pointing at Loc, and
10279  // this location should be MD->getLocation() instead, since that's
10280  // the location where we actually use the default init expression.
10281  E = S.BuildCXXDefaultInitExpr(Loc, FD).get();
10282  if (E)
10283  ExceptSpec.CalledExpr(E);
10284  } else if (auto *RT = S.Context.getBaseElementType(FD->getType())
10285  ->getAs<RecordType>()) {
10286  visitClassSubobject(cast<CXXRecordDecl>(RT->getDecl()), FD,
10287  FD->getType().getCVRQualifiers());
10288  }
10289  return false;
10290 }
10291 
10292 void SpecialMemberExceptionSpecInfo::visitClassSubobject(CXXRecordDecl *Class,
10293  Subobject Subobj,
10294  unsigned Quals) {
10295  FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
10296  bool IsMutable = Field && Field->isMutable();
10297  visitSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable));
10298 }
10299 
10300 void SpecialMemberExceptionSpecInfo::visitSubobjectCall(
10301  Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR) {
10302  // Note, if lookup fails, it doesn't matter what exception specification we
10303  // choose because the special member will be deleted.
10304  if (CXXMethodDecl *MD = SMOR.getMethod())
10305  ExceptSpec.CalledDecl(getSubobjectLoc(Subobj), MD);
10306 }
10307 
10312  CXXRecordDecl *ClassDecl = MD->getParent();
10313 
10314  // C++ [except.spec]p14:
10315  // An implicitly declared special member function (Clause 12) shall have an
10316  // exception-specification. [...]
10317  SpecialMemberExceptionSpecInfo Info(S, MD, CSM, ICI, Loc);
10318  if (ClassDecl->isInvalidDecl())
10319  return Info.ExceptSpec;
10320 
10321  // C++1z [except.spec]p7:
10322  // [Look for exceptions thrown by] a constructor selected [...] to
10323  // initialize a potentially constructed subobject,
10324  // C++1z [except.spec]p8:
10325  // The exception specification for an implicitly-declared destructor, or a
10326  // destructor without a noexcept-specifier, is potentially-throwing if and
10327  // only if any of the destructors for any of its potentially constructed
10328  // subojects is potentially throwing.
10329  // FIXME: We respect the first rule but ignore the "potentially constructed"
10330  // in the second rule to resolve a core issue (no number yet) that would have
10331  // us reject:
10332  // struct A { virtual void f() = 0; virtual ~A() noexcept(false) = 0; };
10333  // struct B : A {};
10334  // struct C : B { void f(); };
10335  // ... due to giving B::~B() a non-throwing exception specification.
10336  Info.visit(Info.IsConstructor ? Info.VisitPotentiallyConstructedBases
10337  : Info.VisitAllBases);
10338 
10339  return Info.ExceptSpec;
10340 }
10341 
10342 namespace {
10343 /// RAII object to register a special member as being currently declared.
10344 struct DeclaringSpecialMember {
10345  Sema &S;
10347  Sema::ContextRAII SavedContext;
10348  bool WasAlreadyBeingDeclared;
10349 
10350  DeclaringSpecialMember(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM)
10351  : S(S), D(RD, CSM), SavedContext(S, RD) {
10352  WasAlreadyBeingDeclared = !S.SpecialMembersBeingDeclared.insert(D).second;
10353  if (WasAlreadyBeingDeclared)
10354  // This almost never happens, but if it does, ensure that our cache
10355  // doesn't contain a stale result.
10356  S.SpecialMemberCache.clear();
10357  else {
10358  // Register a note to be produced if we encounter an error while
10359  // declaring the special member.
10362  // FIXME: We don't have a location to use here. Using the class's
10363  // location maintains the fiction that we declare all special members
10364  // with the class, but (1) it's not clear that lying about that helps our
10365  // users understand what's going on, and (2) there may be outer contexts
10366  // on the stack (some of which are relevant) and printing them exposes
10367  // our lies.
10368  Ctx.PointOfInstantiation = RD->getLocation();
10369  Ctx.Entity = RD;
10370  Ctx.SpecialMember = CSM;
10371  S.pushCodeSynthesisContext(Ctx);
10372  }
10373  }
10374  ~DeclaringSpecialMember() {
10375  if (!WasAlreadyBeingDeclared) {
10376  S.SpecialMembersBeingDeclared.erase(D);
10378  }
10379  }
10380 
10381  /// \brief Are we already trying to declare this special member?
10382  bool isAlreadyBeingDeclared() const {
10383  return WasAlreadyBeingDeclared;
10384  }
10385 };
10386 }
10387 
10389  // Look up any existing declarations, but don't trigger declaration of all
10390  // implicit special members with this name.
10391  DeclarationName Name = FD->getDeclName();
10392  LookupResult R(*this, Name, SourceLocation(), LookupOrdinaryName,
10393  ForExternalRedeclaration);
10394  for (auto *D : FD->getParent()->lookup(Name))
10395  if (auto *Acceptable = R.getAcceptableDecl(D))
10396  R.addDecl(Acceptable);
10397  R.resolveKind();
10398  R.suppressDiagnostics();
10399 
10400  CheckFunctionDeclaration(S, FD, R, /*IsMemberSpecialization*/false);
10401 }
10402 
10404  CXXRecordDecl *ClassDecl) {
10405  // C++ [class.ctor]p5:
10406  // A default constructor for a class X is a constructor of class X
10407  // that can be called without an argument. If there is no
10408  // user-declared constructor for class X, a default constructor is
10409  // implicitly declared. An implicitly-declared default constructor
10410  // is an inline public member of its class.
10411  assert(ClassDecl->needsImplicitDefaultConstructor() &&
10412  "Should not build implicit default constructor!");
10413 
10414  DeclaringSpecialMember DSM(*this, ClassDecl, CXXDefaultConstructor);
10415  if (DSM.isAlreadyBeingDeclared())
10416  return nullptr;
10417 
10418  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
10419  CXXDefaultConstructor,
10420  false);
10421 
10422  // Create the actual constructor declaration.
10423  CanQualType ClassType
10424  = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
10425  SourceLocation ClassLoc = ClassDecl->getLocation();
10426  DeclarationName Name
10427  = Context.DeclarationNames.getCXXConstructorName(ClassType);
10428  DeclarationNameInfo NameInfo(Name, ClassLoc);
10430  Context, ClassDecl, ClassLoc, NameInfo, /*Type*/QualType(),
10431  /*TInfo=*/nullptr, /*isExplicit=*/false, /*isInline=*/true,
10432  /*isImplicitlyDeclared=*/true, Constexpr);
10433  DefaultCon->setAccess(AS_public);
10434  DefaultCon->setDefaulted();
10435 
10436  if (getLangOpts().CUDA) {
10437  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDefaultConstructor,
10438  DefaultCon,
10439  /* ConstRHS */ false,
10440  /* Diagnose */ false);
10441  }
10442 
10443  // Build an exception specification pointing back at this constructor.
10444  FunctionProtoType::ExtProtoInfo EPI = getImplicitMethodEPI(*this, DefaultCon);
10445  DefaultCon->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
10446 
10447  // We don't need to use SpecialMemberIsTrivial here; triviality for default
10448  // constructors is easy to compute.
10449  DefaultCon->setTrivial(ClassDecl->hasTrivialDefaultConstructor());
10450 
10451  // Note that we have declared this constructor.
10453 
10454  Scope *S = getScopeForContext(ClassDecl);
10455  CheckImplicitSpecialMemberDeclaration(S, DefaultCon);
10456 
10457  if (ShouldDeleteSpecialMember(DefaultCon, CXXDefaultConstructor))
10458  SetDeclDeleted(DefaultCon, ClassLoc);
10459 
10460  if (S)
10461  PushOnScopeChains(DefaultCon, S, false);
10462  ClassDecl->addDecl(DefaultCon);
10463 
10464  return DefaultCon;
10465 }
10466 
10468  CXXConstructorDecl *Constructor) {
10469  assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
10470  !Constructor->doesThisDeclarationHaveABody() &&
10471  !Constructor->isDeleted()) &&
10472  "DefineImplicitDefaultConstructor - call it for implicit default ctor");
10473  if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
10474  return;
10475 
10476  CXXRecordDecl *ClassDecl = Constructor->getParent();
10477  assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
10478 
10479  SynthesizedFunctionScope Scope(*this, Constructor);
10480 
10481  // The exception specification is needed because we are defining the
10482  // function.
10483  ResolveExceptionSpec(CurrentLocation,
10484  Constructor->getType()->castAs<FunctionProtoType>());
10485  MarkVTableUsed(CurrentLocation, ClassDecl);
10486 
10487  // Add a context note for diagnostics produced after this point.
10488  Scope.addContextNote(CurrentLocation);
10489 
10490  if (SetCtorInitializers(Constructor, /*AnyErrors=*/false)) {
10491  Constructor->setInvalidDecl();
10492  return;
10493  }
10494 
10495  SourceLocation Loc = Constructor->getLocEnd().isValid()
10496  ? Constructor->getLocEnd()
10497  : Constructor->getLocation();
10498  Constructor->setBody(new (Context) CompoundStmt(Loc));
10499  Constructor->markUsed(Context);
10500 
10501  if (ASTMutationListener *L = getASTMutationListener()) {
10502  L->CompletedImplicitDefinition(Constructor);
10503  }
10504 
10505  DiagnoseUninitializedFields(*this, Constructor);
10506 }
10507 
10509  // Perform any delayed checks on exception specifications.
10510  CheckDelayedMemberExceptionSpecs();
10511 }
10512 
10513 /// Find or create the fake constructor we synthesize to model constructing an
10514 /// object of a derived class via a constructor of a base class.
10517  CXXConstructorDecl *BaseCtor,
10518  ConstructorUsingShadowDecl *Shadow) {
10519  CXXRecordDecl *Derived = Shadow->getParent();
10520  SourceLocation UsingLoc = Shadow->getLocation();
10521 
10522  // FIXME: Add a new kind of DeclarationName for an inherited constructor.
10523  // For now we use the name of the base class constructor as a member of the
10524  // derived class to indicate a (fake) inherited constructor name.
10525  DeclarationName Name = BaseCtor->getDeclName();
10526 
10527  // Check to see if we already have a fake constructor for this inherited
10528  // constructor call.
10529  for (NamedDecl *Ctor : Derived->lookup(Name))
10530  if (declaresSameEntity(cast<CXXConstructorDecl>(Ctor)
10531  ->getInheritedConstructor()
10532  .getConstructor(),
10533  BaseCtor))
10534  return cast<CXXConstructorDecl>(Ctor);
10535 
10536  DeclarationNameInfo NameInfo(Name, UsingLoc);
10537  TypeSourceInfo *TInfo =
10538  Context.getTrivialTypeSourceInfo(BaseCtor->getType(), UsingLoc);
10539  FunctionProtoTypeLoc ProtoLoc =
10541 
10542  // Check the inherited constructor is valid and find the list of base classes
10543  // from which it was inherited.
10544  InheritedConstructorInfo ICI(*this, Loc, Shadow);
10545 
10546  bool Constexpr =
10547  BaseCtor->isConstexpr() &&
10548  defaultedSpecialMemberIsConstexpr(*this, Derived, CXXDefaultConstructor,
10549  false, BaseCtor, &ICI);
10550 
10552  Context, Derived, UsingLoc, NameInfo, TInfo->getType(), TInfo,
10553  BaseCtor->isExplicit(), /*Inline=*/true,
10554  /*ImplicitlyDeclared=*/true, Constexpr,
10555  InheritedConstructor(Shadow, BaseCtor));
10556  if (Shadow->isInvalidDecl())
10557  DerivedCtor->setInvalidDecl();
10558 
10559  // Build an unevaluated exception specification for this fake constructor.
10560  const FunctionProtoType *FPT = TInfo->getType()->castAs<FunctionProtoType>();
10563  EPI.ExceptionSpec.SourceDecl = DerivedCtor;
10564  DerivedCtor->setType(Context.getFunctionType(FPT->getReturnType(),
10565  FPT->getParamTypes(), EPI));
10566 
10567  // Build the parameter declarations.
10568  SmallVector<ParmVarDecl *, 16> ParamDecls;
10569  for (unsigned I = 0, N = FPT->getNumParams(); I != N; ++I) {
10570  TypeSourceInfo *TInfo =
10571  Context.getTrivialTypeSourceInfo(FPT->getParamType(I), UsingLoc);
10573  Context, DerivedCtor, UsingLoc, UsingLoc, /*IdentifierInfo=*/nullptr,
10574  FPT->getParamType(I), TInfo, SC_None, /*DefaultArg=*/nullptr);
10575  PD->setScopeInfo(0, I);
10576  PD->setImplicit();
10577  // Ensure attributes are propagated onto parameters (this matters for
10578  // format, pass_object_size, ...).
10579  mergeDeclAttributes(PD, BaseCtor->getParamDecl(I));
10580  ParamDecls.push_back(PD);
10581  ProtoLoc.setParam(I, PD);
10582  }
10583 
10584  // Set up the new constructor.
10585  assert(!BaseCtor->isDeleted() && "should not use deleted constructor");
10586  DerivedCtor->setAccess(BaseCtor->getAccess());
10587  DerivedCtor->setParams(ParamDecls);
10588  Derived->addDecl(DerivedCtor);
10589 
10590  if (ShouldDeleteSpecialMember(DerivedCtor, CXXDefaultConstructor, &ICI))
10591  SetDeclDeleted(DerivedCtor, UsingLoc);
10592 
10593  return DerivedCtor;
10594 }
10595 
10597  InheritedConstructorInfo ICI(*this, Ctor->getLocation(),
10599  ShouldDeleteSpecialMember(Ctor, CXXDefaultConstructor, &ICI,
10600  /*Diagnose*/true);
10601 }
10602 
10604  CXXConstructorDecl *Constructor) {
10605  CXXRecordDecl *ClassDecl = Constructor->getParent();
10606  assert(Constructor->getInheritedConstructor() &&
10607  !Constructor->doesThisDeclarationHaveABody() &&
10608  !Constructor->isDeleted());
10609  if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
10610  return;
10611 
10612  // Initializations are performed "as if by a defaulted default constructor",
10613  // so enter the appropriate scope.
10614  SynthesizedFunctionScope Scope(*this, Constructor);
10615 
10616  // The exception specification is needed because we are defining the
10617  // function.
10618  ResolveExceptionSpec(CurrentLocation,
10619  Constructor->getType()->castAs<FunctionProtoType>());
10620  MarkVTableUsed(CurrentLocation, ClassDecl);
10621 
10622  // Add a context note for diagnostics produced after this point.
10623  Scope.addContextNote(CurrentLocation);
10624 
10625  ConstructorUsingShadowDecl *Shadow =
10626  Constructor->getInheritedConstructor().getShadowDecl();
10627  CXXConstructorDecl *InheritedCtor =
10628  Constructor->getInheritedConstructor().getConstructor();
10629 
10630  // [class.inhctor.init]p1:
10631  // initialization proceeds as if a defaulted default constructor is used to
10632  // initialize the D object and each base class subobject from which the
10633  // constructor was inherited
10634 
10635  InheritedConstructorInfo ICI(*this, CurrentLocation, Shadow);
10636  CXXRecordDecl *RD = Shadow->getParent();
10637  SourceLocation InitLoc = Shadow->getLocation();
10638 
10639  // Build explicit initializers for all base classes from which the
10640  // constructor was inherited.
10642  for (bool VBase : {false, true}) {
10643  for (CXXBaseSpecifier &B : VBase ? RD->vbases() : RD->bases()) {
10644  if (B.isVirtual() != VBase)
10645  continue;
10646 
10647  auto *BaseRD = B.getType()->getAsCXXRecordDecl();
10648  if (!BaseRD)
10649  continue;
10650 
10651  auto BaseCtor = ICI.findConstructorForBase(BaseRD, InheritedCtor);
10652  if (!BaseCtor.first)
10653  continue;
10654 
10655  MarkFunctionReferenced(CurrentLocation, BaseCtor.first);
10656  ExprResult Init = new (Context) CXXInheritedCtorInitExpr(
10657  InitLoc, B.getType(), BaseCtor.first, VBase, BaseCtor.second);
10658 
10659  auto *TInfo = Context.getTrivialTypeSourceInfo(B.getType(), InitLoc);
10660  Inits.push_back(new (Context) CXXCtorInitializer(
10661  Context, TInfo, VBase, InitLoc, Init.get(), InitLoc,
10662  SourceLocation()));
10663  }
10664  }
10665 
10666  // We now proceed as if for a defaulted default constructor, with the relevant
10667  // initializers replaced.
10668 
10669  if (SetCtorInitializers(Constructor, /*AnyErrors*/false, Inits)) {
10670  Constructor->setInvalidDecl();
10671  return;
10672  }
10673 
10674  Constructor->setBody(new (Context) CompoundStmt(InitLoc));
10675  Constructor->markUsed(Context);
10676 
10677  if (ASTMutationListener *L = getASTMutationListener()) {
10678  L->CompletedImplicitDefinition(Constructor);
10679  }
10680 
10681  DiagnoseUninitializedFields(*this, Constructor);
10682 }
10683 
10685  // C++ [class.dtor]p2:
10686  // If a class has no user-declared destructor, a destructor is
10687  // declared implicitly. An implicitly-declared destructor is an
10688  // inline public member of its class.
10689  assert(ClassDecl->needsImplicitDestructor());
10690 
10691  DeclaringSpecialMember DSM(*this, ClassDecl, CXXDestructor);
10692  if (DSM.isAlreadyBeingDeclared())
10693  return nullptr;
10694 
10695  // Create the actual destructor declaration.
10696  CanQualType ClassType
10697  = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
10698  SourceLocation ClassLoc = ClassDecl->getLocation();
10699  DeclarationName Name
10700  = Context.DeclarationNames.getCXXDestructorName(ClassType);
10701  DeclarationNameInfo NameInfo(Name, ClassLoc);
10702  CXXDestructorDecl *Destructor
10703  = CXXDestructorDecl::Create(Context, ClassDecl, ClassLoc, NameInfo,
10704  QualType(), nullptr, /*isInline=*/true,
10705  /*isImplicitlyDeclared=*/true);
10706  Destructor->setAccess(AS_public);
10707  Destructor->setDefaulted();
10708 
10709  if (getLangOpts().CUDA) {
10710  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDestructor,
10711  Destructor,
10712  /* ConstRHS */ false,
10713  /* Diagnose */ false);
10714  }
10715 
10716  // Build an exception specification pointing back at this destructor.
10717  FunctionProtoType::ExtProtoInfo EPI = getImplicitMethodEPI(*this, Destructor);
10718  Destructor->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
10719 
10720  // We don't need to use SpecialMemberIsTrivial here; triviality for
10721  // destructors is easy to compute.
10722  Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
10723 
10724  // Note that we have declared this destructor.
10726 
10727  Scope *S = getScopeForContext(ClassDecl);
10728  CheckImplicitSpecialMemberDeclaration(S, Destructor);
10729 
10730  // We can't check whether an implicit destructor is deleted before we complete
10731  // the definition of the class, because its validity depends on the alignment
10732  // of the class. We'll check this from ActOnFields once the class is complete.
10733  if (ClassDecl->isCompleteDefinition() &&
10734  ShouldDeleteSpecialMember(Destructor, CXXDestructor))
10735  SetDeclDeleted(Destructor, ClassLoc);
10736 
10737  // Introduce this destructor into its scope.
10738  if (S)
10739  PushOnScopeChains(Destructor, S, false);
10740  ClassDecl->addDecl(Destructor);
10741 
10742  return Destructor;
10743 }
10744 
10746  CXXDestructorDecl *Destructor) {
10747  assert((Destructor->isDefaulted() &&
10748  !Destructor->doesThisDeclarationHaveABody() &&
10749  !Destructor->isDeleted()) &&
10750  "DefineImplicitDestructor - call it for implicit default dtor");
10751  if (Destructor->willHaveBody() || Destructor->isInvalidDecl())
10752  return;
10753 
10754  CXXRecordDecl *ClassDecl = Destructor->getParent();
10755  assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
10756 
10757  SynthesizedFunctionScope Scope(*this, Destructor);
10758 
10759  // The exception specification is needed because we are defining the
10760  // function.
10761  ResolveExceptionSpec(CurrentLocation,
10762  Destructor->getType()->castAs<FunctionProtoType>());
10763  MarkVTableUsed(CurrentLocation, ClassDecl);
10764 
10765  // Add a context note for diagnostics produced after this point.
10766  Scope.addContextNote(CurrentLocation);
10767 
10768  MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
10769  Destructor->getParent());
10770 
10771  if (CheckDestructor(Destructor)) {
10772  Destructor->setInvalidDecl();
10773  return;
10774  }
10775 
10776  SourceLocation Loc = Destructor->getLocEnd().isValid()
10777  ? Destructor->getLocEnd()
10778  : Destructor->getLocation();
10779  Destructor->setBody(new (Context) CompoundStmt(Loc));
10780  Destructor->markUsed(Context);
10781 
10782  if (ASTMutationListener *L = getASTMutationListener()) {
10783  L->CompletedImplicitDefinition(Destructor);
10784  }
10785 }
10786 
10787 /// \brief Perform any semantic analysis which needs to be delayed until all
10788 /// pending class member declarations have been parsed.
10790  // If the context is an invalid C++ class, just suppress these checks.
10791  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(CurContext)) {
10792  if (Record->isInvalidDecl()) {
10793  DelayedDefaultedMemberExceptionSpecs.clear();
10794  DelayedExceptionSpecChecks.clear();
10795  return;
10796  }
10798  }
10799 }
10800 
10802  referenceDLLExportedClassMethods();
10803 }
10804 
10806  if (!DelayedDllExportClasses.empty()) {
10807  // Calling ReferenceDllExportedMethods might cause the current function to
10808  // be called again, so use a local copy of DelayedDllExportClasses.
10810  std::swap(DelayedDllExportClasses, WorkList);
10811  for (CXXRecordDecl *Class : WorkList)
10812  ReferenceDllExportedMethods(*this, Class);
10813  }
10814 }
10815 
10817  CXXDestructorDecl *Destructor) {
10818  assert(getLangOpts().CPlusPlus11 &&
10819  "adjusting dtor exception specs was introduced in c++11");
10820 
10821  // C++11 [class.dtor]p3:
10822  // A declaration of a destructor that does not have an exception-
10823  // specification is implicitly considered to have the same exception-
10824  // specification as an implicit declaration.
10825  const FunctionProtoType *DtorType = Destructor->getType()->
10826  getAs<FunctionProtoType>();
10827  if (DtorType->hasExceptionSpec())
10828  return;
10829 
10830  // Replace the destructor's type, building off the existing one. Fortunately,
10831  // the only thing of interest in the destructor type is its extended info.
10832  // The return and arguments are fixed.
10835  EPI.ExceptionSpec.SourceDecl = Destructor;
10836  Destructor->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
10837 
10838  // FIXME: If the destructor has a body that could throw, and the newly created
10839  // spec doesn't allow exceptions, we should emit a warning, because this
10840  // change in behavior can break conforming C++03 programs at runtime.
10841  // However, we don't have a body or an exception specification yet, so it
10842  // needs to be done somewhere else.
10843 }
10844 
10845 namespace {
10846 /// \brief An abstract base class for all helper classes used in building the
10847 // copy/move operators. These classes serve as factory functions and help us
10848 // avoid using the same Expr* in the AST twice.
10849 class ExprBuilder {
10850  ExprBuilder(const ExprBuilder&) = delete;
10851  ExprBuilder &operator=(const ExprBuilder&) = delete;
10852 
10853 protected:
10854  static Expr *assertNotNull(Expr *E) {
10855  assert(E && "Expression construction must not fail.");
10856  return E;
10857  }
10858 
10859 public:
10860  ExprBuilder() {}
10861  virtual ~ExprBuilder() {}
10862 
10863  virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
10864 };
10865 
10866 class RefBuilder: public ExprBuilder {
10867  VarDecl *Var;
10868  QualType VarType;
10869 
10870 public:
10871  Expr *build(Sema &S, SourceLocation Loc) const override {
10872  return assertNotNull(S.BuildDeclRefExpr(Var, VarType, VK_LValue, Loc).get());
10873  }
10874 
10875  RefBuilder(VarDecl *Var, QualType VarType)
10876  : Var(Var), VarType(VarType) {}
10877 };
10878 
10879 class ThisBuilder: public ExprBuilder {
10880 public:
10881  Expr *build(Sema &S, SourceLocation Loc) const override {
10882  return assertNotNull(S.ActOnCXXThis(Loc).getAs<Expr>());
10883  }
10884 };
10885 
10886 class CastBuilder: public ExprBuilder {
10887  const ExprBuilder &Builder;
10888  QualType Type;
10890  const CXXCastPath &Path;
10891 
10892 public:
10893  Expr *build(Sema &S, SourceLocation Loc) const override {
10894  return assertNotNull(S.ImpCastExprToType(Builder.build(S, Loc), Type,
10895  CK_UncheckedDerivedToBase, Kind,
10896  &Path).get());
10897  }
10898 
10899  CastBuilder(const ExprBuilder &Builder, QualType Type, ExprValueKind Kind,
10900  const CXXCastPath &Path)
10901  : Builder(Builder), Type(Type), Kind(Kind), Path(Path) {}
10902 };
10903 
10904 class DerefBuilder: public ExprBuilder {
10905  const ExprBuilder &Builder;
10906 
10907 public:
10908  Expr *build(Sema &S, SourceLocation Loc) const override {
10909  return assertNotNull(
10910  S.CreateBuiltinUnaryOp(Loc, UO_Deref, Builder.build(S, Loc)).get());
10911  }
10912 
10913  DerefBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
10914 };
10915 
10916 class MemberBuilder: public ExprBuilder {
10917  const ExprBuilder &Builder;
10918  QualType Type;
10919  CXXScopeSpec SS;
10920  bool IsArrow;
10921  LookupResult &MemberLookup;
10922 
10923 public:
10924  Expr *build(Sema &S, SourceLocation Loc) const override {
10925  return assertNotNull(S.BuildMemberReferenceExpr(
10926  Builder.build(S, Loc), Type, Loc, IsArrow, SS, SourceLocation(),
10927  nullptr, MemberLookup, nullptr, nullptr).get());
10928  }
10929 
10930  MemberBuilder(const ExprBuilder &Builder, QualType Type, bool IsArrow,
10931  LookupResult &MemberLookup)
10932  : Builder(Builder), Type(Type), IsArrow(IsArrow),
10933  MemberLookup(MemberLookup) {}
10934 };
10935 
10936 class MoveCastBuilder: public ExprBuilder {
10937  const ExprBuilder &Builder;
10938 
10939 public:
10940  Expr *build(Sema &S, SourceLocation Loc) const override {
10941  return assertNotNull(CastForMoving(S, Builder.build(S, Loc)));
10942  }
10943 
10944  MoveCastBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
10945 };
10946 
10947 class LvalueConvBuilder: public ExprBuilder {
10948  const ExprBuilder &Builder;
10949 
10950 public:
10951  Expr *build(Sema &S, SourceLocation Loc) const override {
10952  return assertNotNull(
10953  S.DefaultLvalueConversion(Builder.build(S, Loc)).get());
10954  }
10955 
10956  LvalueConvBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
10957 };
10958 
10959 class SubscriptBuilder: public ExprBuilder {
10960  const ExprBuilder &Base;
10961  const ExprBuilder &Index;
10962 
10963 public:
10964  Expr *build(Sema &S, SourceLocation Loc) const override {
10965  return assertNotNull(S.CreateBuiltinArraySubscriptExpr(
10966  Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).get());
10967  }
10968 
10969  SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index)
10970  : Base(Base), Index(Index) {}
10971 };
10972 
10973 } // end anonymous namespace
10974 
10975 /// When generating a defaulted copy or move assignment operator, if a field
10976 /// should be copied with __builtin_memcpy rather than via explicit assignments,
10977 /// do so. This optimization only applies for arrays of scalars, and for arrays
10978 /// of class type where the selected copy/move-assignment operator is trivial.
10979 static StmtResult
10981  const ExprBuilder &ToB, const ExprBuilder &FromB) {
10982  // Compute the size of the memory buffer to be copied.
10983  QualType SizeType = S.Context.getSizeType();
10984  llvm::APInt Size(S.Context.getTypeSize(SizeType),
10986 
10987  // Take the address of the field references for "from" and "to". We
10988  // directly construct UnaryOperators here because semantic analysis
10989  // does not permit us to take the address of an xvalue.
10990  Expr *From = FromB.build(S, Loc);
10991  From = new (S.Context) UnaryOperator(From, UO_AddrOf,
10992  S.Context.getPointerType(From->getType()),
10993  VK_RValue, OK_Ordinary, Loc);
10994  Expr *To = ToB.build(S, Loc);
10995  To = new (S.Context) UnaryOperator(To, UO_AddrOf,
10996  S.Context.getPointerType(To->getType()),
10997  VK_RValue, OK_Ordinary, Loc);
10998 
10999  const Type *E = T->getBaseElementTypeUnsafe();
11000  bool NeedsCollectableMemCpy =
11001  E->isRecordType() && E->getAs<RecordType>()->getDecl()->hasObjectMember();
11002 
11003  // Create a reference to the __builtin_objc_memmove_collectable function
11004  StringRef MemCpyName = NeedsCollectableMemCpy ?
11005  "__builtin_objc_memmove_collectable" :
11006  "__builtin_memcpy";
11007  LookupResult R(S, &S.Context.Idents.get(MemCpyName), Loc,
11009  S.LookupName(R, S.TUScope, true);
11010 
11011  FunctionDecl *MemCpy = R.getAsSingle<FunctionDecl>();
11012  if (!MemCpy)
11013  // Something went horribly wrong earlier, and we will have complained
11014  // about it.
11015  return StmtError();
11016 
11017  ExprResult MemCpyRef = S.BuildDeclRefExpr(MemCpy, S.Context.BuiltinFnTy,
11018  VK_RValue, Loc, nullptr);
11019  assert(MemCpyRef.isUsable() && "Builtin reference cannot fail");
11020 
11021  Expr *CallArgs[] = {
11022  To, From, IntegerLiteral::Create(S.Context, Size, SizeType, Loc)
11023  };
11024  ExprResult Call = S.ActOnCallExpr(/*Scope=*/nullptr, MemCpyRef.get(),
11025  Loc, CallArgs, Loc);
11026 
11027  assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!");
11028  return Call.getAs<Stmt>();
11029 }
11030 
11031 /// \brief Builds a statement that copies/moves the given entity from \p From to
11032 /// \c To.
11033 ///
11034 /// This routine is used to copy/move the members of a class with an
11035 /// implicitly-declared copy/move assignment operator. When the entities being
11036 /// copied are arrays, this routine builds for loops to copy them.
11037 ///
11038 /// \param S The Sema object used for type-checking.
11039 ///
11040 /// \param Loc The location where the implicit copy/move is being generated.
11041 ///
11042 /// \param T The type of the expressions being copied/moved. Both expressions
11043 /// must have this type.
11044 ///
11045 /// \param To The expression we are copying/moving to.
11046 ///
11047 /// \param From The expression we are copying/moving from.
11048 ///
11049 /// \param CopyingBaseSubobject Whether we're copying/moving a base subobject.
11050 /// Otherwise, it's a non-static member subobject.
11051 ///
11052 /// \param Copying Whether we're copying or moving.
11053 ///
11054 /// \param Depth Internal parameter recording the depth of the recursion.
11055 ///
11056 /// \returns A statement or a loop that copies the expressions, or StmtResult(0)
11057 /// if a memcpy should be used instead.
11058 static StmtResult
11060  const ExprBuilder &To, const ExprBuilder &From,
11061  bool CopyingBaseSubobject, bool Copying,
11062  unsigned Depth = 0) {
11063  // C++11 [class.copy]p28:
11064  // Each subobject is assigned in the manner appropriate to its type:
11065  //
11066  // - if the subobject is of class type, as if by a call to operator= with
11067  // the subobject as the object expression and the corresponding
11068  // subobject of x as a single function argument (as if by explicit
11069  // qualification; that is, ignoring any possible virtual overriding
11070  // functions in more derived classes);
11071  //
11072  // C++03 [class.copy]p13:
11073  // - if the subobject is of class type, the copy assignment operator for
11074  // the class is used (as if by explicit qualification; that is,
11075  // ignoring any possible virtual overriding functions in more derived
11076  // classes);
11077  if (const RecordType *RecordTy = T->getAs<RecordType>()) {
11078  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
11079 
11080  // Look for operator=.
11081  DeclarationName Name
11083  LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName);
11084  S.LookupQualifiedName(OpLookup, ClassDecl, false);
11085 
11086  // Prior to C++11, filter out any result that isn't a copy/move-assignment
11087  // operator.
11088  if (!S.getLangOpts().CPlusPlus11) {
11089  LookupResult::Filter F = OpLookup.makeFilter();
11090  while (F.hasNext()) {
11091  NamedDecl *D = F.next();
11092  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
11093  if (Method->isCopyAssignmentOperator() ||
11094  (!Copying && Method->isMoveAssignmentOperator()))
11095  continue;
11096 
11097  F.erase();
11098  }
11099  F.done();
11100  }
11101 
11102  // Suppress the protected check (C++ [class.protected]) for each of the
11103  // assignment operators we found. This strange dance is required when
11104  // we're assigning via a base classes's copy-assignment operator. To
11105  // ensure that we're getting the right base class subobject (without
11106  // ambiguities), we need to cast "this" to that subobject type; to
11107  // ensure that we don't go through the virtual call mechanism, we need
11108  // to qualify the operator= name with the base class (see below). However,
11109  // this means that if the base class has a protected copy assignment
11110  // operator, the protected member access check will fail. So, we
11111  // rewrite "protected" access to "public" access in this case, since we
11112  // know by construction that we're calling from a derived class.
11113  if (CopyingBaseSubobject) {
11114  for (LookupResult::iterator L = OpLookup.begin(), LEnd = OpLookup.end();
11115  L != LEnd; ++L) {
11116  if (L.getAccess() == AS_protected)
11117  L.setAccess(AS_public);
11118  }
11119  }
11120 
11121  // Create the nested-name-specifier that will be used to qualify the
11122  // reference to operator=; this is required to suppress the virtual
11123  // call mechanism.
11124  CXXScopeSpec SS;
11125  const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
11126  SS.MakeTrivial(S.Context,
11127  NestedNameSpecifier::Create(S.Context, nullptr, false,
11128  CanonicalT),
11129  Loc);
11130 
11131  // Create the reference to operator=.
11132  ExprResult OpEqualRef
11133  = S.BuildMemberReferenceExpr(To.build(S, Loc), T, Loc, /*isArrow=*/false,
11134  SS, /*TemplateKWLoc=*/SourceLocation(),
11135  /*FirstQualifierInScope=*/nullptr,
11136  OpLookup,
11137  /*TemplateArgs=*/nullptr, /*S*/nullptr,
11138  /*SuppressQualifierCheck=*/true);
11139  if (OpEqualRef.isInvalid())
11140  return StmtError();
11141 
11142  // Build the call to the assignment operator.
11143 
11144  Expr *FromInst = From.build(S, Loc);
11145  ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/nullptr,
11146  OpEqualRef.getAs<Expr>(),
11147  Loc, FromInst, Loc);
11148  if (Call.isInvalid())
11149  return StmtError();
11150 
11151  // If we built a call to a trivial 'operator=' while copying an array,
11152  // bail out. We'll replace the whole shebang with a memcpy.
11153  CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(Call.get());
11154  if (CE && CE->getMethodDecl()->isTrivial() && Depth)
11155  return StmtResult((Stmt*)nullptr);
11156 
11157  // Convert to an expression-statement, and clean up any produced
11158  // temporaries.
11159  return S.ActOnExprStmt(Call);
11160  }
11161 
11162  // - if the subobject is of scalar type, the built-in assignment
11163  // operator is used.
11164  const ConstantArrayType *ArrayTy = S.Context.getAsConstantArrayType(T);
11165  if (!ArrayTy) {
11167  Loc, BO_Assign, To.build(S, Loc), From.build(S, Loc));
11168  if (Assignment.isInvalid())
11169  return StmtError();
11170  return S.ActOnExprStmt(Assignment);
11171  }
11172 
11173  // - if the subobject is an array, each element is assigned, in the
11174  // manner appropriate to the element type;
11175 
11176  // Construct a loop over the array bounds, e.g.,
11177  //
11178  // for (__SIZE_TYPE__ i0 = 0; i0 != array-size; ++i0)
11179  //
11180  // that will copy each of the array elements.
11181  QualType SizeType = S.Context.getSizeType();
11182 
11183  // Create the iteration variable.
11184  IdentifierInfo *IterationVarName = nullptr;
11185  {
11186  SmallString<8> Str;
11187  llvm::raw_svector_ostream OS(Str);
11188  OS << "__i" << Depth;
11189  IterationVarName = &S.Context.Idents.get(OS.str());
11190  }
11191  VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
11192  IterationVarName, SizeType,
11193  S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
11194  SC_None);
11195 
11196  // Initialize the iteration variable to zero.
11197  llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
11198  IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
11199 
11200  // Creates a reference to the iteration variable.
11201  RefBuilder IterationVarRef(IterationVar, SizeType);
11202  LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
11203 
11204  // Create the DeclStmt that holds the iteration variable.
11205  Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);
11206 
11207  // Subscript the "from" and "to" expressions with the iteration variable.
11208  SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
11209  MoveCastBuilder FromIndexMove(FromIndexCopy);
11210  const ExprBuilder *FromIndex;
11211  if (Copying)
11212  FromIndex = &FromIndexCopy;
11213  else
11214  FromIndex = &FromIndexMove;
11215 
11216  SubscriptBuilder ToIndex(To, IterationVarRefRVal);
11217 
11218  // Build the copy/move for an individual element of the array.
11219  StmtResult Copy =
11221  ToIndex, *FromIndex, CopyingBaseSubobject,
11222  Copying, Depth + 1);
11223  // Bail out if copying fails or if we determined that we should use memcpy.
11224  if (Copy.isInvalid() || !Copy.get())
11225  return Copy;
11226 
11227  // Create the comparison against the array bound.
11228  llvm::APInt Upper
11229  = ArrayTy->getSize().zextOrTrunc(S.Context.getTypeSize(SizeType));
11230  Expr *Comparison
11231  = new (S.Context) BinaryOperator(IterationVarRefRVal.build(S, Loc),
11232  IntegerLiteral::Create(S.Context, Upper, SizeType, Loc),
11233  BO_NE, S.Context.BoolTy,
11234  VK_RValue, OK_Ordinary, Loc, FPOptions());
11235 
11236  // Create the pre-increment of the iteration variable.
11237  Expr *Increment
11238  = new (S.Context) UnaryOperator(IterationVarRef.build(S, Loc), UO_PreInc,
11239  SizeType, VK_LValue, OK_Ordinary, Loc);
11240 
11241  // Construct the loop that copies all elements of this array.
11242  return S.ActOnForStmt(
11243  Loc, Loc, InitStmt,
11244  S.ActOnCondition(nullptr, Loc, Comparison, Sema::ConditionKind::Boolean),
11245  S.MakeFullDiscardedValueExpr(Increment), Loc, Copy.get());
11246 }
11247 
11248 static StmtResult
11250  const ExprBuilder &To, const ExprBuilder &From,
11251  bool CopyingBaseSubobject, bool Copying) {
11252  // Maybe we should use a memcpy?
11253  if (T->isArrayType() && !T.isConstQualified() && !T.isVolatileQualified() &&
11255  return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
11256 
11258  CopyingBaseSubobject,
11259  Copying, 0));
11260 
11261  // If we ended up picking a trivial assignment operator for an array of a
11262  // non-trivially-copyable class type, just emit a memcpy.
11263  if (!Result.isInvalid() && !Result.get())
11264  return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
11265 
11266  return Result;
11267 }
11268 
11270  // Note: The following rules are largely analoguous to the copy
11271  // constructor rules. Note that virtual bases are not taken into account
11272  // for determining the argument type of the operator. Note also that
11273  // operators taking an object instead of a reference are allowed.
11274  assert(ClassDecl->needsImplicitCopyAssignment());
11275 
11276  DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyAssignment);
11277  if (DSM.isAlreadyBeingDeclared())
11278  return nullptr;
11279 
11280  QualType ArgType = Context.getTypeDeclType(ClassDecl);
11281  QualType RetType = Context.getLValueReferenceType(ArgType);
11282  bool Const = ClassDecl->implicitCopyAssignmentHasConstParam();
11283  if (Const)
11284  ArgType = ArgType.withConst();
11285  ArgType = Context.getLValueReferenceType(ArgType);
11286 
11287  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
11288  CXXCopyAssignment,
11289  Const);
11290 
11291  // An implicitly-declared copy assignment operator is an inline public
11292  // member of its class.
11293  DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
11294  SourceLocation ClassLoc = ClassDecl->getLocation();
11295  DeclarationNameInfo NameInfo(Name, ClassLoc);
11296  CXXMethodDecl *CopyAssignment =
11297  CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
11298  /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
11299  /*isInline=*/true, Constexpr, SourceLocation());
11300  CopyAssignment->setAccess(AS_public);
11301  CopyAssignment->setDefaulted();
11302  CopyAssignment->setImplicit();
11303 
11304  if (getLangOpts().CUDA) {
11305  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyAssignment,
11306  CopyAssignment,
11307  /* ConstRHS */ Const,
11308  /* Diagnose */ false);
11309  }
11310 
11311  // Build an exception specification pointing back at this member.
11313  getImplicitMethodEPI(*this, CopyAssignment);
11314  CopyAssignment->setType(Context.getFunctionType(RetType, ArgType, EPI));
11315 
11316  // Add the parameter to the operator.
11317  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
11318  ClassLoc, ClassLoc,
11319  /*Id=*/nullptr, ArgType,
11320  /*TInfo=*/nullptr, SC_None,
11321  nullptr);
11322  CopyAssignment->setParams(FromParam);
11323 
11324  CopyAssignment->setTrivial(
11326  ? SpecialMemberIsTrivial(CopyAssignment, CXXCopyAssignment)
11327  : ClassDecl->hasTrivialCopyAssignment());
11328 
11329  // Note that we have added this copy-assignment operator.
11331 
11332  Scope *S = getScopeForContext(ClassDecl);
11333  CheckImplicitSpecialMemberDeclaration(S, CopyAssignment);
11334 
11335  if (ShouldDeleteSpecialMember(CopyAssignment, CXXCopyAssignment))
11336  SetDeclDeleted(CopyAssignment, ClassLoc);
11337 
11338  if (S)
11339  PushOnScopeChains(CopyAssignment, S, false);
11340  ClassDecl->addDecl(CopyAssignment);
11341 
11342  return CopyAssignment;
11343 }
11344 
11345 /// Diagnose an implicit copy operation for a class which is odr-used, but
11346 /// which is deprecated because the class has a user-declared copy constructor,
11347 /// copy assignment operator, or destructor.
11349  assert(CopyOp->isImplicit());
11350 
11351  CXXRecordDecl *RD = CopyOp->getParent();
11352  CXXMethodDecl *UserDeclaredOperation = nullptr;
11353 
11354  // In Microsoft mode, assignment operations don't affect constructors and
11355  // vice versa.
11356  if (RD->hasUserDeclaredDestructor()) {
11357  UserDeclaredOperation = RD->getDestructor();
11358  } else if (!isa<CXXConstructorDecl>(CopyOp) &&
11359  RD->hasUserDeclaredCopyConstructor() &&
11360  !S.getLangOpts().MSVCCompat) {
11361  // Find any user-declared copy constructor.
11362  for (auto *I : RD->ctors()) {
11363  if (I->isCopyConstructor()) {
11364  UserDeclaredOperation = I;
11365  break;
11366  }
11367  }
11368  assert(UserDeclaredOperation);
11369  } else if (isa<CXXConstructorDecl>(CopyOp) &&
11370  RD->hasUserDeclaredCopyAssignment() &&
11371  !S.getLangOpts().MSVCCompat) {
11372  // Find any user-declared move assignment operator.
11373  for (auto *I : RD->methods()) {
11374  if (I->isCopyAssignmentOperator()) {
11375  UserDeclaredOperation = I;
11376  break;
11377  }
11378  }
11379  assert(UserDeclaredOperation);
11380  }
11381 
11382  if (UserDeclaredOperation) {
11383  S.Diag(UserDeclaredOperation->getLocation(),
11384  diag::warn_deprecated_copy_operation)
11385  << RD << /*copy assignment*/!isa<CXXConstructorDecl>(CopyOp)
11386  << /*destructor*/isa<CXXDestructorDecl>(UserDeclaredOperation);
11387  }
11388 }
11389 
11391  CXXMethodDecl *CopyAssignOperator) {
11392  assert((CopyAssignOperator->isDefaulted() &&
11393  CopyAssignOperator->isOverloadedOperator() &&
11394  CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
11395  !CopyAssignOperator->doesThisDeclarationHaveABody() &&
11396  !CopyAssignOperator->isDeleted()) &&
11397  "DefineImplicitCopyAssignment called for wrong function");
11398  if (CopyAssignOperator->willHaveBody() || CopyAssignOperator->isInvalidDecl())
11399  return;
11400 
11401  CXXRecordDecl *ClassDecl = CopyAssignOperator->getParent();
11402  if (ClassDecl->isInvalidDecl()) {
11403  CopyAssignOperator->setInvalidDecl();
11404  return;
11405  }
11406 
11407  SynthesizedFunctionScope Scope(*this, CopyAssignOperator);
11408 
11409  // The exception specification is needed because we are defining the
11410  // function.
11411  ResolveExceptionSpec(CurrentLocation,
11412  CopyAssignOperator->getType()->castAs<FunctionProtoType>());
11413 
11414  // Add a context note for diagnostics produced after this point.
11415  Scope.addContextNote(CurrentLocation);
11416 
11417  // C++11 [class.copy]p18:
11418  // The [definition of an implicitly declared copy assignment operator] is
11419  // deprecated if the class has a user-declared copy constructor or a
11420  // user-declared destructor.
11421  if (getLangOpts().CPlusPlus11 && CopyAssignOperator->isImplicit())
11422  diagnoseDeprecatedCopyOperation(*this, CopyAssignOperator);
11423 
11424  // C++0x [class.copy]p30:
11425  // The implicitly-defined or explicitly-defaulted copy assignment operator
11426  // for a non-union class X performs memberwise copy assignment of its
11427  // subobjects. The direct base classes of X are assigned first, in the
11428  // order of their declaration in the base-specifier-list, and then the
11429  // immediate non-static data members of X are assigned, in the order in
11430  // which they were declared in the class definition.
11431 
11432  // The statements that form the synthesized function body.
11433  SmallVector<Stmt*, 8> Statements;
11434 
11435  // The parameter for the "other" object, which we are copying from.
11436  ParmVarDecl *Other = CopyAssignOperator->getParamDecl(0);
11437  Qualifiers OtherQuals = Other->getType().getQualifiers();
11438  QualType OtherRefType = Other->getType();
11439  if (const LValueReferenceType *OtherRef
11440  = OtherRefType->getAs<LValueReferenceType>()) {
11441  OtherRefType = OtherRef->getPointeeType();
11442  OtherQuals = OtherRefType.getQualifiers();
11443  }
11444 
11445  // Our location for everything implicitly-generated.
11446  SourceLocation Loc = CopyAssignOperator->getLocEnd().isValid()
11447  ? CopyAssignOperator->getLocEnd()
11448  : CopyAssignOperator->getLocation();
11449 
11450  // Builds a DeclRefExpr for the "other" object.
11451  RefBuilder OtherRef(Other, OtherRefType);
11452 
11453  // Builds the "this" pointer.
11454  ThisBuilder This;
11455 
11456  // Assign base classes.
11457  bool Invalid = false;
11458  for (auto &Base : ClassDecl->bases()) {
11459  // Form the assignment:
11460  // static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other));
11461  QualType BaseType = Base.getType().getUnqualifiedType();
11462  if (!BaseType->isRecordType()) {
11463  Invalid = true;
11464  continue;
11465  }
11466 
11467  CXXCastPath BasePath;
11468  BasePath.push_back(&Base);
11469 
11470  // Construct the "from" expression, which is an implicit cast to the
11471  // appropriately-qualified base type.
11472  CastBuilder From(OtherRef, Context.getQualifiedType(BaseType, OtherQuals),
11473  VK_LValue, BasePath);
11474 
11475  // Dereference "this".
11476  DerefBuilder DerefThis(This);
11477  CastBuilder To(DerefThis,
11478  Context.getCVRQualifiedType(
11479  BaseType, CopyAssignOperator->getTypeQualifiers()),
11480  VK_LValue, BasePath);
11481 
11482  // Build the copy.
11483  StmtResult Copy = buildSingleCopyAssign(*this, Loc, BaseType,
11484  To, From,
11485  /*CopyingBaseSubobject=*/true,
11486  /*Copying=*/true);
11487  if (Copy.isInvalid()) {
11488  CopyAssignOperator->setInvalidDecl();
11489  return;
11490  }
11491 
11492  // Success! Record the copy.
11493  Statements.push_back(Copy.getAs<Expr>());
11494  }
11495 
11496  // Assign non-static members.
11497  for (auto *Field : ClassDecl->fields()) {
11498  // FIXME: We should form some kind of AST representation for the implied
11499  // memcpy in a union copy operation.
11500  if (Field->isUnnamedBitfield() || Field->getParent()->isUnion())
11501  continue;
11502 
11503  if (Field->isInvalidDecl()) {
11504  Invalid = true;
11505  continue;
11506  }
11507 
11508  // Check for members of reference type; we can't copy those.
11509  if (Field->getType()->isReferenceType()) {
11510  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
11511  << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
11512  Diag(Field->getLocation(), diag::note_declared_at);
11513  Invalid = true;
11514  continue;
11515  }
11516 
11517  // Check for members of const-qualified, non-class type.
11518  QualType BaseType = Context.getBaseElementType(Field->getType());
11519  if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
11520  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
11521  << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
11522  Diag(Field->getLocation(), diag::note_declared_at);
11523  Invalid = true;
11524  continue;
11525  }
11526 
11527  // Suppress assigning zero-width bitfields.
11528  if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
11529  continue;
11530 
11531  QualType FieldType = Field->getType().getNonReferenceType();
11532  if (FieldType->isIncompleteArrayType()) {
11533  assert(ClassDecl->hasFlexibleArrayMember() &&
11534  "Incomplete array type is not valid");
11535  continue;
11536  }
11537 
11538  // Build references to the field in the object we're copying from and to.
11539  CXXScopeSpec SS; // Intentionally empty
11540  LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
11541  LookupMemberName);
11542  MemberLookup.addDecl(Field);
11543  MemberLookup.resolveKind();
11544 
11545  MemberBuilder From(OtherRef, OtherRefType, /*IsArrow=*/false, MemberLookup);
11546 
11547  MemberBuilder To(This, getCurrentThisType(), /*IsArrow=*/true, MemberLookup);
11548 
11549  // Build the copy of this field.
11550  StmtResult Copy = buildSingleCopyAssign(*this, Loc, FieldType,
11551  To, From,
11552  /*CopyingBaseSubobject=*/false,
11553  /*Copying=*/true);
11554  if (Copy.isInvalid()) {
11555  CopyAssignOperator->setInvalidDecl();
11556  return;
11557  }
11558 
11559  // Success! Record the copy.
11560  Statements.push_back(Copy.getAs<Stmt>());
11561  }
11562 
11563  if (!Invalid) {
11564  // Add a "return *this;"
11565  ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
11566 
11567  StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
11568  if (Return.isInvalid())
11569  Invalid = true;
11570  else
11571  Statements.push_back(Return.getAs<Stmt>());
11572  }
11573 
11574  if (Invalid) {
11575  CopyAssignOperator->setInvalidDecl();
11576  return;
11577  }
11578 
11579  StmtResult Body;
11580  {
11581  CompoundScopeRAII CompoundScope(*this);
11582  Body = ActOnCompoundStmt(Loc, Loc, Statements,
11583  /*isStmtExpr=*/false);
11584  assert(!Body.isInvalid() && "Compound statement creation cannot fail");
11585  }
11586  CopyAssignOperator->setBody(Body.getAs<Stmt>());
11587  CopyAssignOperator->markUsed(Context);
11588 
11589  if (ASTMutationListener *L = getASTMutationListener()) {
11590  L->CompletedImplicitDefinition(CopyAssignOperator);
11591  }
11592 }
11593 
11595  assert(ClassDecl->needsImplicitMoveAssignment());
11596 
11597  DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveAssignment);
11598  if (DSM.isAlreadyBeingDeclared())
11599  return nullptr;
11600 
11601  // Note: The following rules are largely analoguous to the move
11602  // constructor rules.
11603 
11604  QualType ArgType = Context.getTypeDeclType(ClassDecl);
11605  QualType RetType = Context.getLValueReferenceType(ArgType);
11606  ArgType = Context.getRValueReferenceType(ArgType);
11607 
11608  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
11609  CXXMoveAssignment,
11610  false);
11611 
11612  // An implicitly-declared move assignment operator is an inline public
11613  // member of its class.
11614  DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
11615  SourceLocation ClassLoc = ClassDecl->getLocation();
11616  DeclarationNameInfo NameInfo(Name, ClassLoc);
11617  CXXMethodDecl *MoveAssignment =
11618  CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
11619  /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
11620  /*isInline=*/true, Constexpr, SourceLocation());
11621  MoveAssignment->setAccess(AS_public);
11622  MoveAssignment->setDefaulted();
11623  MoveAssignment->setImplicit();
11624 
11625  if (getLangOpts().CUDA) {
11626  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveAssignment,
11627  MoveAssignment,
11628  /* ConstRHS */ false,
11629  /* Diagnose */ false);
11630  }
11631 
11632  // Build an exception specification pointing back at this member.
11634  getImplicitMethodEPI(*this, MoveAssignment);
11635  MoveAssignment->setType(Context.getFunctionType(RetType, ArgType, EPI));
11636 
11637  // Add the parameter to the operator.
11638  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveAssignment,
11639  ClassLoc, ClassLoc,
11640  /*Id=*/nullptr, ArgType,
11641  /*TInfo=*/nullptr, SC_None,
11642  nullptr);
11643  MoveAssignment->setParams(FromParam);
11644 
11645  MoveAssignment->setTrivial(
11647  ? SpecialMemberIsTrivial(MoveAssignment, CXXMoveAssignment)
11648  : ClassDecl->hasTrivialMoveAssignment());
11649 
11650  // Note that we have added this copy-assignment operator.
11652 
11653  Scope *S = getScopeForContext(ClassDecl);
11654  CheckImplicitSpecialMemberDeclaration(S, MoveAssignment);
11655 
11656  if (ShouldDeleteSpecialMember(MoveAssignment, CXXMoveAssignment)) {
11658  SetDeclDeleted(MoveAssignment, ClassLoc);
11659  }
11660 
11661  if (S)
11662  PushOnScopeChains(MoveAssignment, S, false);
11663  ClassDecl->addDecl(MoveAssignment);
11664 
11665  return MoveAssignment;
11666 }
11667 
11668 /// Check if we're implicitly defining a move assignment operator for a class
11669 /// with virtual bases. Such a move assignment might move-assign the virtual
11670 /// base multiple times.
11672  SourceLocation CurrentLocation) {
11673  assert(!Class->isDependentContext() && "should not define dependent move");
11674 
11675  // Only a virtual base could get implicitly move-assigned multiple times.
11676  // Only a non-trivial move assignment can observe this. We only want to
11677  // diagnose if we implicitly define an assignment operator that assigns
11678  // two base classes, both of which move-assign the same virtual base.
11679  if (Class->getNumVBases() == 0 || Class->hasTrivialMoveAssignment() ||
11680  Class->getNumBases() < 2)
11681  return;
11682 
11684  typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
11685  VBaseMap VBases;
11686 
11687  for (auto &BI : Class->bases()) {
11688  Worklist.push_back(&BI);
11689  while (!Worklist.empty()) {
11690  CXXBaseSpecifier *BaseSpec = Worklist.pop_back_val();
11691  CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
11692 
11693  // If the base has no non-trivial move assignment operators,
11694  // we don't care about moves from it.
11695  if (!Base->hasNonTrivialMoveAssignment())
11696  continue;
11697 
11698  // If there's nothing virtual here, skip it.
11699  if (!BaseSpec->isVirtual() && !Base->getNumVBases())
11700  continue;
11701 
11702  // If we're not actually going to call a move assignment for this base,
11703  // or the selected move assignment is trivial, skip it.
11706  /*ConstArg*/false, /*VolatileArg*/false,
11707  /*RValueThis*/true, /*ConstThis*/false,
11708  /*VolatileThis*/false);
11709  if (!SMOR.getMethod() || SMOR.getMethod()->isTrivial() ||
11711  continue;
11712 
11713  if (BaseSpec->isVirtual()) {
11714  // We're going to move-assign this virtual base, and its move
11715  // assignment operator is not trivial. If this can happen for
11716  // multiple distinct direct bases of Class, diagnose it. (If it
11717  // only happens in one base, we'll diagnose it when synthesizing
11718  // that base class's move assignment operator.)
11719  CXXBaseSpecifier *&Existing =
11720  VBases.insert(std::make_pair(Base->getCanonicalDecl(), &BI))
11721  .first->second;
11722  if (Existing && Existing != &BI) {
11723  S.Diag(CurrentLocation, diag::warn_vbase_moved_multiple_times)
11724  << Class << Base;
11725  S.Diag(Existing->getLocStart(), diag::note_vbase_moved_here)
11726  << (Base->getCanonicalDecl() ==
11727  Existing->getType()->getAsCXXRecordDecl()->getCanonicalDecl())
11728  << Base << Existing->getType() << Existing->getSourceRange();
11729  S.Diag(BI.getLocStart(), diag::note_vbase_moved_here)
11730  << (Base->getCanonicalDecl() ==
11731  BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
11732  << Base << BI.getType() << BaseSpec->getSourceRange();
11733 
11734  // Only diagnose each vbase once.
11735  Existing = nullptr;
11736  }
11737  } else {
11738  // Only walk over bases that have defaulted move assignment operators.
11739  // We assume that any user-provided move assignment operator handles
11740  // the multiple-moves-of-vbase case itself somehow.
11741  if (!SMOR.getMethod()->isDefaulted())
11742  continue;
11743 
11744  // We're going to move the base classes of Base. Add them to the list.
11745  for (auto &BI : Base->bases())
11746  Worklist.push_back(&BI);
11747  }
11748  }
11749  }
11750 }
11751 
11753  CXXMethodDecl *MoveAssignOperator) {
11754  assert((MoveAssignOperator->isDefaulted() &&
11755  MoveAssignOperator->isOverloadedOperator() &&
11756  MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
11757  !MoveAssignOperator->doesThisDeclarationHaveABody() &&
11758  !MoveAssignOperator->isDeleted()) &&
11759  "DefineImplicitMoveAssignment called for wrong function");
11760  if (MoveAssignOperator->willHaveBody() || MoveAssignOperator->isInvalidDecl())
11761  return;
11762 
11763  CXXRecordDecl *ClassDecl = MoveAssignOperator->getParent();
11764  if (ClassDecl->isInvalidDecl()) {
11765  MoveAssignOperator->setInvalidDecl();
11766  return;
11767  }
11768 
11769  // C++0x [class.copy]p28:
11770  // The implicitly-defined or move assignment operator for a non-union class
11771  // X performs memberwise move assignment of its subobjects. The direct base
11772  // classes of X are assigned first, in the order of their declaration in the
11773  // base-specifier-list, and then the immediate non-static data members of X
11774  // are assigned, in the order in which they were declared in the class
11775  // definition.
11776 
11777  // Issue a warning if our implicit move assignment operator will move
11778  // from a virtual base more than once.
11779  checkMoveAssignmentForRepeatedMove(*this, ClassDecl, CurrentLocation);
11780 
11781  SynthesizedFunctionScope Scope(*this, MoveAssignOperator);
11782 
11783  // The exception specification is needed because we are defining the
11784  // function.
11785  ResolveExceptionSpec(CurrentLocation,
11786  MoveAssignOperator->getType()->castAs<FunctionProtoType>());
11787 
11788  // Add a context note for diagnostics produced after this point.
11789  Scope.addContextNote(CurrentLocation);
11790 
11791  // The statements that form the synthesized function body.
11792  SmallVector<Stmt*, 8> Statements;
11793 
11794  // The parameter for the "other" object, which we are move from.
11795  ParmVarDecl *Other = MoveAssignOperator->getParamDecl(0);
11796  QualType OtherRefType = Other->getType()->
11797  getAs<RValueReferenceType>()->getPointeeType();
11798  assert(!OtherRefType.getQualifiers() &&
11799  "Bad argument type of defaulted move assignment");
11800 
11801  // Our location for everything implicitly-generated.
11802  SourceLocation Loc = MoveAssignOperator->getLocEnd().isValid()
11803  ? MoveAssignOperator->getLocEnd()
11804  : MoveAssignOperator->getLocation();
11805 
11806  // Builds a reference to the "other" object.
11807  RefBuilder OtherRef(Other, OtherRefType);
11808  // Cast to rvalue.
11809  MoveCastBuilder MoveOther(OtherRef);
11810 
11811  // Builds the "this" pointer.
11812  ThisBuilder This;
11813 
11814  // Assign base classes.
11815  bool Invalid = false;
11816  for (auto &Base : ClassDecl->bases()) {
11817  // C++11 [class.copy]p28:
11818  // It is unspecified whether subobjects representing virtual base classes
11819  // are assigned more than once by the implicitly-defined copy assignment
11820  // operator.
11821  // FIXME: Do not assign to a vbase that will be assigned by some other base
11822  // class. For a move-assignment, this can result in the vbase being moved
11823  // multiple times.
11824 
11825  // Form the assignment:
11826  // static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other));
11827  QualType BaseType = Base.getType().getUnqualifiedType();
11828  if (!BaseType->isRecordType()) {
11829  Invalid = true;
11830  continue;
11831  }
11832 
11833  CXXCastPath BasePath;
11834  BasePath.push_back(&Base);
11835 
11836  // Construct the "from" expression, which is an implicit cast to the
11837  // appropriately-qualified base type.
11838  CastBuilder From(OtherRef, BaseType, VK_XValue, BasePath);
11839 
11840  // Dereference "this".
11841  DerefBuilder DerefThis(This);
11842 
11843  // Implicitly cast "this" to the appropriately-qualified base type.
11844  CastBuilder To(DerefThis,
11845  Context.getCVRQualifiedType(
11846  BaseType, MoveAssignOperator->getTypeQualifiers()),
11847  VK_LValue, BasePath);
11848 
11849  // Build the move.
11850  StmtResult Move = buildSingleCopyAssign(*this, Loc, BaseType,
11851  To, From,
11852  /*CopyingBaseSubobject=*/true,
11853  /*Copying=*/false);
11854  if (Move.isInvalid()) {
11855  MoveAssignOperator->setInvalidDecl();
11856  return;
11857  }
11858 
11859  // Success! Record the move.
11860  Statements.push_back(Move.getAs<Expr>());
11861  }
11862 
11863  // Assign non-static members.
11864  for (auto *Field : ClassDecl->fields()) {
11865  // FIXME: We should form some kind of AST representation for the implied
11866  // memcpy in a union copy operation.
11867  if (Field->isUnnamedBitfield() || Field->getParent()->isUnion())
11868  continue;
11869 
11870  if (Field->isInvalidDecl()) {
11871  Invalid = true;
11872  continue;
11873  }
11874 
11875  // Check for members of reference type; we can't move those.
11876  if (Field->getType()->isReferenceType()) {
11877  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
11878  << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
11879  Diag(Field->getLocation(), diag::note_declared_at);
11880  Invalid = true;
11881  continue;
11882  }
11883 
11884  // Check for members of const-qualified, non-class type.
11885  QualType BaseType = Context.getBaseElementType(Field->getType());
11886  if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
11887  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
11888  << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
11889  Diag(Field->getLocation(), diag::note_declared_at);
11890  Invalid = true;
11891  continue;
11892  }
11893 
11894  // Suppress assigning zero-width bitfields.
11895  if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
11896  continue;
11897 
11898  QualType FieldType = Field->getType().getNonReferenceType();
11899  if (FieldType->isIncompleteArrayType()) {
11900  assert(ClassDecl->hasFlexibleArrayMember() &&
11901  "Incomplete array type is not valid");
11902  continue;
11903  }
11904 
11905  // Build references to the field in the object we're copying from and to.
11906  LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
11907  LookupMemberName);
11908  MemberLookup.addDecl(Field);
11909  MemberLookup.resolveKind();
11910  MemberBuilder From(MoveOther, OtherRefType,
11911  /*IsArrow=*/false, MemberLookup);
11912  MemberBuilder To(This, getCurrentThisType(),
11913  /*IsArrow=*/true, MemberLookup);
11914 
11915  assert(!From.build(*this, Loc)->isLValue() && // could be xvalue or prvalue
11916  "Member reference with rvalue base must be rvalue except for reference "
11917  "members, which aren't allowed for move assignment.");
11918 
11919  // Build the move of this field.
11920  StmtResult Move = buildSingleCopyAssign(*this, Loc, FieldType,
11921  To, From,
11922  /*CopyingBaseSubobject=*/false,
11923  /*Copying=*/false);
11924  if (Move.isInvalid()) {
11925  MoveAssignOperator->setInvalidDecl();
11926  return;
11927  }
11928 
11929  // Success! Record the copy.
11930  Statements.push_back(Move.getAs<Stmt>());
11931  }
11932 
11933  if (!Invalid) {
11934  // Add a "return *this;"
11935  ExprResult ThisObj =
11936  CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
11937 
11938  StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
11939  if (Return.isInvalid())
11940  Invalid = true;
11941  else
11942  Statements.push_back(Return.getAs<Stmt>());
11943  }
11944 
11945  if (Invalid) {
11946  MoveAssignOperator->setInvalidDecl();
11947  return;
11948  }
11949 
11950  StmtResult Body;
11951  {
11952  CompoundScopeRAII CompoundScope(*this);
11953  Body = ActOnCompoundStmt(Loc, Loc, Statements,
11954  /*isStmtExpr=*/false);
11955  assert(!Body.isInvalid() && "Compound statement creation cannot fail");
11956  }
11957  MoveAssignOperator->setBody(Body.getAs<Stmt>());
11958  MoveAssignOperator->markUsed(Context);
11959 
11960  if (ASTMutationListener *L = getASTMutationListener()) {
11961  L->CompletedImplicitDefinition(MoveAssignOperator);
11962  }
11963 }
11964 
11966  CXXRecordDecl *ClassDecl) {
11967  // C++ [class.copy]p4:
11968  // If the class definition does not explicitly declare a copy
11969  // constructor, one is declared implicitly.
11970  assert(ClassDecl->needsImplicitCopyConstructor());
11971 
11972  DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyConstructor);
11973  if (DSM.isAlreadyBeingDeclared())
11974  return nullptr;
11975 
11976  QualType ClassType = Context.getTypeDeclType(ClassDecl);
11977  QualType ArgType = ClassType;
11978  bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
11979  if (Const)
11980  ArgType = ArgType.withConst();
11981  ArgType = Context.getLValueReferenceType(ArgType);
11982 
11983  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
11984  CXXCopyConstructor,
11985  Const);
11986 
11987  DeclarationName Name
11989  Context.getCanonicalType(ClassType));
11990  SourceLocation ClassLoc = ClassDecl->getLocation();
11991  DeclarationNameInfo NameInfo(Name, ClassLoc);
11992 
11993  // An implicitly-declared copy constructor is an inline public
11994  // member of its class.
11996  Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
11997  /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
11998  Constexpr);
11999  CopyConstructor->setAccess(AS_public);
12000  CopyConstructor->setDefaulted();
12001 
12002  if (getLangOpts().CUDA) {
12003  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyConstructor,
12004  CopyConstructor,
12005  /* ConstRHS */ Const,
12006  /* Diagnose */ false);
12007  }
12008 
12009  // Build an exception specification pointing back at this member.
12011  getImplicitMethodEPI(*this, CopyConstructor);
12012  CopyConstructor->setType(
12013  Context.getFunctionType(Context.VoidTy, ArgType, EPI));
12014 
12015  // Add the parameter to the constructor.
12016  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
12017  ClassLoc, ClassLoc,
12018  /*IdentifierInfo=*/nullptr,
12019  ArgType, /*TInfo=*/nullptr,
12020  SC_None, nullptr);
12021  CopyConstructor->setParams(FromParam);
12022 
12023  CopyConstructor->setTrivial(
12025  ? SpecialMemberIsTrivial(CopyConstructor, CXXCopyConstructor)
12026  : ClassDecl->hasTrivialCopyConstructor());
12027 
12028  // Note that we have declared this constructor.
12030 
12031  Scope *S = getScopeForContext(ClassDecl);
12032  CheckImplicitSpecialMemberDeclaration(S, CopyConstructor);
12033 
12034  if (ShouldDeleteSpecialMember(CopyConstructor, CXXCopyConstructor)) {
12036  SetDeclDeleted(CopyConstructor, ClassLoc);
12037  }
12038 
12039  if (S)
12040  PushOnScopeChains(CopyConstructor, S, false);
12041  ClassDecl->addDecl(CopyConstructor);
12042 
12043  return CopyConstructor;
12044 }
12045 
12047  CXXConstructorDecl *CopyConstructor) {
12048  assert((CopyConstructor->isDefaulted() &&
12049  CopyConstructor->isCopyConstructor() &&
12050  !CopyConstructor->doesThisDeclarationHaveABody() &&
12051  !CopyConstructor->isDeleted()) &&
12052  "DefineImplicitCopyConstructor - call it for implicit copy ctor");
12053  if (CopyConstructor->willHaveBody() || CopyConstructor->isInvalidDecl())
12054  return;
12055 
12056  CXXRecordDecl *ClassDecl = CopyConstructor->getParent();
12057  assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
12058 
12059  SynthesizedFunctionScope Scope(*this, CopyConstructor);
12060 
12061  // The exception specification is needed because we are defining the
12062  // function.
12063  ResolveExceptionSpec(CurrentLocation,
12064  CopyConstructor->getType()->castAs<FunctionProtoType>());
12065  MarkVTableUsed(CurrentLocation, ClassDecl);
12066 
12067  // Add a context note for diagnostics produced after this point.
12068  Scope.addContextNote(CurrentLocation);
12069 
12070  // C++11 [class.copy]p7:
12071  // The [definition of an implicitly declared copy constructor] is
12072  // deprecated if the class has a user-declared copy assignment operator
12073  // or a user-declared destructor.
12074  if (getLangOpts().CPlusPlus11 && CopyConstructor->isImplicit())
12075  diagnoseDeprecatedCopyOperation(*this, CopyConstructor);
12076 
12077  if (SetCtorInitializers(CopyConstructor, /*AnyErrors=*/false)) {
12078  CopyConstructor->setInvalidDecl();
12079  } else {
12080  SourceLocation Loc = CopyConstructor->getLocEnd().isValid()
12081  ? CopyConstructor->getLocEnd()
12082  : CopyConstructor->getLocation();
12083  Sema::CompoundScopeRAII CompoundScope(*this);
12084  CopyConstructor->setBody(
12085  ActOnCompoundStmt(Loc, Loc, None, /*isStmtExpr=*/false).getAs<Stmt>());
12086  CopyConstructor->markUsed(Context);
12087  }
12088 
12089  if (ASTMutationListener *L = getASTMutationListener()) {
12090  L->CompletedImplicitDefinition(CopyConstructor);
12091  }
12092 }
12093 
12095  CXXRecordDecl *ClassDecl) {
12096  assert(ClassDecl->needsImplicitMoveConstructor());
12097 
12098  DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveConstructor);
12099  if (DSM.isAlreadyBeingDeclared())
12100  return nullptr;
12101 
12102  QualType ClassType = Context.getTypeDeclType(ClassDecl);
12103  QualType ArgType = Context.getRValueReferenceType(ClassType);
12104 
12105  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
12106  CXXMoveConstructor,
12107  false);
12108 
12109  DeclarationName Name
12111  Context.getCanonicalType(ClassType));
12112  SourceLocation ClassLoc = ClassDecl->getLocation();
12113  DeclarationNameInfo NameInfo(Name, ClassLoc);
12114 
12115  // C++11 [class.copy]p11:
12116  // An implicitly-declared copy/move constructor is an inline public
12117  // member of its class.
12119  Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
12120  /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
12121  Constexpr);
12122  MoveConstructor->setAccess(AS_public);
12123  MoveConstructor->setDefaulted();
12124 
12125  if (getLangOpts().CUDA) {
12126  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveConstructor,
12127  MoveConstructor,
12128  /* ConstRHS */ false,
12129  /* Diagnose */ false);
12130  }
12131 
12132  // Build an exception specification pointing back at this member.
12134  getImplicitMethodEPI(*this, MoveConstructor);
12135  MoveConstructor->setType(
12136  Context.getFunctionType(Context.VoidTy, ArgType, EPI));
12137 
12138  // Add the parameter to the constructor.
12139  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveConstructor,
12140  ClassLoc, ClassLoc,
12141  /*IdentifierInfo=*/nullptr,
12142  ArgType, /*TInfo=*/nullptr,
12143  SC_None, nullptr);
12144  MoveConstructor->setParams(FromParam);
12145 
12146  MoveConstructor->setTrivial(
12148  ? SpecialMemberIsTrivial(MoveConstructor, CXXMoveConstructor)
12149  : ClassDecl->hasTrivialMoveConstructor());
12150 
12151  // Note that we have declared this constructor.
12153 
12154  Scope *S = getScopeForContext(ClassDecl);
12155  CheckImplicitSpecialMemberDeclaration(S, MoveConstructor);
12156 
12157  if (ShouldDeleteSpecialMember(MoveConstructor, CXXMoveConstructor)) {
12159  SetDeclDeleted(MoveConstructor, ClassLoc);
12160  }
12161 
12162  if (S)
12163  PushOnScopeChains(MoveConstructor, S, false);
12164  ClassDecl->addDecl(MoveConstructor);
12165 
12166  return MoveConstructor;
12167 }
12168 
12170  CXXConstructorDecl *MoveConstructor) {
12171  assert((MoveConstructor->isDefaulted() &&
12172  MoveConstructor->isMoveConstructor() &&
12173  !MoveConstructor->doesThisDeclarationHaveABody() &&
12174  !MoveConstructor->isDeleted()) &&
12175  "DefineImplicitMoveConstructor - call it for implicit move ctor");
12176  if (MoveConstructor->willHaveBody() || MoveConstructor->isInvalidDecl())
12177  return;
12178 
12179  CXXRecordDecl *ClassDecl = MoveConstructor->getParent();
12180  assert(ClassDecl && "DefineImplicitMoveConstructor - invalid constructor");
12181 
12182  SynthesizedFunctionScope Scope(*this, MoveConstructor);
12183 
12184  // The exception specification is needed because we are defining the
12185  // function.
12186  ResolveExceptionSpec(CurrentLocation,
12187  MoveConstructor->getType()->castAs<FunctionProtoType>());
12188  MarkVTableUsed(CurrentLocation, ClassDecl);
12189 
12190  // Add a context note for diagnostics produced after this point.
12191  Scope.addContextNote(CurrentLocation);
12192 
12193  if (SetCtorInitializers(MoveConstructor, /*AnyErrors=*/false)) {
12194  MoveConstructor->setInvalidDecl();
12195  } else {
12196  SourceLocation Loc = MoveConstructor->getLocEnd().isValid()
12197  ? MoveConstructor->getLocEnd()
12198  : MoveConstructor->getLocation();
12199  Sema::CompoundScopeRAII CompoundScope(*this);
12200  MoveConstructor->setBody(ActOnCompoundStmt(
12201  Loc, Loc, None, /*isStmtExpr=*/ false).getAs<Stmt>());
12202  MoveConstructor->markUsed(Context);
12203  }
12204 
12205  if (ASTMutationListener *L = getASTMutationListener()) {
12206  L->CompletedImplicitDefinition(MoveConstructor);
12207  }
12208 }
12209 
12211  return FD->isDeleted() && FD->isDefaulted() && isa<CXXMethodDecl>(FD);
12212 }
12213 
12215  SourceLocation CurrentLocation,
12216  CXXConversionDecl *Conv) {
12217  SynthesizedFunctionScope Scope(*this, Conv);
12218  assert(!Conv->getReturnType()->isUndeducedType());
12219 
12220  CXXRecordDecl *Lambda = Conv->getParent();
12221  FunctionDecl *CallOp = Lambda->getLambdaCallOperator();
12222  FunctionDecl *Invoker = Lambda->getLambdaStaticInvoker();
12223 
12224  if (auto *TemplateArgs = Conv->getTemplateSpecializationArgs()) {
12225  CallOp = InstantiateFunctionDeclaration(
12226  CallOp->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
12227  if (!CallOp)
12228  return;
12229 
12230  Invoker = InstantiateFunctionDeclaration(
12231  Invoker->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
12232  if (!Invoker)
12233  return;
12234  }
12235 
12236  if (CallOp->isInvalidDecl())
12237  return;
12238 
12239  // Mark the call operator referenced (and add to pending instantiations
12240  // if necessary).
12241  // For both the conversion and static-invoker template specializations
12242  // we construct their body's in this function, so no need to add them
12243  // to the PendingInstantiations.
12244  MarkFunctionReferenced(CurrentLocation, CallOp);
12245 
12246  // Fill in the __invoke function with a dummy implementation. IR generation
12247  // will fill in the actual details. Update its type in case it contained
12248  // an 'auto'.
12249  Invoker->markUsed(Context);
12250  Invoker->setReferenced();
12251  Invoker->setType(Conv->getReturnType()->getPointeeType());
12252  Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));
12253 
12254  // Construct the body of the conversion function { return __invoke; }.
12255  Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(),
12256  VK_LValue, Conv->getLocation()).get();
12257  assert(FunctionRef && "Can't refer to __invoke function?");
12258  Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
12259  Conv->setBody(CompoundStmt::Create(Context, Return, Conv->getLocation(),
12260  Conv->getLocation()));
12261  Conv->markUsed(Context);
12262  Conv->setReferenced();
12263 
12264  if (ASTMutationListener *L = getASTMutationListener()) {
12265  L->CompletedImplicitDefinition(Conv);
12266  L->CompletedImplicitDefinition(Invoker);
12267  }
12268 }
12269 
12270 
12271 
12273  SourceLocation CurrentLocation,
12274  CXXConversionDecl *Conv)
12275 {
12276  assert(!Conv->getParent()->isGenericLambda());
12277 
12278  SynthesizedFunctionScope Scope(*this, Conv);
12279 
12280  // Copy-initialize the lambda object as needed to capture it.
12281  Expr *This = ActOnCXXThis(CurrentLocation).get();
12282  Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).get();
12283 
12284  ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation,
12285  Conv->getLocation(),
12286  Conv, DerefThis);
12287 
12288  // If we're not under ARC, make sure we still get the _Block_copy/autorelease
12289  // behavior. Note that only the general conversion function does this
12290  // (since it's unusable otherwise); in the case where we inline the
12291  // block literal, it has block literal lifetime semantics.
12292  if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
12293  BuildBlock = ImplicitCastExpr::Create(Context, BuildBlock.get()->getType(),
12294  CK_CopyAndAutoreleaseBlockObject,
12295  BuildBlock.get(), nullptr, VK_RValue);
12296 
12297  if (BuildBlock.isInvalid()) {
12298  Diag(CurrentLocation, diag::note_lambda_to_block_conv);
12299  Conv->setInvalidDecl();
12300  return;
12301  }
12302 
12303  // Create the return statement that returns the block from the conversion
12304  // function.
12305  StmtResult Return = BuildReturnStmt(Conv->getLocation(), BuildBlock.get());
12306  if (Return.isInvalid()) {
12307  Diag(CurrentLocation, diag::note_lambda_to_block_conv);
12308  Conv->setInvalidDecl();
12309  return;
12310  }
12311 
12312  // Set the body of the conversion function.
12313  Stmt *ReturnS = Return.get();
12314  Conv->setBody(CompoundStmt::Create(Context, ReturnS, Conv->getLocation(),
12315  Conv->getLocation()));
12316  Conv->markUsed(Context);
12317 
12318  // We're done; notify the mutation listener, if any.
12319  if (ASTMutationListener *L = getASTMutationListener()) {
12320  L->CompletedImplicitDefinition(Conv);
12321  }
12322 }
12323 
12324 /// \brief Determine whether the given list arguments contains exactly one
12325 /// "real" (non-default) argument.
12327  switch (Args.size()) {
12328  case 0:
12329  return false;
12330 
12331  default:
12332  if (!Args[1]->isDefaultArgument())
12333  return false;
12334 
12335  LLVM_FALLTHROUGH;
12336  case 1:
12337  return !Args[0]->isDefaultArgument();
12338  }
12339 
12340  return false;
12341 }
12342 
12343 ExprResult
12345  NamedDecl *FoundDecl,
12346  CXXConstructorDecl *Constructor,
12347  MultiExprArg ExprArgs,
12348  bool HadMultipleCandidates,
12349  bool IsListInitialization,
12350  bool IsStdInitListInitialization,
12351  bool RequiresZeroInit,
12352  unsigned ConstructKind,
12353  SourceRange ParenRange) {
12354  bool Elidable = false;
12355 
12356  // C++0x [class.copy]p34:
12357  // When certain criteria are met, an implementation is allowed to
12358  // omit the copy/move construction of a class object, even if the
12359  // copy/move constructor and/or destructor for the object have
12360  // side effects. [...]
12361  // - when a temporary class object that has not been bound to a
12362  // reference (12.2) would be copied/moved to a class object
12363  // with the same cv-unqualified type, the copy/move operation
12364  // can be omitted by constructing the temporary object
12365  // directly into the target of the omitted copy/move
12366  if (ConstructKind == CXXConstructExpr::CK_Complete && Constructor &&
12367  Constructor->isCopyOrMoveConstructor() && hasOneRealArgument(ExprArgs)) {
12368  Expr *SubExpr = ExprArgs[0];
12369  Elidable = SubExpr->isTemporaryObject(
12370  Context, cast<CXXRecordDecl>(FoundDecl->getDeclContext()));
12371  }
12372 
12373  return BuildCXXConstructExpr(ConstructLoc, DeclInitType,
12374  FoundDecl, Constructor,
12375  Elidable, ExprArgs, HadMultipleCandidates,
12376  IsListInitialization,
12377  IsStdInitListInitialization, RequiresZeroInit,
12378  ConstructKind, ParenRange);
12379 }
12380 
12381 ExprResult
12383  NamedDecl *FoundDecl,
12384  CXXConstructorDecl *Constructor,
12385  bool Elidable,
12386  MultiExprArg ExprArgs,
12387  bool HadMultipleCandidates,
12388  bool IsListInitialization,
12389  bool IsStdInitListInitialization,
12390  bool RequiresZeroInit,
12391  unsigned ConstructKind,
12392  SourceRange ParenRange) {
12393  if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl)) {
12394  Constructor = findInheritingConstructor(ConstructLoc, Constructor, Shadow);
12395  if (DiagnoseUseOfDecl(Constructor, ConstructLoc))
12396  return ExprError();
12397  }
12398 
12399  return BuildCXXConstructExpr(
12400  ConstructLoc, DeclInitType, Constructor, Elidable, ExprArgs,
12401  HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
12402  RequiresZeroInit, ConstructKind, ParenRange);
12403 }
12404 
12405 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
12406 /// including handling of its default argument expressions.
12407 ExprResult
12409  CXXConstructorDecl *Constructor,
12410  bool Elidable,
12411  MultiExprArg ExprArgs,
12412  bool HadMultipleCandidates,
12413  bool IsListInitialization,
12414  bool IsStdInitListInitialization,
12415  bool RequiresZeroInit,
12416  unsigned ConstructKind,
12417  SourceRange ParenRange) {
12418  assert(declaresSameEntity(
12419  Constructor->getParent(),
12420  DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) &&
12421  "given constructor for wrong type");
12422  MarkFunctionReferenced(ConstructLoc, Constructor);
12423  if (getLangOpts().CUDA && !CheckCUDACall(ConstructLoc, Constructor))
12424  return ExprError();
12425 
12426  return CXXConstructExpr::Create(
12427  Context, DeclInitType, ConstructLoc, Constructor, Elidable,
12428  ExprArgs, HadMultipleCandidates, IsListInitialization,
12429  IsStdInitListInitialization, RequiresZeroInit,
12430  static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
12431  ParenRange);
12432 }
12433 
12435  assert(Field->hasInClassInitializer());
12436 
12437  // If we already have the in-class initializer nothing needs to be done.
12438  if (Field->getInClassInitializer())
12439  return CXXDefaultInitExpr::Create(Context, Loc, Field);
12440 
12441  // If we might have already tried and failed to instantiate, don't try again.
12442  if (Field->isInvalidDecl())
12443  return ExprError();
12444 
12445  // Maybe we haven't instantiated the in-class initializer. Go check the
12446  // pattern FieldDecl to see if it has one.
12447  CXXRecordDecl *ParentRD = cast<CXXRecordDecl>(Field->getParent());
12448 
12450  CXXRecordDecl *ClassPattern = ParentRD->getTemplateInstantiationPattern();
12452  ClassPattern->lookup(Field->getDeclName());
12453 
12454  // Lookup can return at most two results: the pattern for the field, or the
12455  // injected class name of the parent record. No other member can have the
12456  // same name as the field.
12457  // In modules mode, lookup can return multiple results (coming from
12458  // different modules).
12459  assert((getLangOpts().Modules || (!Lookup.empty() && Lookup.size() <= 2)) &&
12460  "more than two lookup results for field name");
12461  FieldDecl *Pattern = dyn_cast<FieldDecl>(Lookup[0]);
12462  if (!Pattern) {
12463  assert(isa<CXXRecordDecl>(Lookup[0]) &&
12464  "cannot have other non-field member with same name");
12465  for (auto L : Lookup)
12466  if (isa<FieldDecl>(L)) {
12467  Pattern = cast<FieldDecl>(L);
12468  break;
12469  }
12470  assert(Pattern && "We must have set the Pattern!");
12471  }
12472 
12473  if (!Pattern->hasInClassInitializer() ||
12474  InstantiateInClassInitializer(Loc, Field, Pattern,
12475  getTemplateInstantiationArgs(Field))) {
12476  // Don't diagnose this again.
12477  Field->setInvalidDecl();
12478  return ExprError();
12479  }
12480  return CXXDefaultInitExpr::Create(Context, Loc, Field);
12481  }
12482 
12483  // DR1351:
12484  // If the brace-or-equal-initializer of a non-static data member
12485  // invokes a defaulted default constructor of its class or of an
12486  // enclosing class in a potentially evaluated subexpression, the
12487  // program is ill-formed.
12488  //
12489  // This resolution is unworkable: the exception specification of the
12490  // default constructor can be needed in an unevaluated context, in
12491  // particular, in the operand of a noexcept-expression, and we can be
12492  // unable to compute an exception specification for an enclosed class.
12493  //
12494  // Any attempt to resolve the exception specification of a defaulted default
12495  // constructor before the initializer is lexically complete will ultimately
12496  // come here at which point we can diagnose it.
12497  RecordDecl *OutermostClass = ParentRD->getOuterLexicalRecordContext();
12498  Diag(Loc, diag::err_in_class_initializer_not_yet_parsed)
12499  << OutermostClass << Field;
12500  Diag(Field->getLocEnd(), diag::note_in_class_initializer_not_yet_parsed);
12501  // Recover by marking the field invalid, unless we're in a SFINAE context.
12502  if (!isSFINAEContext())
12503  Field->setInvalidDecl();
12504  return ExprError();
12505 }
12506 
12508  if (VD->isInvalidDecl()) return;
12509 
12510  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());
12511  if (ClassDecl->isInvalidDecl()) return;
12512  if (ClassDecl->hasIrrelevantDestructor()) return;
12513  if (ClassDecl->isDependentContext()) return;
12514 
12515  CXXDestructorDecl *Destructor = LookupDestructor(ClassDecl);
12516  MarkFunctionReferenced(VD->getLocation(), Destructor);
12517  CheckDestructorAccess(VD->getLocation(), Destructor,
12518  PDiag(diag::err_access_dtor_var)
12519  << VD->getDeclName()
12520  << VD->getType());
12521  DiagnoseUseOfDecl(Destructor, VD->getLocation());
12522 
12523  if (Destructor->isTrivial()) return;
12524  if (!VD->hasGlobalStorage()) return;
12525 
12526  // Emit warning for non-trivial dtor in global scope (a real global,
12527  // class-static, function-static).
12528  Diag(VD->getLocation(), diag::warn_exit_time_destructor);
12529 
12530  // TODO: this should be re-enabled for static locals by !CXAAtExit
12531  if (!VD->isStaticLocal())
12532  Diag(VD->getLocation(), diag::warn_global_destructor);
12533 }
12534 
12535 /// \brief Given a constructor and the set of arguments provided for the
12536 /// constructor, convert the arguments and add any required default arguments
12537 /// to form a proper call to this constructor.
12538 ///
12539 /// \returns true if an error occurred, false otherwise.
12540 bool
12542  MultiExprArg ArgsPtr,
12543  SourceLocation Loc,
12544  SmallVectorImpl<Expr*> &ConvertedArgs,
12545  bool AllowExplicit,
12546  bool IsListInitialization) {
12547  // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
12548  unsigned NumArgs = ArgsPtr.size();
12549  Expr **Args = ArgsPtr.data();
12550 
12551  const FunctionProtoType *Proto
12552  = Constructor->getType()->getAs<FunctionProtoType>();
12553  assert(Proto && "Constructor without a prototype?");
12554  unsigned NumParams = Proto->getNumParams();
12555 
12556  // If too few arguments are available, we'll fill in the rest with defaults.
12557  if (NumArgs < NumParams)
12558  ConvertedArgs.reserve(NumParams);
12559  else
12560  ConvertedArgs.reserve(NumArgs);
12561 
12562  VariadicCallType CallType =
12563  Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
12564  SmallVector<Expr *, 8> AllArgs;
12565  bool Invalid = GatherArgumentsForCall(Loc, Constructor,
12566  Proto, 0,
12567  llvm::makeArrayRef(Args, NumArgs),
12568  AllArgs,
12569  CallType, AllowExplicit,
12570  IsListInitialization);
12571  ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
12572 
12573  DiagnoseSentinelCalls(Constructor, Loc, AllArgs);
12574 
12575  CheckConstructorCall(Constructor,
12576  llvm::makeArrayRef(AllArgs.data(), AllArgs.size()),
12577  Proto, Loc);
12578 
12579  return Invalid;
12580 }
12581 
12582 static inline bool
12584  const FunctionDecl *FnDecl) {
12585  const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
12586  if (isa<NamespaceDecl>(DC)) {
12587  return SemaRef.Diag(FnDecl->getLocation(),
12588  diag::err_operator_new_delete_declared_in_namespace)
12589  << FnDecl->getDeclName();
12590  }
12591 
12592  if (isa<TranslationUnitDecl>(DC) &&
12593  FnDecl->getStorageClass() == SC_Static) {
12594  return SemaRef.Diag(FnDecl->getLocation(),
12595  diag::err_operator_new_delete_declared_static)
12596  << FnDecl->getDeclName();
12597  }
12598 
12599  return false;
12600 }
12601 
12602 static inline bool
12604  CanQualType ExpectedResultType,
12605  CanQualType ExpectedFirstParamType,
12606  unsigned DependentParamTypeDiag,
12607  unsigned InvalidParamTypeDiag) {
12608  QualType ResultType =
12609  FnDecl->getType()->getAs<FunctionType>()->getReturnType();
12610 
12611  // Check that the result type is not dependent.
12612  if (ResultType->isDependentType())
12613  return SemaRef.Diag(FnDecl->getLocation(),
12614  diag::err_operator_new_delete_dependent_result_type)
12615  << FnDecl->getDeclName() << ExpectedResultType;
12616 
12617  // Check that the result type is what we expect.
12618  if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType)
12619  return SemaRef.Diag(FnDecl->getLocation(),
12620  diag::err_operator_new_delete_invalid_result_type)
12621  << FnDecl->getDeclName() << ExpectedResultType;
12622 
12623  // A function template must have at least 2 parameters.
12624  if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
12625  return SemaRef.Diag(FnDecl->getLocation(),
12626  diag::err_operator_new_delete_template_too_few_parameters)
12627  << FnDecl->getDeclName();
12628 
12629  // The function decl must have at least 1 parameter.
12630  if (FnDecl->getNumParams() == 0)
12631  return SemaRef.Diag(FnDecl->getLocation(),
12632  diag::err_operator_new_delete_too_few_parameters)
12633  << FnDecl->getDeclName();
12634 
12635  // Check the first parameter type is not dependent.
12636  QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
12637  if (FirstParamType->isDependentType())
12638  return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag)
12639  << FnDecl->getDeclName() << ExpectedFirstParamType;
12640 
12641  // Check that the first parameter type is what we expect.
12642  if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
12643  ExpectedFirstParamType)
12644  return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
12645  << FnDecl->getDeclName() << ExpectedFirstParamType;
12646 
12647  return false;
12648 }
12649 
12650 static bool
12652  // C++ [basic.stc.dynamic.allocation]p1:
12653  // A program is ill-formed if an allocation function is declared in a
12654  // namespace scope other than global scope or declared static in global
12655  // scope.
12656  if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
12657  return true;
12658 
12659  CanQualType SizeTy =
12660  SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType());
12661 
12662  // C++ [basic.stc.dynamic.allocation]p1:
12663  // The return type shall be void*. The first parameter shall have type
12664  // std::size_t.
12665  if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy,
12666  SizeTy,
12667  diag::err_operator_new_dependent_param_type,
12668  diag::err_operator_new_param_type))
12669  return true;
12670 
12671  // C++ [basic.stc.dynamic.allocation]p1:
12672  // The first parameter shall not have an associated default argument.
12673  if (FnDecl->getParamDecl(0)->hasDefaultArg())
12674  return SemaRef.Diag(FnDecl->getLocation(),
12675  diag::err_operator_new_default_arg)
12676  << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();
12677 
12678  return false;
12679 }
12680 
12681 static bool
12683  // C++ [basic.stc.dynamic.deallocation]p1:
12684  // A program is ill-formed if deallocation functions are declared in a
12685  // namespace scope other than global scope or declared static in global
12686  // scope.
12687  if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
12688  return true;
12689 
12690  auto *MD = dyn_cast<CXXMethodDecl>(FnDecl);
12691 
12692  // C++ P0722:
12693  // Within a class C, the first parameter of a destroying operator delete
12694  // shall be of type C *. The first parameter of any other deallocation
12695  // function shall be of type void *.
12696  CanQualType ExpectedFirstParamType =
12697  MD && MD->isDestroyingOperatorDelete()
12698  ? SemaRef.Context.getCanonicalType(SemaRef.Context.getPointerType(
12699  SemaRef.Context.getRecordType(MD->getParent())))
12700  : SemaRef.Context.VoidPtrTy;
12701 
12702  // C++ [basic.stc.dynamic.deallocation]p2:
12703  // Each deallocation function shall return void
12705  SemaRef, FnDecl, SemaRef.Context.VoidTy, ExpectedFirstParamType,
12706  diag::err_operator_delete_dependent_param_type,
12707  diag::err_operator_delete_param_type))
12708  return true;
12709 
12710  // C++ P0722:
12711  // A destroying operator delete shall be a usual deallocation function.
12712  if (MD && !MD->getParent()->isDependentContext() &&
12714  SemaRef.Diag(MD->getLocation(),
12715  diag::err_destroying_operator_delete_not_usual);
12716  return true;
12717  }
12718 
12719  return false;
12720 }
12721 
12722 /// CheckOverloadedOperatorDeclaration - Check whether the declaration
12723 /// of this overloaded operator is well-formed. If so, returns false;
12724 /// otherwise, emits appropriate diagnostics and returns true.
12726  assert(FnDecl && FnDecl->isOverloadedOperator() &&
12727  "Expected an overloaded operator declaration");
12728 
12730 
12731  // C++ [over.oper]p5:
12732  // The allocation and deallocation functions, operator new,
12733  // operator new[], operator delete and operator delete[], are
12734  // described completely in 3.7.3. The attributes and restrictions
12735  // found in the rest of this subclause do not apply to them unless
12736  // explicitly stated in 3.7.3.
12737  if (Op == OO_Delete || Op == OO_Array_Delete)
12738  return CheckOperatorDeleteDeclaration(*this, FnDecl);
12739 
12740  if (Op == OO_New || Op == OO_Array_New)
12741  return CheckOperatorNewDeclaration(*this, FnDecl);
12742 
12743  // C++ [over.oper]p6:
12744  // An operator function shall either be a non-static member
12745  // function or be a non-member function and have at least one
12746  // parameter whose type is a class, a reference to a class, an
12747  // enumeration, or a reference to an enumeration.
12748  if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
12749  if (MethodDecl->isStatic())
12750  return Diag(FnDecl->getLocation(),
12751  diag::err_operator_overload_static) << FnDecl->getDeclName();
12752  } else {
12753  bool ClassOrEnumParam = false;
12754  for (auto Param : FnDecl->parameters()) {
12755  QualType ParamType = Param->getType().getNonReferenceType();
12756  if (ParamType->isDependentType() || ParamType->isRecordType() ||
12757  ParamType->isEnumeralType()) {
12758  ClassOrEnumParam = true;
12759  break;
12760  }
12761  }
12762 
12763  if (!ClassOrEnumParam)
12764  return Diag(FnDecl->getLocation(),
12765  diag::err_operator_overload_needs_class_or_enum)
12766  << FnDecl->getDeclName();
12767  }
12768 
12769  // C++ [over.oper]p8:
12770  // An operator function cannot have default arguments (8.3.6),
12771  // except where explicitly stated below.
12772  //
12773  // Only the function-call operator allows default arguments
12774  // (C++ [over.call]p1).
12775  if (Op != OO_Call) {
12776  for (auto Param : FnDecl->parameters()) {
12777  if (Param->hasDefaultArg())
12778  return Diag(Param->getLocation(),
12779  diag::err_operator_overload_default_arg)
12780  << FnDecl->getDeclName() << Param->getDefaultArgRange();
12781  }
12782  }
12783 
12784  static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
12785  { false, false, false }
12786 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
12787  , { Unary, Binary, MemberOnly }
12788 #include "clang/Basic/OperatorKinds.def"
12789  };
12790 
12791  bool CanBeUnaryOperator = OperatorUses[Op][0];
12792  bool CanBeBinaryOperator = OperatorUses[Op][1];
12793  bool MustBeMemberOperator = OperatorUses[Op][2];
12794 
12795  // C++ [over.oper]p8:
12796  // [...] Operator functions cannot have more or fewer parameters
12797  // than the number required for the corresponding operator, as
12798  // described in the rest of this subclause.
12799  unsigned NumParams = FnDecl->getNumParams()
12800  + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
12801  if (Op != OO_Call &&
12802  ((NumParams == 1 && !CanBeUnaryOperator) ||
12803  (NumParams == 2 && !CanBeBinaryOperator) ||
12804  (NumParams < 1) || (NumParams > 2))) {
12805  // We have the wrong number of parameters.
12806  unsigned ErrorKind;
12807  if (CanBeUnaryOperator && CanBeBinaryOperator) {
12808  ErrorKind = 2; // 2 -> unary or binary.
12809  } else if (CanBeUnaryOperator) {
12810  ErrorKind = 0; // 0 -> unary
12811  } else {
12812  assert(CanBeBinaryOperator &&
12813  "All non-call overloaded operators are unary or binary!");
12814  ErrorKind = 1; // 1 -> binary
12815  }
12816 
12817  return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
12818  << FnDecl->getDeclName() << NumParams << ErrorKind;
12819  }
12820 
12821  // Overloaded operators other than operator() cannot be variadic.
12822  if (Op != OO_Call &&
12823  FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) {
12824  return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
12825  << FnDecl->getDeclName();
12826  }
12827 
12828  // Some operators must be non-static member functions.
12829  if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
12830  return Diag(FnDecl->getLocation(),
12831  diag::err_operator_overload_must_be_member)
12832  << FnDecl->getDeclName();
12833  }
12834 
12835  // C++ [over.inc]p1:
12836  // The user-defined function called operator++ implements the
12837  // prefix and postfix ++ operator. If this function is a member
12838  // function with no parameters, or a non-member function with one
12839  // parameter of class or enumeration type, it defines the prefix
12840  // increment operator ++ for objects of that type. If the function
12841  // is a member function with one parameter (which shall be of type
12842  // int) or a non-member function with two parameters (the second
12843  // of which shall be of type int), it defines the postfix
12844  // increment operator ++ for objects of that type.
12845  if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
12846  ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
12847  QualType ParamType = LastParam->getType();
12848 
12849  if (!ParamType->isSpecificBuiltinType(BuiltinType::Int) &&
12850  !ParamType->isDependentType())
12851  return Diag(LastParam->getLocation(),
12852  diag::err_operator_overload_post_incdec_must_be_int)
12853  << LastParam->getType() << (Op == OO_MinusMinus);
12854  }
12855 
12856  return false;
12857 }
12858 
12859 static bool
12861  FunctionTemplateDecl *TpDecl) {
12862  TemplateParameterList *TemplateParams = TpDecl->getTemplateParameters();
12863 
12864  // Must have one or two template parameters.
12865  if (TemplateParams->size() == 1) {
12866  NonTypeTemplateParmDecl *PmDecl =
12867  dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(0));
12868 
12869  // The template parameter must be a char parameter pack.
12870  if (PmDecl && PmDecl->isTemplateParameterPack() &&
12871  SemaRef.Context.hasSameType(PmDecl->getType(), SemaRef.Context.CharTy))
12872  return false;
12873 
12874  } else if (TemplateParams->size() == 2) {
12875  TemplateTypeParmDecl *PmType =
12876  dyn_cast<TemplateTypeParmDecl>(TemplateParams->getParam(0));
12877  NonTypeTemplateParmDecl *PmArgs =
12878  dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(1));
12879 
12880  // The second template parameter must be a parameter pack with the
12881  // first template parameter as its type.
12882  if (PmType && PmArgs && !PmType->isTemplateParameterPack() &&
12883  PmArgs->isTemplateParameterPack()) {
12884  const TemplateTypeParmType *TArgs =
12885  PmArgs->getType()->getAs<TemplateTypeParmType>();
12886  if (TArgs && TArgs->getDepth() == PmType->getDepth() &&
12887  TArgs->getIndex() == PmType->getIndex()) {
12888  if (!SemaRef.inTemplateInstantiation())
12889  SemaRef.Diag(TpDecl->getLocation(),
12890  diag::ext_string_literal_operator_template);
12891  return false;
12892  }
12893  }
12894  }
12895 
12896  SemaRef.Diag(TpDecl->getTemplateParameters()->getSourceRange().getBegin(),
12897  diag::err_literal_operator_template)
12898  << TpDecl->getTemplateParameters()->getSourceRange();
12899  return true;
12900 }
12901 
12902 /// CheckLiteralOperatorDeclaration - Check whether the declaration
12903 /// of this literal operator function is well-formed. If so, returns
12904 /// false; otherwise, emits appropriate diagnostics and returns true.
12906  if (isa<CXXMethodDecl>(FnDecl)) {
12907  Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
12908  << FnDecl->getDeclName();
12909  return true;
12910  }
12911 
12912  if (FnDecl->isExternC()) {
12913  Diag(FnDecl->getLocation(), diag::err_literal_operator_extern_c);
12914  if (const LinkageSpecDecl *LSD =
12915  FnDecl->getDeclContext()->getExternCContext())
12916  Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
12917  return true;
12918  }
12919 
12920  // This might be the definition of a literal operator template.
12922 
12923  // This might be a specialization of a literal operator template.
12924  if (!TpDecl)
12925  TpDecl = FnDecl->getPrimaryTemplate();
12926 
12927  // template <char...> type operator "" name() and
12928  // template <class T, T...> type operator "" name() are the only valid
12929  // template signatures, and the only valid signatures with no parameters.
12930  if (TpDecl) {
12931  if (FnDecl->param_size() != 0) {
12932  Diag(FnDecl->getLocation(),
12933  diag::err_literal_operator_template_with_params);
12934  return true;
12935  }
12936 
12937  if (checkLiteralOperatorTemplateParameterList(*this, TpDecl))
12938  return true;
12939 
12940  } else if (FnDecl->param_size() == 1) {
12941  const ParmVarDecl *Param = FnDecl->getParamDecl(0);
12942 
12943  QualType ParamType = Param->getType().getUnqualifiedType();
12944 
12945  // Only unsigned long long int, long double, any character type, and const
12946  // char * are allowed as the only parameters.
12947  if (ParamType->isSpecificBuiltinType(BuiltinType::ULongLong) ||
12948  ParamType->isSpecificBuiltinType(BuiltinType::LongDouble) ||
12949  Context.hasSameType(ParamType, Context.CharTy) ||
12950  Context.hasSameType(ParamType, Context.WideCharTy) ||
12951  Context.hasSameType(ParamType, Context.Char16Ty) ||
12952  Context.hasSameType(ParamType, Context.Char32Ty)) {
12953  } else if (const PointerType *Ptr = ParamType->getAs<PointerType>()) {
12954  QualType InnerType = Ptr->getPointeeType();
12955 
12956  // Pointer parameter must be a const char *.
12957  if (!(Context.hasSameType(InnerType.getUnqualifiedType(),
12958  Context.CharTy) &&
12959  InnerType.isConstQualified() && !InnerType.isVolatileQualified())) {
12960  Diag(Param->getSourceRange().getBegin(),
12961  diag::err_literal_operator_param)
12962  << ParamType << "'const char *'" << Param->getSourceRange();
12963  return true;
12964  }
12965 
12966  } else if (ParamType->isRealFloatingType()) {
12967  Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
12968  << ParamType << Context.LongDoubleTy << Param->getSourceRange();
12969  return true;
12970 
12971  } else if (ParamType->isIntegerType()) {
12972  Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
12973  << ParamType << Context.UnsignedLongLongTy << Param->getSourceRange();
12974  return true;
12975 
12976  } else {
12977  Diag(Param->getSourceRange().getBegin(),
12978  diag::err_literal_operator_invalid_param)
12979  << ParamType << Param->getSourceRange();
12980  return true;
12981  }
12982 
12983  } else if (FnDecl->param_size() == 2) {
12984  FunctionDecl::param_iterator Param = FnDecl->param_begin();
12985 
12986  // First, verify that the first parameter is correct.
12987 
12988  QualType FirstParamType = (*Param)->getType().getUnqualifiedType();
12989 
12990  // Two parameter function must have a pointer to const as a
12991  // first parameter; let's strip those qualifiers.
12992  const PointerType *PT = FirstParamType->getAs<PointerType>();
12993 
12994  if (!PT) {
12995  Diag((*Param)->getSourceRange().getBegin(),
12996  diag::err_literal_operator_param)
12997  << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
12998  return true;
12999  }
13000 
13001  QualType PointeeType = PT->getPointeeType();
13002  // First parameter must be const
13003  if (!PointeeType.isConstQualified() || PointeeType.isVolatileQualified()) {
13004  Diag((*Param)->getSourceRange().getBegin(),
13005  diag::err_literal_operator_param)
13006  << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
13007  return true;
13008  }
13009 
13010  QualType InnerType = PointeeType.getUnqualifiedType();
13011  // Only const char *, const wchar_t*, const char16_t*, and const char32_t*
13012  // are allowed as the first parameter to a two-parameter function
13013  if (!(Context.hasSameType(InnerType, Context.CharTy) ||
13014  Context.hasSameType(InnerType, Context.WideCharTy) ||
13015  Context.hasSameType(InnerType, Context.Char16Ty) ||
13016  Context.hasSameType(InnerType, Context.Char32Ty))) {
13017  Diag((*Param)->getSourceRange().getBegin(),
13018  diag::err_literal_operator_param)
13019  << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
13020  return true;
13021  }
13022 
13023  // Move on to the second and final parameter.
13024  ++Param;
13025 
13026  // The second parameter must be a std::size_t.
13027  QualType SecondParamType = (*Param)->getType().getUnqualifiedType();
13028  if (!Context.hasSameType(SecondParamType, Context.getSizeType())) {
13029  Diag((*Param)->getSourceRange().getBegin(),
13030  diag::err_literal_operator_param)
13031  << SecondParamType << Context.getSizeType()
13032  << (*Param)->getSourceRange();
13033  return true;
13034  }
13035  } else {
13036  Diag(FnDecl->getLocation(), diag::err_literal_operator_bad_param_count);
13037  return true;
13038  }
13039 
13040  // Parameters are good.
13041 
13042  // A parameter-declaration-clause containing a default argument is not
13043  // equivalent to any of the permitted forms.
13044  for (auto Param : FnDecl->parameters()) {
13045  if (Param->hasDefaultArg()) {
13046  Diag(Param->getDefaultArgRange().getBegin(),
13047  diag::err_literal_operator_default_argument)
13048  << Param->getDefaultArgRange();
13049  break;
13050  }
13051  }
13052 
13053  StringRef LiteralName
13054  = FnDecl->getDeclName().getCXXLiteralIdentifier()->getName();
13055  if (LiteralName[0] != '_' &&
13056  !getSourceManager().isInSystemHeader(FnDecl->getLocation())) {
13057  // C++11 [usrlit.suffix]p1:
13058  // Literal suffix identifiers that do not start with an underscore
13059  // are reserved for future standardization.
13060  Diag(FnDecl->getLocation(), diag::warn_user_literal_reserved)
13061  << StringLiteralParser::isValidUDSuffix(getLangOpts(), LiteralName);
13062  }
13063 
13064  return false;
13065 }
13066 
13067 /// ActOnStartLinkageSpecification - Parsed the beginning of a C++
13068 /// linkage specification, including the language and (if present)
13069 /// the '{'. ExternLoc is the location of the 'extern', Lang is the
13070 /// language string literal. LBraceLoc, if valid, provides the location of
13071 /// the '{' brace. Otherwise, this linkage specification does not
13072 /// have any braces.
13074  Expr *LangStr,
13075  SourceLocation LBraceLoc) {
13076  StringLiteral *Lit = cast<StringLiteral>(LangStr);
13077  if (!Lit->isAscii()) {
13078  Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_not_ascii)
13079  << LangStr->getSourceRange();
13080  return nullptr;
13081  }
13082 
13083  StringRef Lang = Lit->getString();
13085  if (Lang == "C")
13086  Language = LinkageSpecDecl::lang_c;
13087  else if (Lang == "C++")
13088  Language = LinkageSpecDecl::lang_cxx;
13089  else {
13090  Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_unknown)
13091  << LangStr->getSourceRange();
13092  return nullptr;
13093  }
13094 
13095  // FIXME: Add all the various semantics of linkage specifications
13096 
13097  LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext, ExternLoc,
13098  LangStr->getExprLoc(), Language,
13099  LBraceLoc.isValid());
13100  CurContext->addDecl(D);
13101  PushDeclContext(S, D);
13102  return D;
13103 }
13104 
13105 /// ActOnFinishLinkageSpecification - Complete the definition of
13106 /// the C++ linkage specification LinkageSpec. If RBraceLoc is
13107 /// valid, it's the position of the closing '}' brace in a linkage
13108 /// specification that uses braces.
13110  Decl *LinkageSpec,
13111  SourceLocation RBraceLoc) {
13112  if (RBraceLoc.isValid()) {
13113  LinkageSpecDecl* LSDecl = cast<LinkageSpecDecl>(LinkageSpec);
13114  LSDecl->setRBraceLoc(RBraceLoc);
13115  }
13116  PopDeclContext();
13117  return LinkageSpec;
13118 }
13119 
13121  AttributeList *AttrList,
13122  SourceLocation SemiLoc) {
13123  Decl *ED = EmptyDecl::Create(Context, CurContext, SemiLoc);
13124  // Attribute declarations appertain to empty declaration so we handle
13125  // them here.
13126  if (AttrList)
13127  ProcessDeclAttributeList(S, ED, AttrList);
13128 
13129  CurContext->addDecl(ED);
13130  return ED;
13131 }
13132 
13133 /// \brief Perform semantic analysis for the variable declaration that
13134 /// occurs within a C++ catch clause, returning the newly-created
13135 /// variable.
13137  TypeSourceInfo *TInfo,
13138  SourceLocation StartLoc,
13139  SourceLocation Loc,
13140  IdentifierInfo *Name) {
13141  bool Invalid = false;
13142  QualType ExDeclType = TInfo->getType();
13143 
13144  // Arrays and functions decay.
13145  if (ExDeclType->isArrayType())
13146  ExDeclType = Context.getArrayDecayedType(ExDeclType);
13147  else if (ExDeclType->isFunctionType())
13148  ExDeclType = Context.getPointerType(ExDeclType);
13149 
13150  // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
13151  // The exception-declaration shall not denote a pointer or reference to an
13152  // incomplete type, other than [cv] void*.
13153  // N2844 forbids rvalue references.
13154  if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
13155  Diag(Loc, diag::err_catch_rvalue_ref);
13156  Invalid = true;
13157  }
13158 
13159  if (ExDeclType->isVariablyModifiedType()) {
13160  Diag(Loc, diag::err_catch_variably_modified) << ExDeclType;
13161  Invalid = true;
13162  }
13163 
13164  QualType BaseType = ExDeclType;
13165  int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
13166  unsigned DK = diag::err_catch_incomplete;
13167  if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
13168  BaseType = Ptr->getPointeeType();
13169  Mode = 1;
13170  DK = diag::err_catch_incomplete_ptr;
13171  } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
13172  // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
13173  BaseType = Ref->getPointeeType();
13174  Mode = 2;
13175  DK = diag::err_catch_incomplete_ref;
13176  }
13177  if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
13178  !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
13179  Invalid = true;
13180 
13181  if (!Invalid && !ExDeclType->isDependentType() &&
13182  RequireNonAbstractType(Loc, ExDeclType,
13183  diag::err_abstract_type_in_decl,
13184  AbstractVariableType))
13185  Invalid = true;
13186 
13187  // Only the non-fragile NeXT runtime currently supports C++ catches
13188  // of ObjC types, and no runtime supports catching ObjC types by value.
13189  if (!Invalid && getLangOpts().ObjC1) {
13190  QualType T = ExDeclType;
13191  if (const ReferenceType *RT = T->getAs<ReferenceType>())
13192  T = RT->getPointeeType();
13193 
13194  if (T->isObjCObjectType()) {
13195  Diag(Loc, diag::err_objc_object_catch);
13196  Invalid = true;
13197  } else if (T->isObjCObjectPointerType()) {
13198  // FIXME: should this be a test for macosx-fragile specifically?
13199  if (getLangOpts().ObjCRuntime.isFragile())
13200  Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
13201  }
13202  }
13203 
13204  VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
13205  ExDeclType, TInfo, SC_None);
13206  ExDecl->setExceptionVariable(true);
13207 
13208  // In ARC, infer 'retaining' for variables of retainable type.
13209  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(ExDecl))
13210  Invalid = true;
13211 
13212  if (!Invalid && !ExDeclType->isDependentType()) {
13213  if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) {
13214  // Insulate this from anything else we might currently be parsing.
13216  *this, ExpressionEvaluationContext::PotentiallyEvaluated);
13217 
13218  // C++ [except.handle]p16:
13219  // The object declared in an exception-declaration or, if the
13220  // exception-declaration does not specify a name, a temporary (12.2) is
13221  // copy-initialized (8.5) from the exception object. [...]
13222  // The object is destroyed when the handler exits, after the destruction
13223  // of any automatic objects initialized within the handler.
13224  //
13225  // We just pretend to initialize the object with itself, then make sure
13226  // it can be destroyed later.
13227  QualType initType = Context.getExceptionObjectType(ExDeclType);
13228 
13229  InitializedEntity entity =
13231  InitializationKind initKind =
13233 
13234  Expr *opaqueValue =
13235  new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary);
13236  InitializationSequence sequence(*this, entity, initKind, opaqueValue);
13237  ExprResult result = sequence.Perform(*this, entity, initKind, opaqueValue);
13238  if (result.isInvalid())
13239  Invalid = true;
13240  else {
13241  // If the constructor used was non-trivial, set this as the
13242  // "initializer".
13243  CXXConstructExpr *construct = result.getAs<CXXConstructExpr>();
13244  if (!construct->getConstructor()->isTrivial()) {
13245  Expr *init = MaybeCreateExprWithCleanups(construct);
13246  ExDecl->setInit(init);
13247  }
13248 
13249  // And make sure it's destructable.
13250  FinalizeVarWithDestructor(ExDecl, recordType);
13251  }
13252  }
13253  }
13254 
13255  if (Invalid)
13256  ExDecl->setInvalidDecl();
13257 
13258  return ExDecl;
13259 }
13260 
13261 /// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
13262 /// handler.
13264  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
13265  bool Invalid = D.isInvalidType();
13266 
13267  // Check for unexpanded parameter packs.
13268  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
13269  UPPC_ExceptionType)) {
13270  TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
13271  D.getIdentifierLoc());
13272  Invalid = true;
13273  }
13274 
13275  IdentifierInfo *II = D.getIdentifier();
13276  if (NamedDecl *PrevDecl = LookupSingleName(S, II, D.getIdentifierLoc(),
13277  LookupOrdinaryName,
13278  ForVisibleRedeclaration)) {
13279  // The scope should be freshly made just for us. There is just no way
13280  // it contains any previous declaration, except for function parameters in
13281  // a function-try-block's catch statement.
13282  assert(!S->isDeclScope(PrevDecl));
13283  if (isDeclInScope(PrevDecl, CurContext, S)) {
13284  Diag(D.getIdentifierLoc(), diag::err_redefinition)
13285  << D.getIdentifier();
13286  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
13287  Invalid = true;
13288  } else if (PrevDecl->isTemplateParameter())
13289  // Maybe we will complain about the shadowed template parameter.
13290  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
13291  }
13292 
13293  if (D.getCXXScopeSpec().isSet() && !Invalid) {
13294  Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
13295  << D.getCXXScopeSpec().getRange();
13296  Invalid = true;
13297  }
13298 
13299  VarDecl *ExDecl = BuildExceptionDeclaration(S, TInfo,
13300  D.getLocStart(),
13301  D.getIdentifierLoc(),
13302  D.getIdentifier());
13303  if (Invalid)
13304  ExDecl->setInvalidDecl();
13305 
13306  // Add the exception declaration into this scope.
13307  if (II)
13308  PushOnScopeChains(ExDecl, S);
13309  else
13310  CurContext->addDecl(ExDecl);
13311 
13312  ProcessDeclAttributes(S, ExDecl, D);
13313  return ExDecl;
13314 }
13315 
13317  Expr *AssertExpr,
13318  Expr *AssertMessageExpr,
13319  SourceLocation RParenLoc) {
13320  StringLiteral *AssertMessage =
13321  AssertMessageExpr ? cast<StringLiteral>(AssertMessageExpr) : nullptr;
13322 
13323  if (DiagnoseUnexpandedParameterPack(AssertExpr, UPPC_StaticAssertExpression))
13324  return nullptr;
13325 
13326  return BuildStaticAssertDeclaration(StaticAssertLoc, AssertExpr,
13327  AssertMessage, RParenLoc, false);
13328 }
13329 
13331  Expr *AssertExpr,
13332  StringLiteral *AssertMessage,
13333  SourceLocation RParenLoc,
13334  bool Failed) {
13335  assert(AssertExpr != nullptr && "Expected non-null condition");
13336  if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent() &&
13337  !Failed) {
13338  // In a static_assert-declaration, the constant-expression shall be a
13339  // constant expression that can be contextually converted to bool.
13340  ExprResult Converted = PerformContextuallyConvertToBool(AssertExpr);
13341  if (Converted.isInvalid())
13342  Failed = true;
13343 
13344  llvm::APSInt Cond;
13345  if (!Failed && VerifyIntegerConstantExpression(Converted.get(), &Cond,
13346  diag::err_static_assert_expression_is_not_constant,
13347  /*AllowFold=*/false).isInvalid())
13348  Failed = true;
13349 
13350  if (!Failed && !Cond) {
13351  SmallString<256> MsgBuffer;
13352  llvm::raw_svector_ostream Msg(MsgBuffer);
13353  if (AssertMessage)
13354  AssertMessage->printPretty(Msg, nullptr, getPrintingPolicy());
13355 
13356  Expr *InnerCond = nullptr;
13357  std::string InnerCondDescription;
13358  std::tie(InnerCond, InnerCondDescription) =
13359  findFailedBooleanCondition(Converted.get(),
13360  /*AllowTopLevelCond=*/false);
13361  if (InnerCond) {
13362  Diag(StaticAssertLoc, diag::err_static_assert_requirement_failed)
13363  << InnerCondDescription << !AssertMessage
13364  << Msg.str() << InnerCond->getSourceRange();
13365  } else {
13366  Diag(StaticAssertLoc, diag::err_static_assert_failed)
13367  << !AssertMessage << Msg.str() << AssertExpr->getSourceRange();
13368  }
13369  Failed = true;
13370  }
13371  }
13372 
13373  ExprResult FullAssertExpr = ActOnFinishFullExpr(AssertExpr, StaticAssertLoc,
13374  /*DiscardedValue*/false,
13375  /*IsConstexpr*/true);
13376  if (FullAssertExpr.isInvalid())
13377  Failed = true;
13378  else
13379  AssertExpr = FullAssertExpr.get();
13380 
13381  Decl *Decl = StaticAssertDecl::Create(Context, CurContext, StaticAssertLoc,
13382  AssertExpr, AssertMessage, RParenLoc,
13383  Failed);
13384 
13385  CurContext->addDecl(Decl);
13386  return Decl;
13387 }
13388 
13389 /// \brief Perform semantic analysis of the given friend type declaration.
13390 ///
13391 /// \returns A friend declaration that.
13393  SourceLocation FriendLoc,
13394  TypeSourceInfo *TSInfo) {
13395  assert(TSInfo && "NULL TypeSourceInfo for friend type declaration");
13396 
13397  QualType T = TSInfo->getType();
13398  SourceRange TypeRange = TSInfo->getTypeLoc().getLocalSourceRange();
13399 
13400  // C++03 [class.friend]p2:
13401  // An elaborated-type-specifier shall be used in a friend declaration
13402  // for a class.*
13403  //
13404  // * The class-key of the elaborated-type-specifier is required.
13405  if (!CodeSynthesisContexts.empty()) {
13406  // Do not complain about the form of friend template types during any kind
13407  // of code synthesis. For template instantiation, we will have complained
13408  // when the template was defined.
13409  } else {
13410  if (!T->isElaboratedTypeSpecifier()) {
13411  // If we evaluated the type to a record type, suggest putting
13412  // a tag in front.
13413  if (const RecordType *RT = T->getAs<RecordType>()) {
13414  RecordDecl *RD = RT->getDecl();
13415 
13416  SmallString<16> InsertionText(" ");
13417  InsertionText += RD->getKindName();
13418 
13419  Diag(TypeRange.getBegin(),
13420  getLangOpts().CPlusPlus11 ?
13421  diag::warn_cxx98_compat_unelaborated_friend_type :
13422  diag::ext_unelaborated_friend_type)
13423  << (unsigned) RD->getTagKind()
13424  << T
13425  << FixItHint::CreateInsertion(getLocForEndOfToken(FriendLoc),
13426  InsertionText);
13427  } else {
13428  Diag(FriendLoc,
13429  getLangOpts().CPlusPlus11 ?
13430  diag::warn_cxx98_compat_nonclass_type_friend :
13431  diag::ext_nonclass_type_friend)
13432  << T
13433  << TypeRange;
13434  }
13435  } else if (T->getAs<EnumType>()) {
13436  Diag(FriendLoc,
13437  getLangOpts().CPlusPlus11 ?
13438  diag::warn_cxx98_compat_enum_friend :
13439  diag::ext_enum_friend)
13440  << T
13441  << TypeRange;
13442  }
13443 
13444  // C++11 [class.friend]p3:
13445  // A friend declaration that does not declare a function shall have one
13446  // of the following forms:
13447  // friend elaborated-type-specifier ;
13448  // friend simple-type-specifier ;
13449  // friend typename-specifier ;
13450  if (getLangOpts().CPlusPlus11 && LocStart != FriendLoc)
13451  Diag(FriendLoc, diag::err_friend_not_first_in_declaration) << T;
13452  }
13453 
13454  // If the type specifier in a friend declaration designates a (possibly
13455  // cv-qualified) class type, that class is declared as a friend; otherwise,
13456  // the friend declaration is ignored.
13457  return FriendDecl::Create(Context, CurContext,
13458  TSInfo->getTypeLoc().getLocStart(), TSInfo,
13459  FriendLoc);
13460 }
13461 
13462 /// Handle a friend tag declaration where the scope specifier was
13463 /// templated.
13465  unsigned TagSpec, SourceLocation TagLoc,
13466  CXXScopeSpec &SS,
13467  IdentifierInfo *Name,
13468  SourceLocation NameLoc,
13470  MultiTemplateParamsArg TempParamLists) {
13472 
13473  bool IsMemberSpecialization = false;
13474  bool Invalid = false;
13475 
13476  if (TemplateParameterList *TemplateParams =
13477  MatchTemplateParametersToScopeSpecifier(
13478  TagLoc, NameLoc, SS, nullptr, TempParamLists, /*friend*/ true,
13479  IsMemberSpecialization, Invalid)) {
13480  if (TemplateParams->size() > 0) {
13481  // This is a declaration of a class template.
13482  if (Invalid)
13483  return nullptr;
13484 
13485  return CheckClassTemplate(S, TagSpec, TUK_Friend, TagLoc, SS, Name,
13486  NameLoc, Attr, TemplateParams, AS_public,
13487  /*ModulePrivateLoc=*/SourceLocation(),
13488  FriendLoc, TempParamLists.size() - 1,
13489  TempParamLists.data()).get();
13490  } else {
13491  // The "template<>" header is extraneous.
13492  Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
13493  << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
13494  IsMemberSpecialization = true;
13495  }
13496  }
13497 
13498  if (Invalid) return nullptr;
13499 
13500  bool isAllExplicitSpecializations = true;
13501  for (unsigned I = TempParamLists.size(); I-- > 0; ) {
13502  if (TempParamLists[I]->size()) {
13503  isAllExplicitSpecializations = false;
13504  break;
13505  }
13506  }
13507 
13508  // FIXME: don't ignore attributes.
13509 
13510  // If it's explicit specializations all the way down, just forget
13511  // about the template header and build an appropriate non-templated
13512  // friend. TODO: for source fidelity, remember the headers.
13513  if (isAllExplicitSpecializations) {
13514  if (SS.isEmpty()) {
13515  bool Owned = false;
13516  bool IsDependent = false;
13517  return ActOnTag(S, TagSpec, TUK_Friend, TagLoc, SS, Name, NameLoc,
13518  Attr, AS_public,
13519  /*ModulePrivateLoc=*/SourceLocation(),
13520  MultiTemplateParamsArg(), Owned, IsDependent,
13521  /*ScopedEnumKWLoc=*/SourceLocation(),
13522  /*ScopedEnumUsesClassTag=*/false,
13523  /*UnderlyingType=*/TypeResult(),
13524  /*IsTypeSpecifier=*/false,
13525  /*IsTemplateParamOrArg=*/false);
13526  }
13527 
13528  NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
13529  ElaboratedTypeKeyword Keyword
13531  QualType T = CheckTypenameType(Keyword, TagLoc, QualifierLoc,
13532  *Name, NameLoc);
13533  if (T.isNull())
13534  return nullptr;
13535 
13536  TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
13537  if (isa<DependentNameType>(T)) {
13540  TL.setElaboratedKeywordLoc(TagLoc);
13541  TL.setQualifierLoc(QualifierLoc);
13542  TL.setNameLoc(NameLoc);
13543  } else {
13545  TL.setElaboratedKeywordLoc(TagLoc);
13546  TL.setQualifierLoc(QualifierLoc);
13547  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(NameLoc);
13548  }
13549 
13550  FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
13551  TSI, FriendLoc, TempParamLists);
13552  Friend->setAccess(AS_public);
13553  CurContext->addDecl(Friend);
13554  return Friend;
13555  }
13556 
13557  assert(SS.isNotEmpty() && "valid templated tag with no SS and no direct?");
13558 
13559 
13560 
13561  // Handle the case of a templated-scope friend class. e.g.
13562  // template <class T> class A<T>::B;
13563  // FIXME: we don't support these right now.
13564  Diag(NameLoc, diag::warn_template_qualified_friend_unsupported)
13565  << SS.getScopeRep() << SS.getRange() << cast<CXXRecordDecl>(CurContext);
13567  QualType T = Context.getDependentNameType(ETK, SS.getScopeRep(), Name);
13568  TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
13570  TL.setElaboratedKeywordLoc(TagLoc);
13571  TL.setQualifierLoc(SS.getWithLocInContext(Context));
13572  TL.setNameLoc(NameLoc);
13573 
13574  FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
13575  TSI, FriendLoc, TempParamLists);
13576  Friend->setAccess(AS_public);
13577  Friend->setUnsupportedFriend(true);
13578  CurContext->addDecl(Friend);
13579  return Friend;
13580 }
13581 
13582 
13583 /// Handle a friend type declaration. This works in tandem with
13584 /// ActOnTag.
13585 ///
13586 /// Notes on friend class templates:
13587 ///
13588 /// We generally treat friend class declarations as if they were
13589 /// declaring a class. So, for example, the elaborated type specifier
13590 /// in a friend declaration is required to obey the restrictions of a
13591 /// class-head (i.e. no typedefs in the scope chain), template
13592 /// parameters are required to match up with simple template-ids, &c.
13593 /// However, unlike when declaring a template specialization, it's
13594 /// okay to refer to a template specialization without an empty
13595 /// template parameter declaration, e.g.
13596 /// friend class A<T>::B<unsigned>;
13597 /// We permit this as a special case; if there are any template
13598 /// parameters present at all, require proper matching, i.e.
13599 /// template <> template <class T> friend class A<int>::B;
13601  MultiTemplateParamsArg TempParams) {
13602  SourceLocation Loc = DS.getLocStart();
13603 
13604  assert(DS.isFriendSpecified());
13606 
13607  // Try to convert the decl specifier to a type. This works for
13608  // friend templates because ActOnTag never produces a ClassTemplateDecl
13609  // for a TUK_Friend.
13610  Declarator TheDeclarator(DS, DeclaratorContext::MemberContext);
13611  TypeSourceInfo *TSI = GetTypeForDeclarator(TheDeclarator, S);
13612  QualType T = TSI->getType();
13613  if (TheDeclarator.isInvalidType())
13614  return nullptr;
13615 
13616  if (DiagnoseUnexpandedParameterPack(Loc, TSI, UPPC_FriendDeclaration))
13617  return nullptr;
13618 
13619  // This is definitely an error in C++98. It's probably meant to
13620  // be forbidden in C++0x, too, but the specification is just
13621  // poorly written.
13622  //
13623  // The problem is with declarations like the following:
13624  // template <T> friend A<T>::foo;
13625  // where deciding whether a class C is a friend or not now hinges
13626  // on whether there exists an instantiation of A that causes
13627  // 'foo' to equal C. There are restrictions on class-heads
13628  // (which we declare (by fiat) elaborated friend declarations to
13629  // be) that makes this tractable.
13630  //
13631  // FIXME: handle "template <> friend class A<T>;", which
13632  // is possibly well-formed? Who even knows?
13633  if (TempParams.size() && !T->isElaboratedTypeSpecifier()) {
13634  Diag(Loc, diag::err_tagless_friend_type_template)
13635  << DS.getSourceRange();
13636  return nullptr;
13637  }
13638 
13639  // C++98 [class.friend]p1: A friend of a class is a function
13640  // or class that is not a member of the class . . .
13641  // This is fixed in DR77, which just barely didn't make the C++03
13642  // deadline. It's also a very silly restriction that seriously
13643  // affects inner classes and which nobody else seems to implement;
13644  // thus we never diagnose it, not even in -pedantic.
13645  //
13646  // But note that we could warn about it: it's always useless to
13647  // friend one of your own members (it's not, however, worthless to
13648  // friend a member of an arbitrary specialization of your template).
13649 
13650  Decl *D;
13651  if (!TempParams.empty())
13652  D = FriendTemplateDecl::Create(Context, CurContext, Loc,
13653  TempParams,
13654  TSI,
13655  DS.getFriendSpecLoc());
13656  else
13657  D = CheckFriendTypeDecl(Loc, DS.getFriendSpecLoc(), TSI);
13658 
13659  if (!D)
13660  return nullptr;
13661 
13662  D->setAccess(AS_public);
13663  CurContext->addDecl(D);
13664 
13665  return D;
13666 }
13667 
13669  MultiTemplateParamsArg TemplateParams) {
13670  const DeclSpec &DS = D.getDeclSpec();
13671 
13672  assert(DS.isFriendSpecified());
13674 
13675  SourceLocation Loc = D.getIdentifierLoc();
13676  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
13677 
13678  // C++ [class.friend]p1
13679  // A friend of a class is a function or class....
13680  // Note that this sees through typedefs, which is intended.
13681  // It *doesn't* see through dependent types, which is correct
13682  // according to [temp.arg.type]p3:
13683  // If a declaration acquires a function type through a
13684  // type dependent on a template-parameter and this causes
13685  // a declaration that does not use the syntactic form of a
13686  // function declarator to have a function type, the program
13687  // is ill-formed.
13688  if (!TInfo->getType()->isFunctionType()) {
13689  Diag(Loc, diag::err_unexpected_friend);
13690 
13691  // It might be worthwhile to try to recover by creating an
13692  // appropriate declaration.
13693  return nullptr;
13694  }
13695 
13696  // C++ [namespace.memdef]p3
13697  // - If a friend declaration in a non-local class first declares a
13698  // class or function, the friend class or function is a member
13699  // of the innermost enclosing namespace.
13700  // - The name of the friend is not found by simple name lookup
13701  // until a matching declaration is provided in that namespace
13702  // scope (either before or after the class declaration granting
13703  // friendship).
13704  // - If a friend function is called, its name may be found by the
13705  // name lookup that considers functions from namespaces and
13706  // classes associated with the types of the function arguments.
13707  // - When looking for a prior declaration of a class or a function
13708  // declared as a friend, scopes outside the innermost enclosing
13709  // namespace scope are not considered.
13710 
13711  CXXScopeSpec &SS = D.getCXXScopeSpec();
13712  DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
13713  DeclarationName Name = NameInfo.getName();
13714  assert(Name);
13715 
13716  // Check for unexpanded parameter packs.
13717  if (DiagnoseUnexpandedParameterPack(Loc, TInfo, UPPC_FriendDeclaration) ||
13718  DiagnoseUnexpandedParameterPack(NameInfo, UPPC_FriendDeclaration) ||
13719  DiagnoseUnexpandedParameterPack(SS, UPPC_FriendDeclaration))
13720  return nullptr;
13721 
13722  // The context we found the declaration in, or in which we should
13723  // create the declaration.
13724  DeclContext *DC;
13725  Scope *DCScope = S;
13726  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
13727  ForExternalRedeclaration);
13728 
13729  // There are five cases here.
13730  // - There's no scope specifier and we're in a local class. Only look
13731  // for functions declared in the immediately-enclosing block scope.
13732  // We recover from invalid scope qualifiers as if they just weren't there.
13733  FunctionDecl *FunctionContainingLocalClass = nullptr;
13734  if ((SS.isInvalid() || !SS.isSet()) &&
13735  (FunctionContainingLocalClass =
13736  cast<CXXRecordDecl>(CurContext)->isLocalClass())) {
13737  // C++11 [class.friend]p11:
13738  // If a friend declaration appears in a local class and the name
13739  // specified is an unqualified name, a prior declaration is
13740  // looked up without considering scopes that are outside the
13741  // innermost enclosing non-class scope. For a friend function
13742  // declaration, if there is no prior declaration, the program is
13743  // ill-formed.
13744 
13745  // Find the innermost enclosing non-class scope. This is the block
13746  // scope containing the local class definition (or for a nested class,
13747  // the outer local class).
13748  DCScope = S->getFnParent();
13749 
13750  // Look up the function name in the scope.
13751  Previous.clear(LookupLocalFriendName);
13752  LookupName(Previous, S, /*AllowBuiltinCreation*/false);
13753 
13754  if (!Previous.empty()) {
13755  // All possible previous declarations must have the same context:
13756  // either they were declared at block scope or they are members of
13757  // one of the enclosing local classes.
13758  DC = Previous.getRepresentativeDecl()->getDeclContext();
13759  } else {
13760  // This is ill-formed, but provide the context that we would have
13761  // declared the function in, if we were permitted to, for error recovery.
13762  DC = FunctionContainingLocalClass;
13763  }
13764  adjustContextForLocalExternDecl(DC);
13765 
13766  // C++ [class.friend]p6:
13767  // A function can be defined in a friend declaration of a class if and
13768  // only if the class is a non-local class (9.8), the function name is
13769  // unqualified, and the function has namespace scope.
13770  if (D.isFunctionDefinition()) {
13771  Diag(NameInfo.getBeginLoc(), diag::err_friend_def_in_local_class);
13772  }
13773 
13774  // - There's no scope specifier, in which case we just go to the
13775  // appropriate scope and look for a function or function template
13776  // there as appropriate.
13777  } else if (SS.isInvalid() || !SS.isSet()) {
13778  // C++11 [namespace.memdef]p3:
13779  // If the name in a friend declaration is neither qualified nor
13780  // a template-id and the declaration is a function or an
13781  // elaborated-type-specifier, the lookup to determine whether
13782  // the entity has been previously declared shall not consider
13783  // any scopes outside the innermost enclosing namespace.
13784  bool isTemplateId =
13786 
13787  // Find the appropriate context according to the above.
13788  DC = CurContext;
13789 
13790  // Skip class contexts. If someone can cite chapter and verse
13791  // for this behavior, that would be nice --- it's what GCC and
13792  // EDG do, and it seems like a reasonable intent, but the spec
13793  // really only says that checks for unqualified existing
13794  // declarations should stop at the nearest enclosing namespace,
13795  // not that they should only consider the nearest enclosing
13796  // namespace.
13797  while (DC->isRecord())
13798  DC = DC->getParent();
13799 
13800  DeclContext *LookupDC = DC;
13801  while (LookupDC->isTransparentContext())
13802  LookupDC = LookupDC->getParent();
13803 
13804  while (true) {
13805  LookupQualifiedName(Previous, LookupDC);
13806 
13807  if (!Previous.empty()) {
13808  DC = LookupDC;
13809  break;
13810  }
13811 
13812  if (isTemplateId) {
13813  if (isa<TranslationUnitDecl>(LookupDC)) break;
13814  } else {
13815  if (LookupDC->isFileContext()) break;
13816  }
13817  LookupDC = LookupDC->getParent();
13818  }
13819 
13820  DCScope = getScopeForDeclContext(S, DC);
13821 
13822  // - There's a non-dependent scope specifier, in which case we
13823  // compute it and do a previous lookup there for a function
13824  // or function template.
13825  } else if (!SS.getScopeRep()->isDependent()) {
13826  DC = computeDeclContext(SS);
13827  if (!DC) return nullptr;
13828 
13829  if (RequireCompleteDeclContext(SS, DC)) return nullptr;
13830 
13831  LookupQualifiedName(Previous, DC);
13832 
13833  // Ignore things found implicitly in the wrong scope.
13834  // TODO: better diagnostics for this case. Suggesting the right
13835  // qualified scope would be nice...
13836  LookupResult::Filter F = Previous.makeFilter();
13837  while (F.hasNext()) {
13838  NamedDecl *D = F.next();
13839  if (!DC->InEnclosingNamespaceSetOf(
13841  F.erase();
13842  }
13843  F.done();
13844 
13845  if (Previous.empty()) {
13846  D.setInvalidType();
13847  Diag(Loc, diag::err_qualified_friend_not_found)
13848  << Name << TInfo->getType();
13849  return nullptr;
13850  }
13851 
13852  // C++ [class.friend]p1: A friend of a class is a function or
13853  // class that is not a member of the class . . .
13854  if (DC->Equals(CurContext))
13855  Diag(DS.getFriendSpecLoc(),
13856  getLangOpts().CPlusPlus11 ?
13857  diag::warn_cxx98_compat_friend_is_member :
13858  diag::err_friend_is_member);
13859 
13860  if (D.isFunctionDefinition()) {
13861  // C++ [class.friend]p6:
13862  // A function can be defined in a friend declaration of a class if and
13863  // only if the class is a non-local class (9.8), the function name is
13864  // unqualified, and the function has namespace scope.
13866  = Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def);
13867 
13868  DB << SS.getScopeRep();
13869  if (DC->isFileContext())
13870  DB << FixItHint::CreateRemoval(SS.getRange());
13871  SS.clear();
13872  }
13873 
13874  // - There's a scope specifier that does not match any template
13875  // parameter lists, in which case we use some arbitrary context,
13876  // create a method or method template, and wait for instantiation.
13877  // - There's a scope specifier that does match some template
13878  // parameter lists, which we don't handle right now.
13879  } else {
13880  if (D.isFunctionDefinition()) {
13881  // C++ [class.friend]p6:
13882  // A function can be defined in a friend declaration of a class if and
13883  // only if the class is a non-local class (9.8), the function name is
13884  // unqualified, and the function has namespace scope.
13885  Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def)
13886  << SS.getScopeRep();
13887  }
13888 
13889  DC = CurContext;
13890  assert(isa<CXXRecordDecl>(DC) && "friend declaration not in class?");
13891  }
13892 
13893  if (!DC->isRecord()) {
13894  int DiagArg = -1;
13895  switch (D.getName().getKind()) {
13898  DiagArg = 0;
13899  break;
13901  DiagArg = 1;
13902  break;
13904  DiagArg = 2;
13905  break;
13907  DiagArg = 3;
13908  break;
13914  break;
13915  }
13916  // This implies that it has to be an operator or function.
13917  if (DiagArg >= 0) {
13918  Diag(Loc, diag::err_introducing_special_friend) << DiagArg;
13919  return nullptr;
13920  }
13921  }
13922 
13923  // FIXME: This is an egregious hack to cope with cases where the scope stack
13924  // does not contain the declaration context, i.e., in an out-of-line
13925  // definition of a class.
13926  Scope FakeDCScope(S, Scope::DeclScope, Diags);
13927  if (!DCScope) {
13928  FakeDCScope.setEntity(DC);
13929  DCScope = &FakeDCScope;
13930  }
13931 
13932  bool AddToScope = true;
13933  NamedDecl *ND = ActOnFunctionDeclarator(DCScope, D, DC, TInfo, Previous,
13934  TemplateParams, AddToScope);
13935  if (!ND) return nullptr;
13936 
13937  assert(ND->getLexicalDeclContext() == CurContext);
13938 
13939  // If we performed typo correction, we might have added a scope specifier
13940  // and changed the decl context.
13941  DC = ND->getDeclContext();
13942 
13943  // Add the function declaration to the appropriate lookup tables,
13944  // adjusting the redeclarations list as necessary. We don't
13945  // want to do this yet if the friending class is dependent.
13946  //
13947  // Also update the scope-based lookup if the target context's
13948  // lookup context is in lexical scope.
13949  if (!CurContext->isDependentContext()) {
13950  DC = DC->getRedeclContext();
13951  DC->makeDeclVisibleInContext(ND);
13952  if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
13953  PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
13954  }
13955 
13956  FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
13957  D.getIdentifierLoc(), ND,
13958  DS.getFriendSpecLoc());
13959  FrD->setAccess(AS_public);
13960  CurContext->addDecl(FrD);
13961 
13962  if (ND->isInvalidDecl()) {
13963  FrD->setInvalidDecl();
13964  } else {
13965  if (DC->isRecord()) CheckFriendAccess(ND);
13966 
13967  FunctionDecl *FD;
13968  if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
13969  FD = FTD->getTemplatedDecl();
13970  else
13971  FD = cast<FunctionDecl>(ND);
13972 
13973  // C++11 [dcl.fct.default]p4: If a friend declaration specifies a
13974  // default argument expression, that declaration shall be a definition
13975  // and shall be the only declaration of the function or function
13976  // template in the translation unit.
13978  // We can't look at FD->getPreviousDecl() because it may not have been set
13979  // if we're in a dependent context. If the function is known to be a
13980  // redeclaration, we will have narrowed Previous down to the right decl.
13981  if (D.isRedeclaration()) {
13982  Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
13983  Diag(Previous.getRepresentativeDecl()->getLocation(),
13984  diag::note_previous_declaration);
13985  } else if (!D.isFunctionDefinition())
13986  Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_must_be_def);
13987  }
13988 
13989  // Mark templated-scope function declarations as unsupported.
13990  if (FD->getNumTemplateParameterLists() && SS.isValid()) {
13991  Diag(FD->getLocation(), diag::warn_template_qualified_friend_unsupported)
13992  << SS.getScopeRep() << SS.getRange()
13993  << cast<CXXRecordDecl>(CurContext);
13994  FrD->setUnsupportedFriend(true);
13995  }
13996  }
13997 
13998  return ND;
13999 }
14000 
14001 void Sema::SetDeclDeleted(Decl *Dcl, SourceLocation DelLoc) {
14002  AdjustDeclIfTemplate(Dcl);
14003 
14004  FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Dcl);
14005  if (!Fn) {
14006  Diag(DelLoc, diag::err_deleted_non_function);
14007  return;
14008  }
14009 
14010  // Deleted function does not have a body.
14011  Fn->setWillHaveBody(false);
14012 
14013  if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
14014  // Don't consider the implicit declaration we generate for explicit
14015  // specializations. FIXME: Do not generate these implicit declarations.
14016  if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization ||
14017  Prev->getPreviousDecl()) &&
14018  !Prev->isDefined()) {
14019  Diag(DelLoc, diag::err_deleted_decl_not_first);
14020  Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
14021  Prev->isImplicit() ? diag::note_previous_implicit_declaration
14022  : diag::note_previous_declaration);
14023  }
14024  // If the declaration wasn't the first, we delete the function anyway for
14025  // recovery.
14026  Fn = Fn->getCanonicalDecl();
14027  }
14028 
14029  // dllimport/dllexport cannot be deleted.
14030  if (const InheritableAttr *DLLAttr = getDLLAttr(Fn)) {
14031  Diag(Fn->getLocation(), diag::err_attribute_dll_deleted) << DLLAttr;
14032  Fn->setInvalidDecl();
14033  }
14034 
14035  if (Fn->isDeleted())
14036  return;
14037 
14038  // See if we're deleting a function which is already known to override a
14039  // non-deleted virtual function.
14040  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn)) {
14041  bool IssuedDiagnostic = false;
14042  for (const CXXMethodDecl *O : MD->overridden_methods()) {
14043  if (!(*MD->begin_overridden_methods())->isDeleted()) {
14044  if (!IssuedDiagnostic) {
14045  Diag(DelLoc, diag::err_deleted_override) << MD->getDeclName();
14046  IssuedDiagnostic = true;
14047  }
14048  Diag(O->getLocation(), diag::note_overridden_virtual_function);
14049  }
14050  }
14051  // If this function was implicitly deleted because it was defaulted,
14052  // explain why it was deleted.
14053  if (IssuedDiagnostic && MD->isDefaulted())
14054  ShouldDeleteSpecialMember(MD, getSpecialMember(MD), nullptr,
14055  /*Diagnose*/true);
14056  }
14057 
14058  // C++11 [basic.start.main]p3:
14059  // A program that defines main as deleted [...] is ill-formed.
14060  if (Fn->isMain())
14061  Diag(DelLoc, diag::err_deleted_main);
14062 
14063  // C++11 [dcl.fct.def.delete]p4:
14064  // A deleted function is implicitly inline.
14065  Fn->setImplicitlyInline();
14066  Fn->setDeletedAsWritten();
14067 }
14068 
14069 void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) {
14070  CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Dcl);
14071 
14072  if (MD) {
14073  if (MD->getParent()->isDependentType()) {
14074  MD->setDefaulted();
14075  MD->setExplicitlyDefaulted();
14076  return;
14077  }
14078 
14079  CXXSpecialMember Member = getSpecialMember(MD);
14080  if (Member == CXXInvalid) {
14081  if (!MD->isInvalidDecl())
14082  Diag(DefaultLoc, diag::err_default_special_members);
14083  return;
14084  }
14085 
14086  MD->setDefaulted();
14087  MD->setExplicitlyDefaulted();
14088 
14089  // Unset that we will have a body for this function. We might not,
14090  // if it turns out to be trivial, and we don't need this marking now
14091  // that we've marked it as defaulted.
14092  MD->setWillHaveBody(false);
14093 
14094  // If this definition appears within the record, do the checking when
14095  // the record is complete.
14096  const FunctionDecl *Primary = MD;
14097  if (const FunctionDecl *Pattern = MD->getTemplateInstantiationPattern())
14098  // Ask the template instantiation pattern that actually had the
14099  // '= default' on it.
14100  Primary = Pattern;
14101 
14102  // If the method was defaulted on its first declaration, we will have
14103  // already performed the checking in CheckCompletedCXXClass. Such a
14104  // declaration doesn't trigger an implicit definition.
14105  if (Primary->getCanonicalDecl()->isDefaulted())
14106  return;
14107 
14108  CheckExplicitlyDefaultedSpecialMember(MD);
14109 
14110  if (!MD->isInvalidDecl())
14111  DefineImplicitSpecialMember(*this, MD, DefaultLoc);
14112  } else {
14113  Diag(DefaultLoc, diag::err_default_special_members);
14114  }
14115 }
14116 
14117 static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
14118  for (Stmt *SubStmt : S->children()) {
14119  if (!SubStmt)
14120  continue;
14121  if (isa<ReturnStmt>(SubStmt))
14122  Self.Diag(SubStmt->getLocStart(),
14123  diag::err_return_in_constructor_handler);
14124  if (!isa<Expr>(SubStmt))
14125  SearchForReturnInStmt(Self, SubStmt);
14126  }
14127 }
14128 
14130  for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
14131  CXXCatchStmt *Handler = TryBlock->getHandler(I);
14132  SearchForReturnInStmt(*this, Handler);
14133  }
14134 }
14135 
14137  const CXXMethodDecl *Old) {
14138  const auto *NewFT = New->getType()->getAs<FunctionProtoType>();
14139  const auto *OldFT = Old->getType()->getAs<FunctionProtoType>();
14140 
14141  if (OldFT->hasExtParameterInfos()) {
14142  for (unsigned I = 0, E = OldFT->getNumParams(); I != E; ++I)
14143  // A parameter of the overriding method should be annotated with noescape
14144  // if the corresponding parameter of the overridden method is annotated.
14145  if (OldFT->getExtParameterInfo(I).isNoEscape() &&
14146  !NewFT->getExtParameterInfo(I).isNoEscape()) {
14147  Diag(New->getParamDecl(I)->getLocation(),
14148  diag::warn_overriding_method_missing_noescape);
14149  Diag(Old->getParamDecl(I)->getLocation(),
14150  diag::note_overridden_marked_noescape);
14151  }
14152  }
14153 
14154  CallingConv NewCC = NewFT->getCallConv(), OldCC = OldFT->getCallConv();
14155 
14156  // If the calling conventions match, everything is fine
14157  if (NewCC == OldCC)
14158  return false;
14159 
14160  // If the calling conventions mismatch because the new function is static,
14161  // suppress the calling convention mismatch error; the error about static
14162  // function override (err_static_overrides_virtual from
14163  // Sema::CheckFunctionDeclaration) is more clear.
14164  if (New->getStorageClass() == SC_Static)
14165  return false;
14166 
14167  Diag(New->getLocation(),
14168  diag::err_conflicting_overriding_cc_attributes)
14169  << New->getDeclName() << New->getType() << Old->getType();
14170  Diag(Old->getLocation(), diag::note_overridden_virtual_function);
14171  return true;
14172 }
14173 
14175  const CXXMethodDecl *Old) {
14176  QualType NewTy = New->getType()->getAs<FunctionType>()->getReturnType();
14177  QualType OldTy = Old->getType()->getAs<FunctionType>()->getReturnType();
14178 
14179  if (Context.hasSameType(NewTy, OldTy) ||
14180  NewTy->isDependentType() || OldTy->isDependentType())
14181  return false;
14182 
14183  // Check if the return types are covariant
14184  QualType NewClassTy, OldClassTy;
14185 
14186  /// Both types must be pointers or references to classes.
14187  if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
14188  if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
14189  NewClassTy = NewPT->getPointeeType();
14190  OldClassTy = OldPT->getPointeeType();
14191  }
14192  } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
14193  if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
14194  if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
14195  NewClassTy = NewRT->getPointeeType();
14196  OldClassTy = OldRT->getPointeeType();
14197  }
14198  }
14199  }
14200 
14201  // The return types aren't either both pointers or references to a class type.
14202  if (NewClassTy.isNull()) {
14203  Diag(New->getLocation(),
14204  diag::err_different_return_type_for_overriding_virtual_function)
14205  << New->getDeclName() << NewTy << OldTy
14206  << New->getReturnTypeSourceRange();
14207  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
14208  << Old->getReturnTypeSourceRange();
14209 
14210  return true;
14211  }
14212 
14213  if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
14214  // C++14 [class.virtual]p8:
14215  // If the class type in the covariant return type of D::f differs from
14216  // that of B::f, the class type in the return type of D::f shall be
14217  // complete at the point of declaration of D::f or shall be the class
14218  // type D.
14219  if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
14220  if (!RT->isBeingDefined() &&
14221  RequireCompleteType(New->getLocation(), NewClassTy,
14222  diag::err_covariant_return_incomplete,
14223  New->getDeclName()))
14224  return true;
14225  }
14226 
14227  // Check if the new class derives from the old class.
14228  if (!IsDerivedFrom(New->getLocation(), NewClassTy, OldClassTy)) {
14229  Diag(New->getLocation(), diag::err_covariant_return_not_derived)
14230  << New->getDeclName() << NewTy << OldTy
14231  << New->getReturnTypeSourceRange();
14232  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
14233  << Old->getReturnTypeSourceRange();
14234  return true;
14235  }
14236 
14237  // Check if we the conversion from derived to base is valid.
14238  if (CheckDerivedToBaseConversion(
14239  NewClassTy, OldClassTy,
14240  diag::err_covariant_return_inaccessible_base,
14241  diag::err_covariant_return_ambiguous_derived_to_base_conv,
14242  New->getLocation(), New->getReturnTypeSourceRange(),
14243  New->getDeclName(), nullptr)) {
14244  // FIXME: this note won't trigger for delayed access control
14245  // diagnostics, and it's impossible to get an undelayed error
14246  // here from access control during the original parse because
14247  // the ParsingDeclSpec/ParsingDeclarator are still in scope.
14248  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
14249  << Old->getReturnTypeSourceRange();
14250  return true;
14251  }
14252  }
14253 
14254  // The qualifiers of the return types must be the same.
14255  if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
14256  Diag(New->getLocation(),
14257  diag::err_covariant_return_type_different_qualifications)
14258  << New->getDeclName() << NewTy << OldTy
14259  << New->getReturnTypeSourceRange();
14260  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
14261  << Old->getReturnTypeSourceRange();
14262  return true;
14263  }
14264 
14265 
14266  // The new class type must have the same or less qualifiers as the old type.
14267  if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
14268  Diag(New->getLocation(),
14269  diag::err_covariant_return_type_class_type_more_qualified)
14270  << New->getDeclName() << NewTy << OldTy
14271  << New->getReturnTypeSourceRange();
14272  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
14273  << Old->getReturnTypeSourceRange();
14274  return true;
14275  }
14276 
14277  return false;
14278 }
14279 
14280 /// \brief Mark the given method pure.
14281 ///
14282 /// \param Method the method to be marked pure.
14283 ///
14284 /// \param InitRange the source range that covers the "0" initializer.
14286  SourceLocation EndLoc = InitRange.getEnd();
14287  if (EndLoc.isValid())
14288  Method->setRangeEnd(EndLoc);
14289 
14290  if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
14291  Method->setPure();
14292  return false;
14293  }
14294 
14295  if (!Method->isInvalidDecl())
14296  Diag(Method->getLocation(), diag::err_non_virtual_pure)
14297  << Method->getDeclName() << InitRange;
14298  return true;
14299 }
14300 
14302  if (D->getFriendObjectKind())
14303  Diag(D->getLocation(), diag::err_pure_friend);
14304  else if (auto *M = dyn_cast<CXXMethodDecl>(D))
14305  CheckPureMethod(M, ZeroLoc);
14306  else
14307  Diag(D->getLocation(), diag::err_illegal_initializer);
14308 }
14309 
14310 /// \brief Determine whether the given declaration is a global variable or
14311 /// static data member.
14312 static bool isNonlocalVariable(const Decl *D) {
14313  if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(D))
14314  return Var->hasGlobalStorage();
14315 
14316  return false;
14317 }
14318 
14319 /// Invoked when we are about to parse an initializer for the declaration
14320 /// 'Dcl'.
14321 ///
14322 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
14323 /// static data member of class X, names should be looked up in the scope of
14324 /// class X. If the declaration had a scope specifier, a scope will have
14325 /// been created and passed in for this purpose. Otherwise, S will be null.
14327  // If there is no declaration, there was an error parsing it.
14328  if (!D || D->isInvalidDecl())
14329  return;
14330 
14331  // We will always have a nested name specifier here, but this declaration
14332  // might not be out of line if the specifier names the current namespace:
14333  // extern int n;
14334  // int ::n = 0;
14335  if (S && D->isOutOfLine())
14336  EnterDeclaratorContext(S, D->getDeclContext());
14337 
14338  // If we are parsing the initializer for a static data member, push a
14339  // new expression evaluation context that is associated with this static
14340  // data member.
14341  if (isNonlocalVariable(D))
14342  PushExpressionEvaluationContext(
14343  ExpressionEvaluationContext::PotentiallyEvaluated, D);
14344 }
14345 
14346 /// Invoked after we are finished parsing an initializer for the declaration D.
14348  // If there is no declaration, there was an error parsing it.
14349  if (!D || D->isInvalidDecl())
14350  return;
14351 
14352  if (isNonlocalVariable(D))
14353  PopExpressionEvaluationContext();
14354 
14355  if (S && D->isOutOfLine())
14356  ExitDeclaratorContext(S);
14357 }
14358 
14359 /// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
14360 /// C++ if/switch/while/for statement.
14361 /// e.g: "if (int x = f()) {...}"
14363  // C++ 6.4p2:
14364  // The declarator shall not specify a function or an array.
14365  // The type-specifier-seq shall not contain typedef and shall not declare a
14366  // new class or enumeration.
14368  "Parser allowed 'typedef' as storage class of condition decl.");
14369 
14370  Decl *Dcl = ActOnDeclarator(S, D);
14371  if (!Dcl)
14372  return true;
14373 
14374  if (isa<FunctionDecl>(Dcl)) { // The declarator shall not specify a function.
14375  Diag(Dcl->getLocation(), diag::err_invalid_use_of_function_type)
14376  << D.getSourceRange();
14377  return true;
14378  }
14379 
14380  return Dcl;
14381 }
14382 
14384  if (!ExternalSource)
14385  return;
14386 
14388  ExternalSource->ReadUsedVTables(VTables);
14389  SmallVector<VTableUse, 4> NewUses;
14390  for (unsigned I = 0, N = VTables.size(); I != N; ++I) {
14391  llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
14392  = VTablesUsed.find(VTables[I].Record);
14393  // Even if a definition wasn't required before, it may be required now.
14394  if (Pos != VTablesUsed.end()) {
14395  if (!Pos->second && VTables[I].DefinitionRequired)
14396  Pos->second = true;
14397  continue;
14398  }
14399 
14400  VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
14401  NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location));
14402  }
14403 
14404  VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end());
14405 }
14406 
14408  bool DefinitionRequired) {
14409  // Ignore any vtable uses in unevaluated operands or for classes that do
14410  // not have a vtable.
14411  if (!Class->isDynamicClass() || Class->isDependentContext() ||
14412  CurContext->isDependentContext() || isUnevaluatedContext())
14413  return;
14414 
14415  // Try to insert this class into the map.
14416  LoadExternalVTableUses();
14417  Class = cast<CXXRecordDecl>(Class->getCanonicalDecl());
14418  std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator, bool>
14419  Pos = VTablesUsed.insert(std::make_pair(Class, DefinitionRequired));
14420  if (!Pos.second) {
14421  // If we already had an entry, check to see if we are promoting this vtable
14422  // to require a definition. If so, we need to reappend to the VTableUses
14423  // list, since we may have already processed the first entry.
14424  if (DefinitionRequired && !Pos.first->second) {
14425  Pos.first->second = true;
14426  } else {
14427  // Otherwise, we can early exit.
14428  return;
14429  }
14430  } else {
14431  // The Microsoft ABI requires that we perform the destructor body
14432  // checks (i.e. operator delete() lookup) when the vtable is marked used, as
14433  // the deleting destructor is emitted with the vtable, not with the
14434  // destructor definition as in the Itanium ABI.
14435  if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
14436  CXXDestructorDecl *DD = Class->getDestructor();
14437  if (DD && DD->isVirtual() && !DD->isDeleted()) {
14438  if (Class->hasUserDeclaredDestructor() && !DD->isDefined()) {
14439  // If this is an out-of-line declaration, marking it referenced will
14440  // not do anything. Manually call CheckDestructor to look up operator
14441  // delete().
14442  ContextRAII SavedContext(*this, DD);
14443  CheckDestructor(DD);
14444  } else {
14445  MarkFunctionReferenced(Loc, Class->getDestructor());
14446  }
14447  }
14448  }
14449  }
14450 
14451  // Local classes need to have their virtual members marked
14452  // immediately. For all other classes, we mark their virtual members
14453  // at the end of the translation unit.
14454  if (Class->isLocalClass())
14455  MarkVirtualMembersReferenced(Loc, Class);
14456  else
14457  VTableUses.push_back(std::make_pair(Class, Loc));
14458 }
14459 
14461  LoadExternalVTableUses();
14462  if (VTableUses.empty())
14463  return false;
14464 
14465  // Note: The VTableUses vector could grow as a result of marking
14466  // the members of a class as "used", so we check the size each
14467  // time through the loop and prefer indices (which are stable) to
14468  // iterators (which are not).
14469  bool DefinedAnything = false;
14470  for (unsigned I = 0; I != VTableUses.size(); ++I) {
14471  CXXRecordDecl *Class = VTableUses[I].first->getDefinition();
14472  if (!Class)
14473  continue;
14474  TemplateSpecializationKind ClassTSK =
14476 
14477  SourceLocation Loc = VTableUses[I].second;
14478 
14479  bool DefineVTable = true;
14480 
14481  // If this class has a key function, but that key function is
14482  // defined in another translation unit, we don't need to emit the
14483  // vtable even though we're using it.
14484  const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(Class);
14485  if (KeyFunction && !KeyFunction->hasBody()) {
14486  // The key function is in another translation unit.
14487  DefineVTable = false;
14489  KeyFunction->getTemplateSpecializationKind();
14490  assert(TSK != TSK_ExplicitInstantiationDefinition &&
14491  TSK != TSK_ImplicitInstantiation &&
14492  "Instantiations don't have key functions");
14493  (void)TSK;
14494  } else if (!KeyFunction) {
14495  // If we have a class with no key function that is the subject
14496  // of an explicit instantiation declaration, suppress the
14497  // vtable; it will live with the explicit instantiation
14498  // definition.
14499  bool IsExplicitInstantiationDeclaration =
14501  for (auto R : Class->redecls()) {
14503  = cast<CXXRecordDecl>(R)->getTemplateSpecializationKind();
14505  IsExplicitInstantiationDeclaration = true;
14506  else if (TSK == TSK_ExplicitInstantiationDefinition) {
14507  IsExplicitInstantiationDeclaration = false;
14508  break;
14509  }
14510  }
14511 
14512  if (IsExplicitInstantiationDeclaration)
14513  DefineVTable = false;
14514  }
14515 
14516  // The exception specifications for all virtual members may be needed even
14517  // if we are not providing an authoritative form of the vtable in this TU.
14518  // We may choose to emit it available_externally anyway.
14519  if (!DefineVTable) {
14520  MarkVirtualMemberExceptionSpecsNeeded(Loc, Class);
14521  continue;
14522  }
14523 
14524  // Mark all of the virtual members of this class as referenced, so
14525  // that we can build a vtable. Then, tell the AST consumer that a
14526  // vtable for this class is required.
14527  DefinedAnything = true;
14528  MarkVirtualMembersReferenced(Loc, Class);
14529  CXXRecordDecl *Canonical = cast<CXXRecordDecl>(Class->getCanonicalDecl());
14530  if (VTablesUsed[Canonical])
14531  Consumer.HandleVTable(Class);
14532 
14533  // Warn if we're emitting a weak vtable. The vtable will be weak if there is
14534  // no key function or the key function is inlined. Don't warn in C++ ABIs
14535  // that lack key functions, since the user won't be able to make one.
14536  if (Context.getTargetInfo().getCXXABI().hasKeyFunctions() &&
14537  Class->isExternallyVisible() && ClassTSK != TSK_ImplicitInstantiation) {
14538  const FunctionDecl *KeyFunctionDef = nullptr;
14539  if (!KeyFunction || (KeyFunction->hasBody(KeyFunctionDef) &&
14540  KeyFunctionDef->isInlined())) {
14541  Diag(Class->getLocation(),
14543  ? diag::warn_weak_template_vtable
14544  : diag::warn_weak_vtable)
14545  << Class;
14546  }
14547  }
14548  }
14549  VTableUses.clear();
14550 
14551  return DefinedAnything;
14552 }
14553 
14555  const CXXRecordDecl *RD) {
14556  for (const auto *I : RD->methods())
14557  if (I->isVirtual() && !I->isPure())
14558  ResolveExceptionSpec(Loc, I->getType()->castAs<FunctionProtoType>());
14559 }
14560 
14562  const CXXRecordDecl *RD) {
14563  // Mark all functions which will appear in RD's vtable as used.
14564  CXXFinalOverriderMap FinalOverriders;
14565  RD->getFinalOverriders(FinalOverriders);
14566  for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
14567  E = FinalOverriders.end();
14568  I != E; ++I) {
14569  for (OverridingMethods::const_iterator OI = I->second.begin(),
14570  OE = I->second.end();
14571  OI != OE; ++OI) {
14572  assert(OI->second.size() > 0 && "no final overrider");
14573  CXXMethodDecl *Overrider = OI->second.front().Method;
14574 
14575  // C++ [basic.def.odr]p2:
14576  // [...] A virtual member function is used if it is not pure. [...]
14577  if (!Overrider->isPure())
14578  MarkFunctionReferenced(Loc, Overrider);
14579  }
14580  }
14581 
14582  // Only classes that have virtual bases need a VTT.
14583  if (RD->getNumVBases() == 0)
14584  return;
14585 
14586  for (const auto &I : RD->bases()) {
14587  const CXXRecordDecl *Base =
14588  cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
14589  if (Base->getNumVBases() == 0)
14590  continue;
14591  MarkVirtualMembersReferenced(Loc, Base);
14592  }
14593 }
14594 
14595 /// SetIvarInitializers - This routine builds initialization ASTs for the
14596 /// Objective-C implementation whose ivars need be initialized.
14598  if (!getLangOpts().CPlusPlus)
14599  return;
14600  if (ObjCInterfaceDecl *OID = ObjCImplementation->getClassInterface()) {
14602  CollectIvarsToConstructOrDestruct(OID, ivars);
14603  if (ivars.empty())
14604  return;
14606  for (unsigned i = 0; i < ivars.size(); i++) {
14607  FieldDecl *Field = ivars[i];
14608  if (Field->isInvalidDecl())
14609  continue;
14610 
14611  CXXCtorInitializer *Member;
14613  InitializationKind InitKind =
14614  InitializationKind::CreateDefault(ObjCImplementation->getLocation());
14615 
14616  InitializationSequence InitSeq(*this, InitEntity, InitKind, None);
14617  ExprResult MemberInit =
14618  InitSeq.Perform(*this, InitEntity, InitKind, None);
14619  MemberInit = MaybeCreateExprWithCleanups(MemberInit);
14620  // Note, MemberInit could actually come back empty if no initialization
14621  // is required (e.g., because it would call a trivial default constructor)
14622  if (!MemberInit.get() || MemberInit.isInvalid())
14623  continue;
14624 
14625  Member =
14626  new (Context) CXXCtorInitializer(Context, Field, SourceLocation(),
14627  SourceLocation(),
14628  MemberInit.getAs<Expr>(),
14629  SourceLocation());
14630  AllToInit.push_back(Member);
14631 
14632  // Be sure that the destructor is accessible and is marked as referenced.
14633  if (const RecordType *RecordTy =
14634  Context.getBaseElementType(Field->getType())
14635  ->getAs<RecordType>()) {
14636  CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
14637  if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
14638  MarkFunctionReferenced(Field->getLocation(), Destructor);
14639  CheckDestructorAccess(Field->getLocation(), Destructor,
14640  PDiag(diag::err_access_dtor_ivar)
14641  << Context.getBaseElementType(Field->getType()));
14642  }
14643  }
14644  }
14645  ObjCImplementation->setIvarInitializers(Context,
14646  AllToInit.data(), AllToInit.size());
14647  }
14648 }
14649 
14650 static
14652  llvm::SmallSet<CXXConstructorDecl*, 4> &Valid,
14653  llvm::SmallSet<CXXConstructorDecl*, 4> &Invalid,
14654  llvm::SmallSet<CXXConstructorDecl*, 4> &Current,
14655  Sema &S) {
14656  if (Ctor->isInvalidDecl())
14657  return;
14658 
14659  CXXConstructorDecl *Target = Ctor->getTargetConstructor();
14660 
14661  // Target may not be determinable yet, for instance if this is a dependent
14662  // call in an uninstantiated template.
14663  if (Target) {
14664  const FunctionDecl *FNTarget = nullptr;
14665  (void)Target->hasBody(FNTarget);
14666  Target = const_cast<CXXConstructorDecl*>(
14667  cast_or_null<CXXConstructorDecl>(FNTarget));
14668  }
14669 
14670  CXXConstructorDecl *Canonical = Ctor->getCanonicalDecl(),
14671  // Avoid dereferencing a null pointer here.
14672  *TCanonical = Target? Target->getCanonicalDecl() : nullptr;
14673 
14674  if (!Current.insert(Canonical).second)
14675  return;
14676 
14677  // We know that beyond here, we aren't chaining into a cycle.
14678  if (!Target || !Target->isDelegatingConstructor() ||
14679  Target->isInvalidDecl() || Valid.count(TCanonical)) {
14680  Valid.insert(Current.begin(), Current.end());
14681  Current.clear();
14682  // We've hit a cycle.
14683  } else if (TCanonical == Canonical || Invalid.count(TCanonical) ||
14684  Current.count(TCanonical)) {
14685  // If we haven't diagnosed this cycle yet, do so now.
14686  if (!Invalid.count(TCanonical)) {
14687  S.Diag((*Ctor->init_begin())->getSourceLocation(),
14688  diag::warn_delegating_ctor_cycle)
14689  << Ctor;
14690 
14691  // Don't add a note for a function delegating directly to itself.
14692  if (TCanonical != Canonical)
14693  S.Diag(Target->getLocation(), diag::note_it_delegates_to);
14694 
14695  CXXConstructorDecl *C = Target;
14696  while (C->getCanonicalDecl() != Canonical) {
14697  const FunctionDecl *FNTarget = nullptr;
14698  (void)C->getTargetConstructor()->hasBody(FNTarget);
14699  assert(FNTarget && "Ctor cycle through bodiless function");
14700 
14701  C = const_cast<CXXConstructorDecl*>(
14702  cast<CXXConstructorDecl>(FNTarget));
14703  S.Diag(C->getLocation(), diag::note_which_delegates_to);
14704  }
14705  }
14706 
14707  Invalid.insert(Current.begin(), Current.end());
14708  Current.clear();
14709  } else {
14710  DelegatingCycleHelper(Target, Valid, Invalid, Current, S);
14711  }
14712 }
14713 
14714 
14716  llvm::SmallSet<CXXConstructorDecl*, 4> Valid, Invalid, Current;
14717 
14718  for (DelegatingCtorDeclsType::iterator
14719  I = DelegatingCtorDecls.begin(ExternalSource),
14720  E = DelegatingCtorDecls.end();
14721  I != E; ++I)
14722  DelegatingCycleHelper(*I, Valid, Invalid, Current, *this);
14723 
14724  for (llvm::SmallSet<CXXConstructorDecl *, 4>::iterator CI = Invalid.begin(),
14725  CE = Invalid.end();
14726  CI != CE; ++CI)
14727  (*CI)->setInvalidDecl();
14728 }
14729 
14730 namespace {
14731  /// \brief AST visitor that finds references to the 'this' expression.
14732  class FindCXXThisExpr : public RecursiveASTVisitor<FindCXXThisExpr> {
14733  Sema &S;
14734 
14735  public:
14736  explicit FindCXXThisExpr(Sema &S) : S(S) { }
14737 
14738  bool VisitCXXThisExpr(CXXThisExpr *E) {
14739  S.Diag(E->getLocation(), diag::err_this_static_member_func)
14740  << E->isImplicit();
14741  return false;
14742  }
14743  };
14744 }
14745 
14747  TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
14748  if (!TSInfo)
14749  return false;
14750 
14751  TypeLoc TL = TSInfo->getTypeLoc();
14753  if (!ProtoTL)
14754  return false;
14755 
14756  // C++11 [expr.prim.general]p3:
14757  // [The expression this] shall not appear before the optional
14758  // cv-qualifier-seq and it shall not appear within the declaration of a
14759  // static member function (although its type and value category are defined
14760  // within a static member function as they are within a non-static member
14761  // function). [ Note: this is because declaration matching does not occur
14762  // until the complete declarator is known. - end note ]
14763  const FunctionProtoType *Proto = ProtoTL.getTypePtr();
14764  FindCXXThisExpr Finder(*this);
14765 
14766  // If the return type came after the cv-qualifier-seq, check it now.
14767  if (Proto->hasTrailingReturn() &&
14768  !Finder.TraverseTypeLoc(ProtoTL.getReturnLoc()))
14769  return true;
14770 
14771  // Check the exception specification.
14772  if (checkThisInStaticMemberFunctionExceptionSpec(Method))
14773  return true;
14774 
14775  return checkThisInStaticMemberFunctionAttributes(Method);
14776 }
14777 
14779  TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
14780  if (!TSInfo)
14781  return false;
14782 
14783  TypeLoc TL = TSInfo->getTypeLoc();
14785  if (!ProtoTL)
14786  return false;
14787 
14788  const FunctionProtoType *Proto = ProtoTL.getTypePtr();
14789  FindCXXThisExpr Finder(*this);
14790 
14791  switch (Proto->getExceptionSpecType()) {
14792  case EST_Unparsed:
14793  case EST_Uninstantiated:
14794  case EST_Unevaluated:
14795  case EST_BasicNoexcept:
14796  case EST_DynamicNone:
14797  case EST_MSAny:
14798  case EST_None:
14799  break;
14800 
14801  case EST_ComputedNoexcept:
14802  if (!Finder.TraverseStmt(Proto->getNoexceptExpr()))
14803  return true;
14804  LLVM_FALLTHROUGH;
14805 
14806  case EST_Dynamic:
14807  for (const auto &E : Proto->exceptions()) {
14808  if (!Finder.TraverseType(E))
14809  return true;
14810  }
14811  break;
14812  }
14813 
14814  return false;
14815 }
14816 
14818  FindCXXThisExpr Finder(*this);
14819 
14820  // Check attributes.
14821  for (const auto *A : Method->attrs()) {
14822  // FIXME: This should be emitted by tblgen.
14823  Expr *Arg = nullptr;
14824  ArrayRef<Expr *> Args;
14825  if (const auto *G = dyn_cast<GuardedByAttr>(A))
14826  Arg = G->getArg();
14827  else if (const auto *G = dyn_cast<PtGuardedByAttr>(A))
14828  Arg = G->getArg();
14829  else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
14830  Args = llvm::makeArrayRef(AA->args_begin(), AA->args_size());
14831  else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
14832  Args = llvm::makeArrayRef(AB->args_begin(), AB->args_size());
14833  else if (const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
14834  Arg = ETLF->getSuccessValue();
14835  Args = llvm::makeArrayRef(ETLF->args_begin(), ETLF->args_size());
14836  } else if (const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
14837  Arg = STLF->getSuccessValue();
14838  Args = llvm::makeArrayRef(STLF->args_begin(), STLF->args_size());
14839  } else if (const auto *LR = dyn_cast<LockReturnedAttr>(A))
14840  Arg = LR->getArg();
14841  else if (const auto *LE = dyn_cast<LocksExcludedAttr>(A))
14842  Args = llvm::makeArrayRef(LE->args_begin(), LE->args_size());
14843  else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
14844  Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());
14845  else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
14846  Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
14847  else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
14848  Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
14849  else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
14850  Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());
14851 
14852  if (Arg && !Finder.TraverseStmt(Arg))
14853  return true;
14854 
14855  for (unsigned I = 0, N = Args.size(); I != N; ++I) {
14856  if (!Finder.TraverseStmt(Args[I]))
14857  return true;
14858  }
14859  }
14860 
14861  return false;
14862 }
14863 
14865  bool IsTopLevel, ExceptionSpecificationType EST,
14866  ArrayRef<ParsedType> DynamicExceptions,
14867  ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr,
14868  SmallVectorImpl<QualType> &Exceptions,
14870  Exceptions.clear();
14871  ESI.Type = EST;
14872  if (EST == EST_Dynamic) {
14873  Exceptions.reserve(DynamicExceptions.size());
14874  for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
14875  // FIXME: Preserve type source info.
14876  QualType ET = GetTypeFromParser(DynamicExceptions[ei]);
14877 
14878  if (IsTopLevel) {
14880  collectUnexpandedParameterPacks(ET, Unexpanded);
14881  if (!Unexpanded.empty()) {
14883  DynamicExceptionRanges[ei].getBegin(), UPPC_ExceptionType,
14884  Unexpanded);
14885  continue;
14886  }
14887  }
14888 
14889  // Check that the type is valid for an exception spec, and
14890  // drop it if not.
14891  if (!CheckSpecifiedExceptionType(ET, DynamicExceptionRanges[ei]))
14892  Exceptions.push_back(ET);
14893  }
14894  ESI.Exceptions = Exceptions;
14895  return;
14896  }
14897 
14898  if (EST == EST_ComputedNoexcept) {
14899  // If an error occurred, there's no expression here.
14900  if (NoexceptExpr) {
14901  assert((NoexceptExpr->isTypeDependent() ||
14902  NoexceptExpr->getType()->getCanonicalTypeUnqualified() ==
14903  Context.BoolTy) &&
14904  "Parser should have made sure that the expression is boolean");
14905  if (IsTopLevel && NoexceptExpr &&
14906  DiagnoseUnexpandedParameterPack(NoexceptExpr)) {
14907  ESI.Type = EST_BasicNoexcept;
14908  return;
14909  }
14910 
14911  if (!NoexceptExpr->isValueDependent()) {
14912  ExprResult Result = VerifyIntegerConstantExpression(
14913  NoexceptExpr, nullptr, diag::err_noexcept_needs_constant_expression,
14914  /*AllowFold*/ false);
14915  if (Result.isInvalid()) {
14916  ESI.Type = EST_BasicNoexcept;
14917  return;
14918  }
14919  NoexceptExpr = Result.get();
14920  }
14921  ESI.NoexceptExpr = NoexceptExpr;
14922  }
14923  return;
14924  }
14925 }
14926 
14929  SourceRange SpecificationRange,
14930  ArrayRef<ParsedType> DynamicExceptions,
14931  ArrayRef<SourceRange> DynamicExceptionRanges,
14932  Expr *NoexceptExpr) {
14933  if (!MethodD)
14934  return;
14935 
14936  // Dig out the method we're referring to.
14937  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(MethodD))
14938  MethodD = FunTmpl->getTemplatedDecl();
14939 
14940  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(MethodD);
14941  if (!Method)
14942  return;
14943 
14944  // Check the exception specification.
14945  llvm::SmallVector<QualType, 4> Exceptions;
14947  checkExceptionSpecification(/*IsTopLevel*/true, EST, DynamicExceptions,
14948  DynamicExceptionRanges, NoexceptExpr, Exceptions,
14949  ESI);
14950 
14951  // Update the exception specification on the function type.
14952  Context.adjustExceptionSpec(Method, ESI, /*AsWritten*/true);
14953 
14954  if (Method->isStatic())
14955  checkThisInStaticMemberFunctionExceptionSpec(Method);
14956 
14957  if (Method->isVirtual()) {
14958  // Check overrides, which we previously had to delay.
14959  for (const CXXMethodDecl *O : Method->overridden_methods())
14960  CheckOverridingFunctionExceptionSpec(Method, O);
14961  }
14962 }
14963 
14964 /// HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
14965 ///
14967  SourceLocation DeclStart,
14968  Declarator &D, Expr *BitWidth,
14969  InClassInitStyle InitStyle,
14970  AccessSpecifier AS,
14971  AttributeList *MSPropertyAttr) {
14972  IdentifierInfo *II = D.getIdentifier();
14973  if (!II) {
14974  Diag(DeclStart, diag::err_anonymous_property);
14975  return nullptr;
14976  }
14977  SourceLocation Loc = D.getIdentifierLoc();
14978 
14979  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
14980  QualType T = TInfo->getType();
14981  if (getLangOpts().CPlusPlus) {
14982  CheckExtraCXXDefaultArguments(D);
14983 
14984  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
14985  UPPC_DataMemberType)) {
14986  D.setInvalidType();
14987  T = Context.IntTy;
14988  TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
14989  }
14990  }
14991 
14992  DiagnoseFunctionSpecifiers(D.getDeclSpec());
14993 
14994  if (D.getDeclSpec().isInlineSpecified())
14995  Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
14996  << getLangOpts().CPlusPlus17;
14999  diag::err_invalid_thread)
15000  << DeclSpec::getSpecifierName(TSCS);
15001 
15002  // Check to see if this name was declared as a member previously
15003  NamedDecl *PrevDecl = nullptr;
15004  LookupResult Previous(*this, II, Loc, LookupMemberName,
15005  ForVisibleRedeclaration);
15006  LookupName(Previous, S);
15007  switch (Previous.getResultKind()) {
15008  case LookupResult::Found:
15010  PrevDecl = Previous.getAsSingle<NamedDecl>();
15011  break;
15012 
15014  PrevDecl = Previous.getRepresentativeDecl();
15015  break;
15016 
15020  break;
15021  }
15022 
15023  if (PrevDecl && PrevDecl->isTemplateParameter()) {
15024  // Maybe we will complain about the shadowed template parameter.
15025  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
15026  // Just pretend that we didn't see the previous declaration.
15027  PrevDecl = nullptr;
15028  }
15029 
15030  if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
15031  PrevDecl = nullptr;
15032 
15033  SourceLocation TSSL = D.getLocStart();
15034  const AttributeList::PropertyData &Data = MSPropertyAttr->getPropertyData();
15036  Context, Record, Loc, II, T, TInfo, TSSL, Data.GetterId, Data.SetterId);
15037  ProcessDeclAttributes(TUScope, NewPD, D);
15038  NewPD->setAccess(AS);
15039 
15040  if (NewPD->isInvalidDecl())
15041  Record->setInvalidDecl();
15042 
15044  NewPD->setModulePrivate();
15045 
15046  if (NewPD->isInvalidDecl() && PrevDecl) {
15047  // Don't introduce NewFD into scope; there's already something
15048  // with the same name in the same scope.
15049  } else if (II) {
15050  PushOnScopeChains(NewPD, S);
15051  } else
15052  Record->addDecl(NewPD);
15053 
15054  return NewPD;
15055 }
QualType BuildStdInitializerList(QualType Element, SourceLocation Loc)
Looks for the std::initializer_list template and instantiates it with Element, or emits an error if i...
Abstract class used to diagnose incomplete types.
Definition: Sema.h:1483
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
Definition: Ownership.h:265
static bool checkMemberDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const CXXRecordDecl *RD)
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:78
bool isBaseInitializer() const
Determine whether this initializer is initializing a base class.
Definition: DeclCXX.h:2238
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl)
Definition: DeclCXX.cpp:2307
NamespaceDecl * lookupStdExperimentalNamespace()
void setSourceOrder(int Pos)
Set the source order of this initializer.
Definition: DeclCXX.h:2352
Defines the clang::ASTContext interface.
void ActOnFinishDelayedMemberInitializers(Decl *Record)
VariadicCallType
Definition: Sema.h:9293
bool isCallToStdMove() const
Definition: Expr.h:2351
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1546
static void collectUnexpandedParameterPacks(Sema &S, TemplateParameterList *Params, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK)
Definition: SemaExpr.cpp:15383
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Definition: DeclCXX.h:3128
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void setImplicit(bool I=true)
Definition: DeclBase.h:552
An instance of this class is created to represent a function declaration or definition.
Definition: Decl.h:1697
static StmtResult buildSingleCopyAssignRecursively(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &To, const ExprBuilder &From, bool CopyingBaseSubobject, bool Copying, unsigned Depth=0)
Builds a statement that copies/moves the given entity from From to To.
static void CheckForDanglingReferenceOrPointer(Sema &S, ValueDecl *Member, Expr *Init, SourceLocation IdLoc)
Checks a member initializer expression for cases where reference (or pointer) members are bound to by...
Name lookup found a set of overloaded functions that met the criteria.
Definition: Lookup.h:49
NamespaceDecl * getStdNamespace() const
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
Definition: DeclSpec.h:2237
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Expr * getInit() const
Get the initializer.
Definition: DeclCXX.h:2367
const Stmt * getElse() const
Definition: Stmt.h:973
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
Definition: DeclSpec.h:1243
void CheckConstructor(CXXConstructorDecl *Constructor)
CheckConstructor - Checks a fully-formed constructor for well-formedness, issuing any diagnostics req...
void setOrigin(CXXRecordDecl *Rec)
CXXMethodDecl * getMethod() const
Definition: Sema.h:1041
no exception specification
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:497
PtrTy get() const
Definition: Ownership.h:74
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2283
EvaluatedExprVisitor - This class visits &#39;Expr *&#39;s.
QualType getPointeeType() const
Definition: Type.h:2296
CanQualType VoidPtrTy
Definition: ASTContext.h:1012
A (possibly-)qualified type.
Definition: Type.h:653
ASTConsumer & Consumer
Definition: Sema.h:317
Simple class containing the result of Sema::CorrectTypo.
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:2061
base_class_range bases()
Definition: DeclCXX.h:773
bool isArrayType() const
Definition: Type.h:5991
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2483
bool isOverloadedOperator() const
isOverloadedOperator - Whether this function declaration represents an C++ overloaded operator...
Definition: Decl.h:2267
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2278
static bool checkTrivialClassMembers(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM, bool ConstArg, bool Diagnose)
Check whether the members of a class type allow a special member to be trivial.
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:767
AttributeList * getNext() const
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1110
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:2787
void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace)
ActOnFinishNamespaceDef - This callback is called after a namespace is exited.
capture_iterator capture_end() const
Retrieve an iterator pointing past the end of the sequence of lambda captures.
Definition: ExprCXX.cpp:965
ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val)
Definition: SemaExpr.cpp:3129
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition: DeclSpec.h:968
static unsigned NumImplicitMoveAssignmentOperatorsDeclared
The number of implicitly-declared move assignment operators for which declarations were built...
Definition: ASTContext.h:2712
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Definition: DeclSpec.h:2148
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2994
bool willHaveBody() const
True if this function will eventually have a body, once it&#39;s fully parsed.
Definition: Decl.h:2154
DeclarationName getCXXConstructorName(CanQualType Ty)
getCXXConstructorName - Returns the name of a C++ constructor for the given Type. ...
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
Definition: Decl.h:2590
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3920
CanQualType Char32Ty
Definition: ASTContext.h:1003
The subobject is a base class.
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Lookup.h:260
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false)
Perform unqualified name lookup starting from a given scope.
static UsingPackDecl * Create(ASTContext &C, DeclContext *DC, NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl *> UsingDecls)
Definition: DeclCXX.cpp:2487
static UnresolvedLookupExpr * Create(const ASTContext &C, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool ADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.h:2781
static unsigned NumImplicitDefaultConstructors
The number of implicitly-declared default constructors.
Definition: ASTContext.h:2680
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
Definition: TypeLoc.h:169
Decl * Entity
The entity that is being synthesized.
Definition: Sema.h:7119
Expr *const * semantics_iterator
Definition: Expr.h:5035
static ClassTemplateDecl * LookupStdInitializerList(Sema &S, SourceLocation Loc)
Stmt - This represents one statement.
Definition: Stmt.h:66
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
Definition: DeclSpec.h:938
Filter makeFilter()
Create a filter for this result set.
Definition: Lookup.h:685
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:4111
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3056
CXXCatchStmt * getHandler(unsigned i)
Definition: StmtCXX.h:104
IfStmt - This represents an if/then/else.
Definition: Stmt.h:933
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:456
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program...
Definition: Decl.cpp:2645
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:790
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type...
Definition: Type.h:3668
void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD)
Check a completed declaration of an implicit special member.
bool isElaboratedTypeSpecifier() const
Determine wither this type is a C++ elaborated-type-specifier.
Definition: Type.cpp:2555
EnumConstantDecl - An instance of this object exists for each enum constant that is defined...
Definition: Decl.h:2671
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1893
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:788
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1009
StmtResult ActOnExprStmt(ExprResult Arg)
Definition: SemaStmt.cpp:45
void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnStartDelayedCXXMethodDeclaration - We have completed parsing a top-level (non-nested) C++ class...
static CharSourceRange getTokenRange(SourceRange R)
void addConst()
Add the const type qualifier to this QualType.
Definition: Type.h:815
ActionResult< Expr * > ExprResult
Definition: Ownership.h:251
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2042
static unsigned NumImplicitMoveAssignmentOperators
The number of implicitly-declared move assignment operators.
Definition: ASTContext.h:2708
bool isAscii() const
Definition: Expr.h:1600
bool isRecordType() const
Definition: Type.h:6015
static TemplateArgumentLoc getTrivialTypeTemplateArgument(Sema &S, SourceLocation Loc, QualType T)
Expr * getBase() const
Definition: Expr.h:2477
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D)
ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a C++ if/switch/while/for statem...
void erase()
Erase the last element returned from this iterator.
Definition: Lookup.h:657
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D)
Determine what kind of template specialization the given declaration is.
static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm)
Create the initialization entity for a parameter.
void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc, const CXXRecordDecl *RD)
Mark the exception specifications of all virtual member functions in the given class as needed...
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1880
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
const Type * getTypeForDecl() const
Definition: Decl.h:2784
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
Definition: DeclCXX.h:1427
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1270
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
void setRangeEnd(SourceLocation E)
Definition: Decl.h:1914
bool isVariadic() const
Definition: Type.h:3615
bool needsOverloadResolutionForDestructor() const
Determine whether we need to eagerly declare a destructor for this class.
Definition: DeclCXX.h:1147
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToMemberFunction - Build a call to a member function.
bool isVirtual() const
Definition: DeclCXX.h:2009
static bool FindBaseInitializer(Sema &SemaRef, CXXRecordDecl *ClassDecl, QualType BaseType, const CXXBaseSpecifier *&DirectBaseSpec, const CXXBaseSpecifier *&VirtualBaseSpec)
Find the direct and/or virtual base specifiers that correspond to the given base type, for use in base initialization within a constructor.
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:244
ThreadStorageClassSpecifier getTSCSpec() const
Definition: Decl.h:1018
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl, bool ConsiderCudaAttrs=true)
Opcode getOpcode() const
Definition: Expr.h:3026
StringRef P
bool isTemplateParamScope() const
isTemplateParamScope - Return true if this scope is a C++ template parameter scope.
Definition: Scope.h:371
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:805
void setPure(bool P=true)
Definition: Decl.cpp:2632
void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD)
MarkVirtualMembersReferenced - Will mark all members of the given CXXRecordDecl referenced.
bool isOverrideSpecified() const
Definition: DeclSpec.h:2486
Not a friend object.
Definition: DeclBase.h:1093
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration, or NULL if there is no previous declaration.
Definition: DeclBase.h:952
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:5891
void AddDecl(Decl *D)
Definition: Scope.h:281
static bool isVirtualDirectBase(CXXRecordDecl *Derived, CXXRecordDecl *Base)
Determine whether a direct base class is a virtual base class.
void EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD)
Evaluate the implicit exception specification for a defaulted special member function.
A constructor named via a template-id.
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Definition: SemaExpr.cpp:4321
const RecordDecl * getParent() const
getParent - Returns the parent of this field declaration, which is the struct in which this field is ...
Definition: Decl.h:2648
static bool lookupStdTypeTraitMember(Sema &S, LookupResult &TraitMemberLookup, SourceLocation Loc, StringRef Trait, TemplateArgumentListInfo &Args, unsigned DiagID)
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
Definition: Type.cpp:2465
The base class of the type hierarchy.
Definition: Type.h:1351
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnFinishDelayedCXXMethodDeclaration - We have finished processing the delayed method declaration f...
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
One instance of this struct is used for each type in a declarator that is parsed. ...
Definition: DeclSpec.h:1124
Declaration of a variable template.
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:505
static bool isNonlocalVariable(const Decl *D)
Determine whether the given declaration is a global variable or static data member.
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1239
static FixItHint CreateInsertionFromRange(SourceLocation InsertionLoc, CharSourceRange FromRange, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code from FromRange at a specific location...
Definition: Diagnostic.h:103
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
Definition: DeclSpec.cpp:495
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:133
bool hasTrivialMoveConstructor() const
Determine whether this class has a trivial move constructor (C++11 [class.copy]p12) ...
Definition: DeclCXX.h:1361
QualType withConst() const
Definition: Type.h:818
std::unique_ptr< CachedTokens > DefaultArgTokens
DefaultArgTokens - When the parameter&#39;s default argument cannot be parsed immediately (because it occ...
Definition: DeclSpec.h:1212
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:671
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:95
const NestedNameSpecifier * Specifier
A container of type source information.
Definition: Decl.h:86
Floating point control options.
Definition: LangOptions.h:208
static std::string printTemplateArgs(const PrintingPolicy &PrintingPolicy, TemplateArgumentListInfo &Args)
An overloaded operator name, e.g., operator+.
bool isDefined(const FunctionDecl *&Definition) const
Returns true if the function is defined at all, including a deleted definition.
Definition: Decl.cpp:2605
TSCS getThreadStorageClassSpec() const
Definition: DeclSpec.h:446
bool needsImplicitMoveAssignment() const
Determine whether this class should get an implicit move assignment operator or if any existing speci...
Definition: DeclCXX.h:1114
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclBase.h:412
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2717
bool hasNext() const
Definition: Lookup.h:642
Abstract base class used for diagnosing integer constant expression violations.
Definition: Sema.h:9804
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
unsigned getIdentifierNamespace() const
Definition: DeclBase.h:791
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2397
CanQualType WideCharTy
Definition: ASTContext.h:1000
bool implicitCopyAssignmentHasConstParam() const
Determine whether an implicit copy assignment operator for this type would have a parameter with a co...
Definition: DeclCXX.h:1077
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
Instantiate or parse a C++ default argument expression as necessary.
Definition: SemaExpr.cpp:4471
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3)
Definition: SemaExpr.cpp:13861
bool needsOverloadResolutionForCopyConstructor() const
Determine whether we need to eagerly declare a defaulted copy constructor for this class...
Definition: DeclCXX.h:961
size_t param_size() const
Definition: Decl.h:2183
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
Definition: Decl.h:2597
bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S)
MergeCXXFunctionDecl - Merge two declarations of the same C++ function, once we already know that the...
SourceLocation getOverrideLoc() const
Definition: DeclSpec.h:2487
QualType getElementType() const
Definition: Type.h:2593
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:3097
void CheckCXXDefaultArguments(FunctionDecl *FD)
CheckCXXDefaultArguments - Verify that the default arguments for a function declaration are well-form...
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2087
RAII object to handle the state changes required to synthesize a function body.
Definition: Sema.h:739
NamedDecl * BuildUsingPackDecl(NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl *> Expansions)
static InitializedEntity InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, bool IsInheritedVirtualBase, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a base class subobject.
Definition: SemaInit.cpp:2931
CXXMethodDecl * DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl)
Declare the implicit move assignment operator for the given class.
void ActOnFinishCXXNonNestedClass(Decl *D)
This file provides some common utility functions for processing Lambda related AST Constructs...
std::list< CXXBasePath >::iterator paths_iterator
void ActOnDefaultCtorInitializers(Decl *CDtorDecl)
DeclContext::lookup_result Decls
The set of declarations found inside this base class subobject.
bool isFunctionDeclarationContext() const
Return true if this declaration appears in a context where a function declarator would be a function ...
Definition: DeclSpec.h:2260
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:54
bool isInterface() const
Definition: Decl.h:3163
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10640
void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record)
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:806
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1752
QualType getReturnType() const
Definition: Decl.h:2207
DiagnosticsEngine & Diags
Definition: Sema.h:318
Wrapper for source info for member pointers.
Definition: TypeLoc.h:1301
unsigned getNumParams() const
Definition: Type.h:3489
bool isEnumeralType() const
Definition: Type.h:6019
void finishedDefaultedOrDeletedMember(CXXMethodDecl *MD)
Indicates that the declaration of a defaulted or deleted special member function is now complete...
Definition: DeclCXX.cpp:1070
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6305
bool hasDefaultArg() const
hasDefaultArg - Determines whether this parameter has a default argument, either parsed or not...
Definition: Decl.cpp:2541
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy.
Definition: Sema.h:2128
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
Extra information about a function prototype.
Definition: Type.h:3387
bool hasInheritedDefaultArg() const
Definition: Decl.h:1641
void clear()
Clear the base-paths results.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1580
TypeSpecifierType
Specifies the kind of type.
Definition: Specifiers.h:45
bool needsImplicitCopyAssignment() const
Determine whether this class needs an implicit copy assignment operator to be lazily declared...
Definition: DeclCXX.h:1065
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
Definition: DeclCXX.cpp:2637
The "__interface" keyword.
Definition: Type.h:4691
RAII class that determines when any errors have occurred between the time the instance was created an...
Definition: Diagnostic.h:911
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:422
SourceLocation getFinalLoc() const
Definition: DeclSpec.h:2491
bool field_empty() const
Definition: Decl.h:3628
bool isAmbiguous() const
Definition: Lookup.h:304
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
DeclClass * getCorrectionDeclAs() const
reference front() const
Definition: DeclBase.h:1230
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
Definition: DeclCXX.h:1311
TypeLoc getNamedTypeLoc() const
Definition: TypeLoc.h:2034
bool isInvalidDecl() const
Definition: DeclBase.h:546
Like System, but searched after the system directories.
static StmtResult buildMemcpyForAssignmentOp(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &ToB, const ExprBuilder &FromB)
When generating a defaulted copy or move assignment operator, if a field should be copied with __buil...
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
void setBegin(SourceLocation b)
static StringRef getTagTypeKindName(TagTypeKind Kind)
Definition: Type.h:4768
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
Definition: DeclSpec.h:589
static InitializationKind CreateDirectList(SourceLocation InitLoc)
bool isInterfaceLike() const
Definition: DeclCXX.cpp:1503
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
Definition: Sema.h:7061
void DefineImplicitLambdaToFunctionPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a function pointer.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
bool isStatic() const
Definition: DeclCXX.cpp:1633
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams)
Handle a friend type declaration.
bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM, bool Diagnose=false)
Determine whether a defaulted or deleted special member function is trivial, as specified in C++11 [c...
static AccessSpecDecl * Create(ASTContext &C, AccessSpecifier AS, DeclContext *DC, SourceLocation ASLoc, SourceLocation ColonLoc)
Definition: DeclCXX.h:162
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1513
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Definition: Type.h:885
MutableArrayRef< ParmVarDecl * >::iterator param_iterator
Definition: Decl.h:2175
Defines the clang::Expr interface and subclasses for C++ expressions.
Parse and apply any fixits to the source.
AttributeList * getList() const
void removeDecl(Decl *D)
Removes a declaration from this context.
Definition: DeclBase.cpp:1353
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2014
void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old)
Merge the exception specifications of two variable declarations.
A reasonable base class for TypeLocs that correspond to types that are written as a type-specifier...
Definition: TypeLoc.h:508
CXXConstructorDecl * getTargetConstructor() const
When this constructor delegates to another, retrieve the target.
Definition: DeclCXX.cpp:2078
The collection of all-type qualifiers we support.
Definition: Type.h:152
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Determines whether this field is a representative for an anonymous struct ...
Definition: Decl.cpp:3646
bool isRecordingPaths() const
Whether we are recording paths.
ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false)
ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:5216
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
Definition: DeclCXX.h:1572
void DefineImplicitMoveConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitMoveConstructor - Checks for feasibility of defining this constructor as the move const...
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type. ...
Definition: Decl.cpp:3057
bool FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI)
Definition: SemaInternal.h:37
QualType CheckConstructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckConstructorDeclarator - Called by ActOnDeclarator to check the well-formedness of the constructo...
static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T)
Determine whether the given type is an incomplete or zero-lenfgth array type.
void CheckDelayedMemberExceptionSpecs()
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:265
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:1880
SourceLocation getFriendSpecLoc() const
Definition: DeclSpec.h:698
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
bool isRedeclaration() const
Definition: DeclSpec.h:2454
void ActOnMemInitializers(Decl *ConstructorDecl, SourceLocation ColonLoc, ArrayRef< CXXCtorInitializer *> MemInits, bool AnyErrors)
ActOnMemInitializers - Handle the member initializers for a constructor.
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3488
Decl * ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS, MultiTemplateParamsArg TemplateParams, SourceLocation UsingLoc, UnqualifiedId &Name, AttributeList *AttrList, TypeResult Type, Decl *DeclFromDeclSpec)
bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM, InheritedConstructorInfo *ICI=nullptr, bool Diagnose=false)
Determine if a special member function should have a deleted definition when it is defaulted...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
void LoadExternalVTableUses()
Load any externally-stored vtable uses.
bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc)
Checks that the given nested-name qualifier used in a using decl in the current context is appropriat...
static QualType getTupleLikeElementType(Sema &S, SourceLocation Loc, unsigned I, QualType T)
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1279
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
Description of a constructor that was inherited from a base class.
Definition: DeclCXX.h:2371
static bool IsEquivalentForUsingDecl(ASTContext &Context, NamedDecl *D1, NamedDecl *D2)
Determine whether a using declaration considers the given declarations as "equivalent", e.g., if they are redeclarations of the same entity or are both typedefs of the same type.
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
Definition: DeclSpec.h:962
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:291
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1111
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3388
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:859
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition: Lookup.h:59
unsigned getDepth() const
Retrieve the depth of the template parameter.
static bool IsUsingDirectiveInToplevelContext(DeclContext *CurContext)
Determine whether a using statement is in a context where it will be apply in all contexts...
Decl * ActOnNamespaceAliasDef(Scope *CurScope, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident)
void setRecordingPaths(bool RP)
Specify whether we should be recording paths or not.
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
Definition: Decl.h:2659
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
UnionParsedType ConversionFunctionId
When Kind == IK_ConversionFunctionId, the type that the conversion function names.
Definition: DeclSpec.h:946
void setUninstantiatedDefaultArg(Expr *arg)
Definition: Decl.cpp:2530
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
static unsigned NumImplicitMoveConstructorsDeclared
The number of implicitly-declared move constructors for which declarations were built.
Definition: ASTContext.h:2698
A C++ nested-name-specifier augmented with source location information.
bool isInline() const
Returns true if this is an inline namespace declaration.
Definition: Decl.h:566
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7393
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3496
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1182
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:508
TypeSourceInfo * getTypeSourceInfo() const
Definition: TemplateBase.h:501
ImplicitInitializerKind
ImplicitInitializerKind - How an implicit base or member initializer should initialize its base or me...
static CXXConstructExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr *> Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, ConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Definition: ExprCXX.cpp:791
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
bool defaultedDefaultConstructorIsConstexpr() const
Determine whether a defaulted default constructor for this class would be constexpr.
Definition: DeclCXX.h:1334
RecordDecl * getDefinition() const
getDefinition - Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3609
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclCXX.h:235
field_range fields() const
Definition: Decl.h:3619
BaseResult ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange, ParsedAttributes &Attrs, bool Virtual, AccessSpecifier Access, ParsedType basetype, SourceLocation BaseLoc, SourceLocation EllipsisLoc)
ActOnBaseSpecifier - Parsed a base specifier.
static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info, FieldDecl *Field, IndirectFieldDecl *Indirect=nullptr)
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
void checkExceptionSpecification(bool IsTopLevel, ExceptionSpecificationType EST, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr, SmallVectorImpl< QualType > &Exceptions, FunctionProtoType::ExceptionSpecInfo &ESI)
Check the given exception-specification and update the exception specification information with the r...
UnionParsedTemplateTy TemplateName
When Kind == IK_DeductionGuideName, the parsed template-name.
Definition: DeclSpec.h:957
VarDecl * BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id)
Perform semantic analysis for the variable declaration that occurs within a C++ catch clause...
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2467
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
const PropertyData & getPropertyData() const
TypeSourceInfo * getTypeSourceInfo() const
Returns the declarator information for a base class or delegating initializer.
Definition: DeclCXX.h:2299
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType) const
void removeConst()
Definition: Type.h:273
NoexceptResult
Result type of getNoexceptSpec().
Definition: Type.h:3551
bool isAbstractType(SourceLocation Loc, QualType T)
static bool isIncrementDecrementOp(Opcode Op)
Definition: Expr.h:1778
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/__unaligned The qualifier bitmask values are the same as...
Definition: DeclSpec.h:1247
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Lookup.h:245
bool isFunctionDefinition() const
Definition: DeclSpec.h:2431
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2046
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.h:2593
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
bool isReferenceType() const
Definition: Type.h:5954
CXXRecordDecl * getStdBadAlloc() const
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class.copy]p25)
Definition: DeclCXX.h:1389
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2064
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Definition: DeclCXX.h:2593
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
static UnresolvedUsingTypenameDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation TypenameLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TargetNameLoc, DeclarationName TargetName, SourceLocation EllipsisLoc)
Definition: DeclCXX.cpp:2536
static void extendLeft(SourceRange &R, SourceRange Before)
bool hasUserDeclaredDestructor() const
Determine whether this class has a user-declared destructor.
Definition: DeclCXX.h:1135
DeclarationName getCXXDestructorName(CanQualType Ty)
getCXXDestructorName - Returns the name of a C++ destructor for the given Type.
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr)
Definition: Expr.cpp:391
ParmVarDecl * getParam(unsigned i) const
Definition: TypeLoc.h:1477
unsigned getTypeQualifiers() const
Definition: DeclCXX.h:2104
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:6136
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1455
llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const
Make an APSInt of the appropriate width and signedness for the given Value and integer Type...
Definition: ASTContext.h:2532
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1877
static bool CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S, SmallVectorImpl< SourceLocation > &ReturnStmts, SourceLocation &Cxx1yLoc)
Check the provided statement is allowed in a constexpr function definition.
LookupResultKind getResultKind() const
Definition: Lookup.h:324
bool DefineUsedVTables()
Define all of the vtables that have been used in this translation unit and reference any virtual memb...
void setParams(ArrayRef< ParmVarDecl *> NewParamInfo)
Definition: Decl.h:2198
Expr * getSubExpr()
Definition: Expr.h:2761
Represents an access specifier followed by colon &#39;:&#39;.
Definition: DeclCXX.h:131
void ClearStorageClassSpecs()
Definition: DeclSpec.h:459
void addShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:2435
void CheckDeductionGuideDeclarator(Declarator &D, QualType &R, StorageClass &SC)
Check the validity of a declarator that we parsed for a deduction-guide.
SourceLocation getTemplateLoc() const
Definition: DeclTemplate.h:172
void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator, which is not a function declaration or definition and therefore is not permitted to have default arguments.
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition: Lookup.h:41
A user-defined literal name, e.g., operator "" _i.
IdentifierTable & Idents
Definition: ASTContext.h:537
unsigned getTypeQuals() const
Definition: Type.h:3627
SpecialMemberOverloadResult - The overloading result for a special member function.
Definition: Sema.h:1025
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
Definition: SemaExpr.cpp:92
void setImplicitCopyConstructorIsDeleted()
Set that we attempted to declare an implicit copy constructor, but overload resolution failed so we d...
Definition: DeclCXX.h:1014
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:107
bool isInvalidType() const
Definition: DeclSpec.h:2412
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2167
DeclClass * getAsSingle() const
Definition: Lookup.h:510
void FindHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl< CXXMethodDecl *> &OverloadedMethods)
Check if a method overloads virtual methods in a base class without overriding any.
bool isFinalSpelledSealed() const
Definition: DeclSpec.h:2490
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl, DeclStmt *DS, SourceLocation &Cxx1yLoc)
Check the given declaration statement is legal within a constexpr function body.
UnionParsedType DestructorName
When Kind == IK_DestructorName, the type referred to by the class-name.
Definition: DeclSpec.h:954
Describes an C or C++ initializer list.
Definition: Expr.h:3872
Represents a C++ using-declaration.
Definition: DeclCXX.h:3275
ArrayRef< BindingDecl * > bindings() const
Definition: DeclCXX.h:3798
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:910
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2484
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1615
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2545
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization. ...
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
Definition: SemaLookup.cpp:471
NamespaceDecl * getOrCreateStdNamespace()
Retrieve the special "std" namespace, which may require us to implicitly define the namespace...
Represents the results of name lookup.
Definition: Lookup.h:32
PtrTy get() const
Definition: Ownership.h:162
bool isDelegatingConstructor() const
Determine whether this constructor is a delegating constructor.
Definition: DeclCXX.h:2516
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
void CalledExpr(Expr *E)
Integrate an invoked expression into the collected data.
static InitializedEntity InitializeDelegation(QualType Type)
Create the initialization entity for a delegated constructor.
TagKind getTagKind() const
Definition: Decl.h:3156
Microsoft throw(...) extension.
A convenient class for passing around template argument information.
Definition: TemplateBase.h:546
AccessSpecifier getAccessSpecifier() const
Returns the access specifier for this base specifier.
Definition: DeclCXX.h:271
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2166
CXXConstructorDecl * DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit move constructor for the given class.
bool isSpecialMemberAccessibleForDeletion(CXXMethodDecl *decl, AccessSpecifier access, QualType objectType)
Is the given special member function accessible for the purposes of deciding whether to define a spec...
bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method)
Check whether &#39;this&#39; shows up in the type of a static member function after the (naturally empty) cv-...
bool CheckUsingShadowDecl(UsingDecl *UD, NamedDecl *Target, const LookupResult &PreviousDecls, UsingShadowDecl *&PrevShadow)
Determines whether to create a using shadow decl for a particular decl, given the set of decls existi...
bool needsOverloadResolutionForCopyAssignment() const
Determine whether we need to eagerly declare a defaulted copy assignment operator for this class...
Definition: DeclCXX.h:1071
void FilterAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true)
bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS)
Determine whether the identifier II is a typo for the name of the class type currently being defined...
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3226
bool CheckConstexprFunctionDecl(const FunctionDecl *FD)
void DefineInheritingConstructor(SourceLocation UseLoc, CXXConstructorDecl *Constructor)
Define the specified inheriting constructor.
ArrayRef< NamedDecl * > chain() const
Definition: Decl.h:2733
An x-value expression is a reference to an object with independent storage but which can be "moved"...
Definition: Specifiers.h:116
A friend of a previously-undeclared entity.
Definition: DeclBase.h:1095
child_range children()
Definition: Stmt.cpp:226
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:2144
SourceLocation getEndLoc() const
getEndLoc - Retrieve the location of the last token.
static bool BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, FieldDecl *Field, IndirectFieldDecl *Indirect, CXXCtorInitializer *&CXXMemberInit)
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
Definition: SemaExpr.cpp:14989
StmtResult StmtError()
Definition: Ownership.h:268
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:635
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1633
static void NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set, const QualType &Type)
Recursively add the bases of Type. Don&#39;t add Type itself.
semantics_iterator semantics_end()
Definition: Expr.h:5043
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1113
void ActOnBaseSpecifiers(Decl *ClassDecl, MutableArrayRef< CXXBaseSpecifier *> Bases)
ActOnBaseSpecifiers - Attach the given base specifiers to the class, after checking whether there are...
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2760
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2985
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5788
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
Definition: Sema.h:7116
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt *> Stmts, SourceLocation LB, SourceLocation RB)
Definition: Stmt.cpp:316
void CheckDelegatingCtorCycles()
QualType getExceptionObjectType(QualType T) const
QualType CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckDestructorDeclarator - Called by ActOnDeclarator to check the well-formednes of the destructor d...
static void ReferenceDllExportedMethods(Sema &S, CXXRecordDecl *Class)
enum clang::DeclaratorChunk::@198 Kind
bool isRValueReferenceType() const
Definition: Type.h:5962
static void checkMoveAssignmentForRepeatedMove(Sema &S, CXXRecordDecl *Class, SourceLocation CurrentLocation)
Check if we&#39;re implicitly defining a move assignment operator for a class with virtual bases...
bool isNull() const
Definition: TypeLoc.h:118
child_range children()
Definition: Expr.h:4055
void setExceptionVariable(bool EV)
Definition: Decl.h:1302
DeclContextLookupResult slice(size_t N) const
Definition: DeclBase.h:1235
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1152
CanQualType LongDoubleTy
Definition: ASTContext.h:1007
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, const ASTContext *Context=nullptr) const
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence...
Definition: SemaInit.cpp:6530
QualType getCVRQualifiedType(QualType T, unsigned CVR) const
Return a type with additional const, volatile, or restrict qualifiers.
Definition: ASTContext.h:1875
bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5718
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:705
field_iterator field_begin() const
Definition: Decl.cpp:3960
param_type_iterator param_type_begin() const
Definition: Type.h:3641
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3656
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1153
bool hasUnparsedDefaultArg() const
hasUnparsedDefaultArg - Determines whether this parameter has a default argument that has not yet bee...
Definition: Decl.h:1624
CXXBaseSpecifier * CheckBaseSpecifier(CXXRecordDecl *Class, SourceRange SpecifierRange, bool Virtual, AccessSpecifier Access, TypeSourceInfo *TInfo, SourceLocation EllipsisLoc)
ActOnBaseSpecifier - Parsed a base specifier.
void setTrivial(bool IT)
Definition: Decl.h:2008
ExprResult ActOnCXXThis(SourceLocation loc)
bool isAnyMemberInitializer() const
Definition: DeclCXX.h:2246
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
static unsigned NumImplicitDefaultConstructorsDeclared
The number of implicitly-declared default constructors for which declarations were built...
Definition: ASTContext.h:2684
void setNumCtorInitializers(unsigned numCtorInitializers)
Definition: DeclCXX.h:2499
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:820
FieldDecl * getAnyMember() const
Definition: DeclCXX.h:2311
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:964
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1580
Preprocessor & PP
Definition: Sema.h:315
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1404
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1869
const LangOptions & getLangOpts() const
Definition: Sema.h:1193
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
Definition: DeclCXX.cpp:2362
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value &#39;V&#39; and type &#39;type&#39;.
Definition: Expr.cpp:748
TemplateArgumentLoc getArgLoc(unsigned i) const
Definition: TypeLoc.h:1661
bool isInstance() const
Definition: DeclCXX.h:1992
SourceLocation getConstSpecLoc() const
Definition: DeclSpec.h:540
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:167
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:1856
static bool findCircularInheritance(const CXXRecordDecl *Class, const CXXRecordDecl *Current)
Determine whether the given class is a base class of the given class, including looking at dependent ...
static void DelegatingCycleHelper(CXXConstructorDecl *Ctor, llvm::SmallSet< CXXConstructorDecl *, 4 > &Valid, llvm::SmallSet< CXXConstructorDecl *, 4 > &Invalid, llvm::SmallSet< CXXConstructorDecl *, 4 > &Current, Sema &S)
const TemplateArgument * data() const
Retrieve a pointer to the template argument list.
Definition: DeclTemplate.h:273
An ordinary object is located at an address in memory.
Definition: Specifiers.h:123
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1458
Decl * ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc, Expr *LangStr, SourceLocation LBraceLoc)
ActOnStartLinkageSpecification - Parsed the beginning of a C++ linkage specification, including the language and (if present) the &#39;{&#39;.
Represents an ObjC class declaration.
Definition: DeclObjC.h:1191
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
Definition: DeclCXX.h:2305
Represents a linkage specification.
Definition: DeclCXX.h:2743
ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, ActOnMemberAccessExtraArgs *ExtraArgs=nullptr)
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:501
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Lookup.h:429
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:3002
bool containsUnexpandedParameterPack() const
Determine whether this name contains an unexpanded parameter pack.
bool hasConstexprDefaultConstructor() const
Determine whether this class has a constexpr default constructor.
Definition: DeclCXX.h:1340
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:500
bool isAbstract() const
Determine whether this class has a pure virtual function.
Definition: DeclCXX.h:1296
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
Definition: SemaExpr.cpp:2720
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
Definition: CanonicalType.h:84
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:3375
A binding in a decomposition declaration.
Definition: DeclCXX.h:3718
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:143
init_iterator init_begin()
Retrieve an iterator to the first initializer.
Definition: DeclCXX.h:2457
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:2106
Ordinary names.
Definition: DeclBase.h:144
unsigned getLength() const
Efficiently return the length of this identifier info.
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:869
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location...
static TemplateArgumentLoc getTrivialIntegralTemplateArgument(Sema &S, SourceLocation Loc, QualType T, uint64_t I)
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Whether this is an anonymous struct or union.
Definition: Decl.h:3556
param_iterator param_begin()
Definition: Decl.h:2179
Represents the this expression in C++.
Definition: ExprCXX.h:945
UsingShadowDecl * BuildUsingShadowDecl(Scope *S, UsingDecl *UD, NamedDecl *Target, UsingShadowDecl *PrevDecl)
Builds a shadow declaration corresponding to a &#39;using&#39; declaration.
static bool isValidUDSuffix(const LangOptions &LangOpts, StringRef Suffix)
Determine whether a suffix is a valid ud-suffix.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1536
Class that aids in the construction of nested-name-specifiers along with source-location information ...
ExtInfo withCallingConv(CallingConv cc) const
Definition: Type.h:3177
static StmtResult buildSingleCopyAssign(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &To, const ExprBuilder &From, bool CopyingBaseSubobject, bool Copying)
SourceLocation LAngleLoc
The location of the &#39;<&#39; before the template argument list.
void removeInClassInitializer()
removeInClassInitializer - Remove the C++11 in-class initializer from this member.
Definition: Decl.h:2625
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3327
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1197
static bool checkArrayDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const ConstantArrayType *CAT)
bool isFinalSpecified() const
Definition: DeclSpec.h:2489
void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an initializer for the declaratio...
CXXSpecialMember
Kinds of C++ special members.
Definition: Sema.h:1129
NodeId Parent
Definition: ASTDiff.cpp:192
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:216
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
MemInitResult BuildMemInitializer(Decl *ConstructorD, Scope *S, CXXScopeSpec &SS, IdentifierInfo *MemberOrBase, ParsedType TemplateTypeTy, const DeclSpec &DS, SourceLocation IdLoc, Expr *Init, SourceLocation EllipsisLoc)
Handle a C++ member initializer.
CXXConstructorDecl * findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor, ConstructorUsingShadowDecl *DerivedShadow)
Given a derived-class using shadow declaration for a constructor and the correspnding base class cons...
void setBases(CXXBaseSpecifier const *const *Bases, unsigned NumBases)
Sets the base classes of this struct or class.
Definition: DeclCXX.cpp:165
bool hasAttr() const
Definition: DeclBase.h:535
CXXConstructorDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2598
bool hasUserProvidedDefaultConstructor() const
Whether this class has a user-provided default constructor per C++11.
Definition: DeclCXX.h:942
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3269
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1848
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:274
Decl * ActOnEmptyDeclaration(Scope *S, AttributeList *AttrList, SourceLocation SemiLoc)
Handle a C++11 empty-declaration and attribute-declaration.
StringRef getString() const
Definition: Expr.h:1557
TypeAliasDecl - Represents the declaration of a typedef-name via a C++0x alias-declaration.
Definition: Decl.h:2918
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:595
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1590
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3268
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition: DeclSpec.cpp:119
bool isDynamicClass() const
Definition: DeclCXX.h:751
void ClearConstexprSpec()
Definition: DeclSpec.h:706
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
CreateBuiltinBinOp - Creates a new built-in binary operation with operator Opc at location TokLoc...
Definition: SemaExpr.cpp:11577
void ActOnFinishCXXMemberDecls()
Perform any semantic analysis which needs to be delayed until all pending class member declarations h...
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any...
Definition: Decl.cpp:3172
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1302
void DefineImplicitCopyAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared copy assignment operator.
static unsigned NumImplicitCopyConstructors
The number of implicitly-declared copy constructors.
Definition: ASTContext.h:2687
bool isDeclarationOfFunction() const
Determine whether the declaration that will be produced from this declaration will be a function...
Definition: DeclSpec.cpp:308
A RAII object to enter scope of a compound statement.
Definition: Sema.h:3673
bool isMoreQualifiedThan(QualType Other) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
Definition: Type.h:5862
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:1386
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:680
SourceRange getLocalSourceRange() const
Get the local source range.
Definition: TypeLoc.h:158
static Sema::ImplicitExceptionSpecification ComputeDefaultedSpecialMemberExceptionSpec(Sema &S, SourceLocation Loc, CXXMethodDecl *MD, Sema::CXXSpecialMember CSM, Sema::InheritedConstructorInfo *ICI)
bool isDelegatingInitializer() const
Determine whether this initializer is creating a delegating constructor.
Definition: DeclCXX.h:2266
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1718
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:540
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1270
llvm::FoldingSet< SpecialMemberOverloadResultEntry > SpecialMemberCache
A cache of special member function overload resolution results for C++ records.
Definition: Sema.h:1059
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:5793
void NoteHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl< CXXMethodDecl *> &OverloadedMethods)
bool mayHaveDecompositionDeclarator() const
Return true if the context permits a C++17 decomposition declarator.
Definition: DeclSpec.h:1995
static EmptyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
Definition: Decl.cpp:4424
A conversion function name, e.g., operator int.
SourceRange getRange() const
Definition: DeclSpec.h:68
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
bool isInlineSpecified() const
Definition: Decl.h:1351
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
static StaticAssertDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StaticAssertLoc, Expr *AssertExpr, StringLiteral *Message, SourceLocation RParenLoc, bool Failed)
Definition: DeclCXX.cpp:2557
bool isLiteral() const
Determine whether this class is a literal type.
Definition: DeclCXX.h:1491
void setInClassInitializer(Expr *Init)
setInClassInitializer - Set the C++11 in-class initializer for this member.
Definition: Decl.h:2615
const CXXRecordDecl * getParent() const
Returns the parent of this using shadow declaration, which is the class in which this is declared...
Definition: DeclCXX.h:3219
void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param)
This is used to implement the constant expression evaluation part of the attribute enable_if extensio...
MemInitResult BuildMemberInitializer(ValueDecl *Member, Expr *Init, SourceLocation IdLoc)
TST getTypeSpecType() const
Definition: DeclSpec.h:477
static void diagnoseDeprecatedCopyOperation(Sema &S, CXXMethodDecl *CopyOp)
Diagnose an implicit copy operation for a class which is odr-used, but which is deprecated because th...
bool hasKeyFunctions() const
Does this ABI use key functions? If so, class data such as the vtable is emitted with strong linkage ...
Definition: TargetCXXABI.h:234
bool hasInheritedConstructor() const
Determine whether this class has a using-declaration that names a user-declared base class constructo...
Definition: DeclCXX.h:1451
static Sema::SpecialMemberOverloadResult lookupCallFromSpecialMember(Sema &S, CXXRecordDecl *Class, Sema::CXXSpecialMember CSM, unsigned FieldQuals, bool ConstRHS)
Look up the special member function that would be called by a special member function for a subobject...
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
Definition: Expr.cpp:2942
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isInline, bool isImplicitlyDeclared)
Definition: DeclCXX.cpp:2196
llvm::PointerIntPair< CXXRecordDecl *, 3, CXXSpecialMember > SpecialMemberDecl
Definition: Sema.h:1140
bool isMsStruct(const ASTContext &C) const
Get whether or not this is an ms_struct which can be turned on with an attribute, pragma...
Definition: Decl.cpp:3977
static bool checkComplexDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const ComplexType *CT)
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:190
static bool checkArrayLikeDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType)
Allows QualTypes to be sorted and hence used in maps and sets.
Decl * ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *AssertMessageExpr, SourceLocation RParenLoc)
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:432
QualType getElementType() const
Definition: Type.h:2236
bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method)
Whether this&#39; shows up in the exception specification of a static member function.
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2241
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3163
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition: Decl.h:3127
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:627
Expr - This represents one expression.
Definition: Expr.h:106
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Definition: DeclCXX.cpp:2107
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3315
StringRef getKindName() const
Definition: Decl.h:3152
QualType getPointeeType() const
Definition: Type.h:2440
void DefineImplicitCopyConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitCopyConstructor - Checks for feasibility of defining this constructor as the copy const...
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:104
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2574
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2012
llvm::StringRef getAsString(SyncScope S)
Definition: SyncScope.h:51
bool isExplicitSpecified() const
Definition: DeclSpec.h:569
bool isDeclScope(Decl *D)
isDeclScope - Return true if this is the scope that the specified decl is declared in...
Definition: Scope.h:315
Helper class that collects exception specifications for implicitly-declared special member functions...
Definition: Sema.h:4682
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
static void DiagnoseBaseOrMemInitializerOrder(Sema &SemaRef, const CXXConstructorDecl *Constructor, ArrayRef< CXXCtorInitializer *> Inits)
bool isDecompositionDeclarator() const
Return whether this declarator is a decomposition declarator.
Definition: DeclSpec.h:2102
const FunctionProtoType * T
void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath)
StateNode * Previous
Declaration of a template type parameter.
unsigned getIndex() const
Definition: Type.h:4219
DeclContext * getEntity() const
Definition: Scope.h:319
bool defaultedMoveConstructorIsDeleted() const
true if a defaulted move constructor for this class would be deleted.
Definition: DeclCXX.h:871
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:3322
void setHideTags(bool Hide)
Sets whether tag declarations should be hidden by non-tag declarations during resolution.
Definition: Lookup.h:300
This file defines the classes used to store parsed information about declaration-specifiers and decla...
IsTupleLike
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6368
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:4705
void getFinalOverriders(CXXFinalOverriderMap &FinaOverriders) const
Retrieve the final overriders for each virtual member function in the class hierarchy where this clas...
const Stmt * getThen() const
Definition: Stmt.h:971
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
void setRBraceLoc(SourceLocation L)
Definition: Decl.h:611
Inits[]
Definition: OpenMPClause.h:140
static bool checkVectorDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const VectorType *VT)
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
OpaquePtr< T > get() const
Definition: Ownership.h:98
static UnresolvedUsingValueDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, SourceLocation EllipsisLoc)
Definition: DeclCXX.cpp:2508
SourceLocation getLocation() const
Definition: ExprCXX.h:961
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:86
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2620
void freeParams()
Reset the parameter list to having zero parameters.
Definition: DeclSpec.h:1339
void setInit(Expr *I)
Definition: Decl.cpp:2156
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
std::string getAsString() const
getNameAsString - Retrieve the human-readable string for this name.
unsigned getNumInits() const
Definition: Expr.h:3902
static unsigned NumImplicitMoveConstructors
The number of implicitly-declared move constructors.
Definition: ASTContext.h:2694
SourceLocation getVolatileSpecLoc() const
Definition: DeclSpec.h:542
SourceLocation getThreadStorageClassSpecLoc() const
Definition: DeclSpec.h:455
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:551
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
Definition: DeclCXX.cpp:1413
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3347
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
const Expr * getCallee() const
Definition: Expr.h:2249
void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir)
void setRBraceLoc(SourceLocation L)
Definition: DeclCXX.h:2804
Defines the clang::Preprocessor interface.
bool CheckInheritingConstructorUsingDecl(UsingDecl *UD)
Additional checks for a using declaration referring to a constructor name.
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const
Test if this context is part of the enclosing namespace set of the context NS, as defined in C++0x [n...
Definition: DeclBase.cpp:1690
bool hasUserDeclaredMoveAssignment() const
Determine whether this class has had a move assignment declared by the user.
Definition: DeclCXX.h:1092
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, bool AllowFold=true)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
Definition: SemaExpr.cpp:13517
field_iterator field_end() const
Definition: Decl.h:3622
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD)
overridden_method_range overridden_methods() const
Definition: DeclCXX.cpp:1926
bool isLocalExternDecl()
Determine whether this is a block-scope declaration with linkage.
Definition: DeclBase.h:1052
bool isFileContext() const
Definition: DeclBase.h:1401
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:72
bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc, SourceLocation ColonLoc, AttributeList *Attrs=nullptr)
ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
DeclContext * getDeclContext()
Definition: DeclBase.h:425
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:731
bool isConstexprSpecified() const
Definition: DeclSpec.h:703
A parsed C++17 decomposition declarator of the form &#39;[&#39; identifier-list &#39;]&#39;.
Definition: DeclSpec.h:1653
ExprResult BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, TypeSourceInfo *Ty, Expr *E, SourceRange AngleBrackets, SourceRange Parens)
Definition: SemaCast.cpp:240
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition: Type.cpp:2452
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, Expr *Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member, and after instantiating an in-class initializer in a class template.
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation...
Definition: DeclCXX.cpp:463
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:65
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2237
static void DefineImplicitSpecialMember(Sema &S, CXXMethodDecl *MD, SourceLocation DefaultLoc)
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Definition: DeclBase.h:1956
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack...
Definition: DeclBase.cpp:201
void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param)
ActOnDelayedCXXMethodParameter - We&#39;ve already started a delayed C++ method declaration.
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
bool needsImplicitDestructor() const
Determine whether this class needs an implicit destructor to be lazily declared.
Definition: DeclCXX.h:1141
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7394
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:454
Defines the clang::TypeLoc interface and its subclasses.
There is no noexcept specifier.
Definition: Type.h:3553
int Depth
Definition: ASTDiff.cpp:191
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:1788
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:992
void DiscardCleanupsInEvaluationContext()
Definition: SemaExpr.cpp:13788
IdentifierInfo * getAsIdentifierInfo() const
getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in this declaration name, or NULL if this declaration name isn&#39;t a simple identifier.
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined...
Definition: DeclBase.h:618
void propagateDLLAttrToBaseClassTemplate(CXXRecordDecl *Class, Attr *ClassAttr, ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc)
Perform propagation of DLL attributes from a derived class to a templated base class for MS compatibi...
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
Definition: DeclCXX.h:1289
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const
Determine whether the result of this expression is a temporary object of the given class type...
Definition: Expr.cpp:2659
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body (definition).
Definition: Decl.cpp:2580
void setInheritConstructors(bool Inherit=true)
Set that this base class&#39;s constructors should be inherited.
Definition: DeclCXX.h:257
bool isInvalid() const
QualType getType() const
Definition: Expr.h:128
SourceLocation getLocEnd() const LLVM_READONLY
bool isFunctionOrMethod() const
Definition: DeclBase.h:1384
static bool isPotentialConstantExpr(const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExpr - Return true if this function&#39;s definition might be usable in a constant exp...
StorageClass
Storage classes.
Definition: Specifiers.h:203
void DefineImplicitMoveAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared move assignment operator.
void CheckCompletedCXXClass(CXXRecordDecl *Record)
Perform semantic checks on a class definition that has been completing, introducing implicitly-declar...
void AdjustDestructorExceptionSpec(CXXRecordDecl *ClassDecl, CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don&#39;t have one.
bool isIdentifier() const
Predicate functions for querying what type of name this is.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Lookup.h:311
InClassInitStyle
In-class initialization styles for non-static data members.
Definition: Specifiers.h:226
Declaration of an alias template.
static unsigned getRecordDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for record diagnostic message.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1335
A boolean condition, from &#39;if&#39;, &#39;while&#39;, &#39;for&#39;, or &#39;do&#39;.
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc)
static bool specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, Sema::CXXSpecialMember CSM, unsigned Quals, bool ConstRHS, CXXConstructorDecl *InheritedCtor=nullptr, Sema::InheritedConstructorInfo *Inherited=nullptr)
Is the special member function which would be selected to perform the specified operation on the spec...
QualType getRecordType(const RecordDecl *Decl) const
bool isInvalid() const
Definition: Ownership.h:158
SourceLocation getEnd() const
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1717
void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method)
Integrate another called method into the collected data.
CXXMethodDecl * getMethodDecl() const
Retrieves the declaration of the called method.
Definition: ExprCXX.cpp:517
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1333
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
Definition: SemaType.cpp:7724
Represents a GCC generic vector type.
Definition: Type.h:2914
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2466
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1041
bool isFriendSpecified() const
Definition: DeclSpec.h:697
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:6263
void addContextNote(SourceLocation UseLoc)
Definition: Sema.h:756
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class...
Definition: DeclCXX.h:1348
void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an initializer for the declaration ...
void setOperatorDelete(FunctionDecl *OD, Expr *ThisArg)
Definition: DeclCXX.cpp:2208
ValueDecl * getDecl()
Definition: Expr.h:1041
Represents a C++ deduction guide declaration.
Definition: DeclCXX.h:1911
bool needsImplicitDefaultConstructor() const
Determine if we need to declare a default constructor for this class.
Definition: DeclCXX.h:924
bool isUsable() const
Definition: Ownership.h:159
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2682
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1347
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:149
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2007
bool isUnionType() const
Definition: Type.cpp:432
SourceLocation getLocEnd() const LLVM_READONLY
Definition: TypeLoc.h:155
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2073
static void PopulateKeysForFields(FieldDecl *Field, SmallVectorImpl< const void *> &IdealInits)
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
bool hasNonTrivialMoveAssignment() const
Determine whether this class has a non-trivial move assignment operator (C++11 [class.copy]p25)
Definition: DeclCXX.h:1396
bool isProvablyNotDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is provably not derived from the type Base.
void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM)
Diagnose why the specified class does not have a trivial special member of the given kind...
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:167
bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New, const CXXMethodDecl *Old)
void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitDefaultConstructor - Checks for feasibility of defining this constructor as the default...
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:233
TypeLoc getReturnLoc() const
Definition: TypeLoc.h:1480
static bool RefersToRValueRef(Expr *MemRef)
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:1102
static bool computeCanPassInRegisters(Sema &S, CXXRecordDecl *D)
Determine whether a type is permitted to be passed or returned in registers, per C++ [class...
void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc, Decl *TagDecl, SourceLocation LBrac, SourceLocation RBrac, AttributeList *AttrList)
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:5751
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
ExprResult ActOnFinishFullExpr(Expr *Expr)
Definition: Sema.h:5244
bool CheckConstexprFunctionBody(const FunctionDecl *FD, Stmt *Body)
Check the body for the given constexpr function declaration only contains the permitted types of stat...
#define CheckPolymorphic(Type)
CanQualType getCanonicalTypeUnqualified() const
SourceLocation getRefQualifierLoc() const
Retrieve the location of the ref-qualifier, if any.
Definition: DeclSpec.h:1398
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5777
bool hasGroupingParens() const
Definition: DeclSpec.h:2417
void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow)
Hides a using shadow declaration.
bool hasTrailingReturn() const
Definition: Type.h:3625
RecordDecl * getDecl() const
Definition: Type.h:3986
bool hasVariantMembers() const
Determine whether this class has any variant members.
Definition: DeclCXX.h:1307
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
void addAttr(Attr *A)
Definition: DeclBase.h:484
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
Definition: Decl.cpp:3941
unsigned size_overridden_methods() const
Definition: DeclCXX.cpp:1920
static void SearchForReturnInStmt(Sema &Self, Stmt *S)
Wrapper for source info for arrays.
Definition: TypeLoc.h:1529
static bool DiagnoseUnexpandedParameterPacks(Sema &S, TemplateTemplateParmDecl *TTP)
Check for unexpanded parameter packs within the template parameters of a template template parameter...
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl, CXXConstructorDecl *Constructor, MultiExprArg Exprs, bool HadMultipleCandidates, bool IsListInitialization, bool IsStdInitListInitialization, bool RequiresZeroInit, unsigned ConstructKind, SourceRange ParenRange)
BuildCXXConstructExpr - Creates a complete call to a constructor, including handling of its default a...
bool containsUnexpandedParameterPack() const
Whether this nested-name-specifier contains an unexpanded parameter pack (for C++11 variadic template...
Decl::Kind getDeclKind() const
Definition: DeclBase.h:1328
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
static bool CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef, const FunctionDecl *FnDecl)
IdentifierInfo * getCXXLiteralIdentifier() const
getCXXLiteralIdentifier - If this name is the name of a literal operator, retrieve the identifier ass...
UnqualifiedIdKind Kind
Describes the kind of unqualified-id parsed.
Definition: DeclSpec.h:917
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:868
static unsigned NumImplicitDestructorsDeclared
The number of implicitly-declared destructors for which declarations were built.
Definition: ASTContext.h:2719
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1708
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
We are declaring an implicit special member function.
Definition: Sema.h:7105
CXXSpecialMember SpecialMember
The special member being declared or defined.
Definition: Sema.h:7137
CanQualType BuiltinFnTy
Definition: ASTContext.h:1014
The "struct" keyword.
Definition: Type.h:4688
Kind
static CXXConstructorDecl * findUserDeclaredCtor(CXXRecordDecl *RD)
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1400
static const CXXRecordDecl * findDecomposableBaseClass(Sema &S, SourceLocation Loc, const CXXRecordDecl *RD, CXXCastPath &BasePath)
Find the base class to decompose in a built-in decomposition of a class type.
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:144
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3365
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:4969
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1196
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2478
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:208
ExtParameterInfo getExtParameterInfo(unsigned I) const
Definition: Type.h:3684
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3500
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:220
SCS getStorageClassSpec() const
Definition: DeclSpec.h:445
SourceRange getSourceRange() const LLVM_READONLY
Determine the source range covering the entire initializer.
Definition: DeclCXX.cpp:2032
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, ArrayRef< TemplateParameterList *> FriendTypeTPLists=None)
Definition: DeclFriend.cpp:35
NamedDecl * BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, AttributeList *AttrList, bool IsInstantiation)
Builds a using declaration.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:299
llvm::SmallPtrSet< QualType, 4 > IndirectBaseSet
Use small set to collect indirect bases.
bool hasTrivialCopyAssignment() const
Determine whether this class has a trivial copy assignment operator (C++ [class.copy]p11, C++11 [class.copy]p25)
Definition: DeclCXX.h:1376
Encodes a location in the source.
void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record)
body_range body()
Definition: Stmt.h:626
QualType getReturnType() const
Definition: Type.h:3201
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4002
bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange)
Mark the given method pure.
bool hasSameTemplateName(TemplateName X, TemplateName Y)
Determine whether the given template names refer to the same template.
Decl * ActOnFinishLinkageSpecification(Scope *S, Decl *LinkageSpec, SourceLocation RBraceLoc)
ActOnFinishLinkageSpecification - Complete the definition of the C++ linkage specification LinkageSpe...
unsigned getNumHandlers() const
Definition: StmtCXX.h:103
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1335
Expr * getSubExpr() const
Definition: Expr.h:1744
bool hasErrorOccurred() const
Determine whether any errors have occurred since this object instance was created.
Definition: Diagnostic.h:922
Decl * BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, StringLiteral *AssertMessageExpr, SourceLocation RParenLoc, bool Failed)
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1874
Attr * clone(ASTContext &C) const
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
Definition: DeclSpec.h:1860
CastKind getCastKind() const
Definition: Expr.h:2757
static void CheckConstexprCtorInitializer(Sema &SemaRef, const FunctionDecl *Dcl, FieldDecl *Field, llvm::SmallSet< Decl *, 16 > &Inits, bool &Diagnosed)
Check that the given field is initialized within a constexpr constructor.
bool isUnnamedBitfield() const
Determines whether this is an unnamed bitfield.
Definition: Decl.h:2548
static unsigned NumImplicitCopyAssignmentOperatorsDeclared
The number of implicitly-declared copy assignment operators for which declarations were built...
Definition: ASTContext.h:2705
bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method)
Check whether &#39;this&#39; shows up in the attributes of the given static member function.
DeclarationName getName() const
getName - Returns the embedded declaration name.
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2944
SourceLocation getUsingLoc() const
Return the source location of the &#39;using&#39; keyword.
Definition: DeclCXX.h:3308
void referenceDLLExportedClassMethods()
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:164
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:378
FunctionTypeInfo Fun
Definition: DeclSpec.h:1494
bool isModulePrivateSpecified() const
Definition: DeclSpec.h:700
InheritedConstructorInfo(Sema &S, SourceLocation UseLoc, ConstructorUsingShadowDecl *Shadow)
static bool CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl, CanQualType ExpectedResultType, CanQualType ExpectedFirstParamType, unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag)
QualType getElementType() const
Definition: Type.h:2949
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
Definition: SemaInternal.h:94
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:487
void setReferenced(bool R=true)
Definition: DeclBase.h:581
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:823
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec and return false if there was no error...
Definition: DeclSpec.cpp:551
void DefineImplicitDestructor(SourceLocation CurrentLocation, CXXDestructorDecl *Destructor)
DefineImplicitDestructor - Checks for feasibility of defining this destructor as the default destruct...
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3494
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3714
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set...
Definition: Decl.h:2604
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
Definition: Type.h:781
const DecompositionDeclarator & getDecompositionDeclarator() const
Definition: DeclSpec.h:1862
void removeShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:2445
void setCtorInitializers(CXXCtorInitializer **Initializers)
Definition: DeclCXX.h:2503
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1964
void setDefaulted(bool D=true)
Definition: Decl.h:2013
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2321
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3529
paths_iterator begin()
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:186
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:1067
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:530
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
No ref-qualifier was provided.
Definition: Type.h:1304
void setEntity(DeclContext *E)
Definition: Scope.h:320
bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckForFunctionMarkedFinal - Checks whether a virtual member function overrides a virtual member fun...
llvm::SmallPtrSet< const CXXRecordDecl *, 8 > RecordDeclSetTy
Definition: Sema.h:569
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2190
bool isUsualDeallocationFunction() const
Determine whether this is a usual deallocation function (C++ [basic.stc.dynamic.deallocation]p2), which is an overloaded delete or delete[] operator with a particular signature.
Definition: DeclCXX.cpp:1791
std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths)
Builds a string representing ambiguous paths from a specific derived class to different subobjects of...
void setImplicitMoveConstructorIsDeleted()
Set that we attempted to declare an implicit move constructor, but overload resolution failed so we d...
Definition: DeclCXX.h:1023
SourceLocation getLocation() const
Definition: Attr.h:91
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3708
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition: Lookup.h:54
Expr * getNoexceptExpr() const
Definition: Type.h:3575
static CXXBaseSpecifier * findDirectBaseWithType(CXXRecordDecl *Derived, QualType DesiredBase, bool &AnyDependentBases)
Find the base specifier for a base class with the given type.
CanQualType VoidTy
Definition: ASTContext.h:996
void actOnDelayedExceptionSpecification(Decl *Method, ExceptionSpecificationType EST, SourceRange SpecificationRange, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr)
Add an exception-specification to the given member function (or member function template).
bool isGenericLambda() const
Determine whether this class describes a generic lambda function object (i.e.
Definition: DeclCXX.cpp:1116
Decl * ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc, unsigned TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, AttributeList *Attr, MultiTemplateParamsArg TempParamLists)
Handle a friend tag declaration where the scope specifier was templated.
Describes the kind of initialization being performed, along with location information for tokens rela...
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:149
static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident)
AbstractDiagSelID
Definition: Sema.h:5996
arg_range arguments()
Definition: Expr.h:2303
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
Definition: SemaType.cpp:1660
bool isObjCObjectPointerType() const
Definition: Type.h:6039
A class for iterating through a result set and possibly filtering out results.
Definition: Lookup.h:620
Direct list-initialization.
Definition: Specifiers.h:229
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2468
static CXXDefaultInitExpr * Create(const ASTContext &C, SourceLocation Loc, FieldDecl *Field)
Field is the non-static data member whose default initializer is used by this expression.
Definition: ExprCXX.h:1131
static ConstructorUsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, UsingDecl *Using, NamedDecl *Target, bool IsVirtual)
Definition: DeclCXX.cpp:2417
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2822
bool isFunctionProtoType() const
Definition: Type.h:1743
void CheckExplicitlyDefaultedMemberExceptionSpec(CXXMethodDecl *MD, const FunctionProtoType *T)
Check whether the exception specification provided for an explicitly-defaulted special member matches...
static bool checkSimpleDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType, llvm::function_ref< ExprResult(SourceLocation, Expr *, unsigned)> GetInit)
void setIsParsingBaseSpecifiers()
Definition: DeclCXX.h:755
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1628
static FriendTemplateDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc, MutableArrayRef< TemplateParameterList *> Params, FriendUnion Friend, SourceLocation FriendLoc)
CXXRecordDecl * getOrigin() const
Retrieve the type from which this base-paths search began.
static bool BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, CXXBaseSpecifier *BaseSpec, bool IsInheritedVirtualBase, CXXCtorInitializer *&CXXBaseInit)
No entity found met the criteria.
Definition: Lookup.h:36
static bool CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl)
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
Definition: Decl.cpp:2931
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:161
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:146
Decl * ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, AttributeList *AttrList)
bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Previous)
Checks that the given using declaration is not an invalid redeclaration.
bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const LangOptions &Lang)
Definition: DeclSpec.cpp:831
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
Definition: SemaType.cpp:1914
SourceLocation getRAngleLoc() const
Definition: DeclTemplate.h:174
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted per C++0x.
Definition: Decl.h:2017
SourceLocation getInlineSpecLoc() const
Definition: DeclSpec.h:562
NamedDecl * next()
Definition: Lookup.h:646
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:450
void setExplicitlyDefaulted(bool ED=true)
Definition: Decl.h:2018
void setHasInheritedDefaultArg(bool I=true)
Definition: Decl.h:1645
bool hasFlexibleArrayMember() const
Definition: Decl.h:3541
bool defaultedCopyConstructorIsDeleted() const
true if a defaulted copy constructor for this class would be deleted.
Definition: DeclCXX.h:862
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:261
static bool checkTupleLikeDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, VarDecl *Src, QualType DecompType, const llvm::APSInt &TupleSize)
static Sema::ImplicitExceptionSpecification computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, CXXMethodDecl *MD)
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2214
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:586
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Definition: Decl.cpp:80
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3524
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
Decl * ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc, SourceLocation NamespcLoc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *NamespcName, AttributeList *AttrList)
TypeLoc getElementLoc() const
Definition: TypeLoc.h:1562
bool hasInClassInitializer() const
Whether this class has any in-class initializers for non-static data members (including those in anon...
Definition: DeclCXX.h:1241
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
getSpecialMember - get the special member enum for a method.
Definition: SemaDecl.cpp:2804
SourceLocation getLastLocation() const
Definition: DeclSpec.h:2498
CXXDestructorDecl * DeclareImplicitDestructor(CXXRecordDecl *ClassDecl)
Declare the implicit destructor for the given class.
Expr * getLHS() const
Definition: Expr.h:3029
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:4379
CXXConstructorDecl * getConstructor() const
Definition: DeclCXX.h:2384
StringRef getName() const
Return the actual identifier string.
MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, CXXRecordDecl *ClassDecl)
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1876
static AttributeList * getMSPropertyAttr(AttributeList *list)
static void checkForMultipleExportedDefaultConstructors(Sema &S, CXXRecordDecl *Class)
Decl * ActOnExceptionDeclarator(Scope *S, Declarator &D)
ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch handler.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current target.
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2802
ast_type_traits::DynTypedNode Node
CanQualType CharTy
Definition: ASTContext.h:998
TLS with a dynamic initializer.
Definition: Decl.h:829
Represents a template argument.
Definition: TemplateBase.h:51
void setBody(Stmt *B)
Definition: Decl.cpp:2626
TagTypeKind
The kind of a tag type.
Definition: Type.h:4686
static bool isInvalid(LocType Loc, bool *Invalid)
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2459
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2455
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LanguageIDs Lang, bool HasBraces)
Definition: DeclCXX.cpp:2250
Dataflow Directional Tag Classes.
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.h:516
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Definition: Decl.h:2936
bool isExplicit() const
Whether this function is explicit.
Definition: DeclCXX.h:2511
bool isValid() const
Return true if this is a valid SourceLocation object.
void setImplicitlyInline()
Flag that this function is implicitly inline.
Definition: Decl.h:2250
CXXConstructorDecl * DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit copy constructor for the given class.
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:493
not evaluated yet, for special member function
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1256
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
static const TST TST_auto
Definition: DeclSpec.h:300
method_iterator begin_overridden_methods() const
Definition: DeclCXX.cpp:1910
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:224
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type &#39;Type&#39;, insert an implicit cast.
Definition: Sema.cpp:466
static void AddMostOverridenMethods(const CXXMethodDecl *MD, llvm::SmallPtrSetImpl< const CXXMethodDecl *> &Methods)
Add the most overriden methods from MD to Methods.
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:130
StmtResult ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, ConditionResult Second, FullExprArg Third, SourceLocation RParenLoc, Stmt *Body)
Definition: SemaStmt.cpp:1729
SourceLocation getLocStart() const LLVM_READONLY
Definition: TypeLoc.h:154
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with &#39;,...)&#39;, this is true.
Definition: DeclSpec.h:1236
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3430
bool isImplicit() const
Definition: ExprCXX.h:967
SourceRange getSourceRange(const SourceRange &Range)
Returns the SourceRange of a SourceRange.
Definition: FixIt.h:34
bool isRecord() const
Definition: DeclBase.h:1409
attr_range attrs() const
Definition: DeclBase.h:494
SourceLocation RAngleLoc
The location of the &#39;>&#39; after the template argument list.
static bool InitializationHasSideEffects(const FieldDecl &FD)
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
Definition: Decl.h:2711
void ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc, Expr *defarg)
ActOnParamDefaultArgument - Check whether the default argument provided for a function parameter is w...
bool isCopyConstructor(unsigned &TypeQuals) const
Whether this constructor is a copy constructor (C++ [class.copy]p2, which can be used to copy the cla...
Definition: DeclCXX.cpp:2096
SourceLocation getSourceLocation() const
Determine the source location of the initializer.
Definition: DeclCXX.cpp:2019
QualType getUnderlyingType() const
Definition: Decl.h:2853
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1006
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:116
AccessSpecifier getAccess() const
Definition: DeclBase.h:460
const Expr * getInit() const
Definition: Decl.h:1212
A decomposition declaration.
Definition: DeclCXX.h:3766
MapType::iterator iterator
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
Definition: DeclBase.cpp:1679
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:157
static NamespaceDecl * getNamespaceDecl(NamedDecl *D)
getNamespaceDecl - Returns the namespace a decl represents.
bool hasUserDeclaredConstructor() const
Determine whether this class has any user-declared constructors.
Definition: DeclCXX.h:936
unsigned getIndex() const
Retrieve the index of the template parameter.
void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD)
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3590
FunctionDecl * getTemplateInstantiationPattern() const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition: Decl.cpp:3286
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Definition: DeclCXX.cpp:2267
void setWillHaveBody(bool V=true)
Definition: Decl.h:2155
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
DeclarationName - The name of a declaration.
StmtClass getStmtClass() const
Definition: Stmt.h:378
ArrayRef< QualType > exceptions() const
Definition: Type.h:3651
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Lookup.h:520
Expr * getDefaultArg()
Definition: Decl.cpp:2493
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Definition: Decl.h:337
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2085
bool isMoveConstructor(unsigned &TypeQuals) const
Determine whether this constructor is a move constructor (C++11 [class.copy]p3), which can be used to...
Definition: DeclCXX.cpp:2101
llvm::SmallPtrSet< SpecialMemberDecl, 4 > SpecialMembersBeingDeclared
The C++ special members which we are currently in the process of declaring.
Definition: Sema.h:1145
const Type * getBaseClass() const
If this is a base class initializer, returns the type of the base class.
Definition: DeclCXX.cpp:2012
std::pair< CXXRecordDecl *, SourceLocation > VTableUse
The list of classes whose vtables have been used within this translation unit, and the source locatio...
Definition: Sema.h:5737
A mapping from each virtual member function to its set of final overriders.
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:731
unsigned getNumTemplateParameterLists() const
Definition: Decl.h:752
EnumDecl - Represents an enum.
Definition: Decl.h:3239
bool isAmbiguous(CanQualType BaseType)
Determine whether the path from the most-derived type to the given base type is ambiguous (i...
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2502
bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl)
CheckOverloadedOperatorDeclaration - Check whether the declaration of this overloaded operator is wel...
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:143
semantics_iterator semantics_begin()
Definition: Expr.h:5037
bool isDestroyingOperatorDelete() const
Determine whether this is a destroying operator delete.
Definition: Decl.cpp:2769
Expr * get() const
Definition: Sema.h:3632
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration...
Definition: DeclCXX.h:2063
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:574
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
MemInitResult BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo, Expr *Init, CXXRecordDecl *ClassDecl, SourceLocation EllipsisLoc)
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1048
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:1600
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 &#39;auto&#39; typ...
Definition: Type.h:6238
static unsigned NumImplicitCopyAssignmentOperators
The number of implicitly-declared copy assignment operators.
Definition: ASTContext.h:2701
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:196
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2552
void PushUsingDirective(UsingDirectiveDecl *UDir)
Definition: Scope.h:453
CXXConstructorDecl * DeclareImplicitDefaultConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit default constructor for the given class.
std::pair< CXXConstructorDecl *, bool > findConstructorForBase(CXXRecordDecl *Base, CXXConstructorDecl *Ctor) const
Find the constructor to use for inherited construction of a base class, and whether that base class c...
unsigned getNumParams() const
Definition: TypeLoc.h:1471
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2084
SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D, CXXSpecialMember SM, bool ConstArg, bool VolatileArg, bool RValueThis, bool ConstThis, bool VolatileThis)
const FunctionDecl * getOperatorDelete() const
Definition: DeclCXX.h:2652
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:150
static FunctionProtoType::ExtProtoInfo getImplicitMethodEPI(Sema &S, CXXMethodDecl *MD)
UsingDecl * getUsingDecl() const
Gets the using declaration to which this declaration is tied.
Definition: DeclCXX.cpp:2406
void RemoveDecl(Decl *D)
Definition: Scope.h:285
Name lookup found a single declaration that met the criteria.
Definition: Lookup.h:45
bool needsOverloadResolutionForMoveConstructor() const
Determine whether we need to eagerly declare a defaulted move constructor for this class...
Definition: DeclCXX.h:1051
bool isCurrentClassName(const IdentifierInfo &II, Scope *S, const CXXScopeSpec *SS=nullptr)
isCurrentClassName - Determine whether the identifier II is the name of the class type currently bein...
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2571
static AccessSpecifier MergeAccess(AccessSpecifier PathAccess, AccessSpecifier DeclAccess)
Calculates the access of a decl that is reached along a path.
Definition: DeclCXX.h:1789
bool isIncompleteArrayType() const
Definition: Type.h:5999
Decl * ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc, SourceLocation NamespaceLoc, SourceLocation IdentLoc, IdentifierInfo *Ident, SourceLocation LBrace, AttributeList *AttrList, UsingDirectiveDecl *&UsingDecl)
ActOnStartNamespaceDef - This is called at the start of a namespace definition.
bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths, bool LookupInDependent=false) const
Look for entities within the base classes of this C++ class, transitively searching all base class su...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3976
Complex values, per C99 6.2.5p11.
Definition: Type.h:2223
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
static bool CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl)
MapType::const_iterator const_iterator
void setUnparsedDefaultArg()
setUnparsedDefaultArg - Specify that this parameter has an unparsed default argument.
Definition: Decl.h:1637
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:2535
bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl)
CheckLiteralOperatorDeclaration - Check whether the declaration of this literal operator function is ...
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:539
static void extendRight(SourceRange &R, SourceRange After)
QualType getCanonicalTypeInternal() const
Definition: Type.h:2107
SourceLocation getVirtualSpecLoc() const
Definition: DeclSpec.h:567
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2172
LanguageIDs
Represents the language in a linkage specification.
Definition: DeclCXX.h:2753
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6191
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:153
SourceRange getSourceRange() const LLVM_READONLY
getSourceRange - The range of the declaration name.
bool needsOverloadResolutionForMoveAssignment() const
Determine whether we need to eagerly declare a move assignment operator for this class.
Definition: DeclCXX.h:1128
bool hasNonTrivialObjCLifetime() const
Definition: Type.h:1074
IndirectFieldDecl * getIndirectMember() const
Definition: DeclCXX.h:2319
T * getAttr() const
Definition: DeclBase.h:531
type_object_range type_objects() const
Returns the range of type objects, from the identifier outwards.
Definition: DeclSpec.h:2161
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
const llvm::APInt & getSize() const
Definition: Type.h:2636
CanQualType DependentTy
Definition: ASTContext.h:1013
bool isFunctionType() const
Definition: Type.h:5938
TrivialSubobjectKind
The kind of subobject we are checking for triviality.
bool isStaticLocal() const
isStaticLocal - Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1049
NamedDecl * ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, Expr *BitfieldWidth, const VirtSpecifiers &VS, InClassInitStyle InitStyle)
ActOnCXXMemberDeclarator - This is invoked when a C++ class member declarator is parsed.
static const void * GetKeyForBase(ASTContext &Context, QualType BaseType)
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:707
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
CXXBasePath & front()
Opcode getOpcode() const
Definition: Expr.h:1741
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1365
bool isImplicitlyDeleted(FunctionDecl *FD)
Determine whether the given function is an implicitly-deleted special member function.
The noexcept specifier evaluates to false.
Definition: Type.h:3562
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2419
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1663
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2190
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:252
decl_range decls()
Definition: Stmt.h:534
static UsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, UsingDecl *Using, NamedDecl *Target)
Definition: DeclCXX.h:3101
TypeLocClass getTypeLocClass() const
Definition: TypeLoc.h:113
ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, FieldDecl *Field, DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo)
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr)
Definition: SemaExpr.cpp:12164
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInline, bool isConstexpr, SourceLocation EndLocation)
Definition: DeclCXX.cpp:1696
The template argument is a type.
Definition: TemplateBase.h:60
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
ActionResult< ParsedType > TypeResult
Definition: Ownership.h:253
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:90
const LinkageSpecDecl * getExternCContext() const
Retrieve the nearest enclosing C linkage specification context.
Definition: DeclBase.cpp:1096
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1425
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:265
The "class" keyword.
Definition: Type.h:4697
Represents a base class of a C++ class.
Definition: DeclCXX.h:191
bool hasTypename() const
Return true if the using declaration has &#39;typename&#39;.
Definition: DeclCXX.h:3330
bool isInitListConstructor(const FunctionDecl *Ctor)
Determine whether Ctor is an initializer-list constructor, as defined in [dcl.init.list]p2.
void checkClassLevelDLLAttribute(CXXRecordDecl *Class)
Check class-level dllimport/dllexport attribute.
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
Definition: DeclBase.cpp:414
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2007
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3368
This is a scope that can contain a declaration.
Definition: Scope.h:58
bool isObjCObjectType() const
Definition: Type.h:6043
static BindingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id)
Definition: DeclCXX.cpp:2575
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2257
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:2112
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2174
static const void * GetKeyForMember(ASTContext &Context, CXXCtorInitializer *Member)
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1113
EnumDecl * getStdAlignValT() const
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
bool isLValueReferenceType() const
Definition: Type.h:5958
bool needsImplicitCopyConstructor() const
Determine whether this class needs an implicit copy constructor to be lazily declared.
Definition: DeclCXX.h:955
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:239
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1378
void setInvalidType(bool Val=true)
Definition: DeclSpec.h:2411
Expr * NoexceptExpr
Noexcept expression, if this is EST_ComputedNoexcept.
Definition: Type.h:3371
void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc)
ActOnParamDefaultArgumentError - Parsing or semantic analysis of the default argument for the paramet...
void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a block pointer.
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:235
unsigned getDepth() const
Definition: Type.h:4218
static void BuildBasePathArray(const CXXBasePath &Path, CXXCastPath &BasePathArray)
QualType getParamType(unsigned i) const
Definition: Type.h:3491
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups, surround it with a ExprWithCleanups node.
ExprResult BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
Definition: SemaExpr.cpp:1637
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:989
void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc, CXXRecordDecl *Record)
MarkBaseAndMemberDestructorsReferenced - Given a record decl, mark all the non-trivial destructors of...
void Deallocate(void *Ptr) const
Definition: ASTContext.h:656
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2387
static bool functionDeclHasDefaultArgument(const FunctionDecl *FD)
void CheckOverrideControl(NamedDecl *D)
CheckOverrideControl - Check C++11 override control semantics.
CallingConv getCallConv() const
Definition: Type.h:3211
ThreadStorageClassSpecifier
Thread storage-class-specifier.
Definition: Specifiers.h:190
void setImplicitMoveAssignmentIsDeleted()
Set that we attempted to declare an implicit move assignment operator, but overload resolution failed...
Definition: DeclCXX.h:1104
Describes the sequence of initializations required to initialize a given object or reference with a s...
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5798
SourceLocation getRestrictSpecLoc() const
Definition: DeclSpec.h:541
static bool CheckConstexprParameterTypes(Sema &SemaRef, const FunctionDecl *FD)
void setDefaultArg(Expr *defarg)
Definition: Decl.cpp:2505
bool isMutable() const
isMutable - Determines whether this field is mutable (C++ only).
Definition: Decl.h:2542
void setEnd(SourceLocation e)
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn&#39;t on...
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
static bool isCompoundAssignmentOp(Opcode Opc)
Definition: Expr.h:3113
void setIvarInitializers(ASTContext &C, CXXCtorInitializer **initializers, unsigned numInitializers)
Definition: DeclObjC.cpp:2137
bool isValid() const
bool hasUserDeclaredMoveConstructor() const
Determine whether this class has had a move constructor declared by the user.
Definition: DeclCXX.h:1002
bool CompleteConstructorCall(CXXConstructorDecl *Constructor, MultiExprArg ArgsPtr, SourceLocation Loc, SmallVectorImpl< Expr *> &ConvertedArgs, bool AllowExplicit=false, bool IsListInitialization=false)
Given a constructor and the set of arguments provided for the constructor, convert the arguments and ...
void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc)
bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, ArrayRef< CXXCtorInitializer *> Initializers=None)
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
bool isVoidType() const
Definition: Type.h:6169
bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier *> Bases)
Performs the actual work of attaching the given base class specifiers to a C++ class.
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:3342
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:29
void CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD)
void setConstexpr(bool IC)
Definition: Decl.h:2043
void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5745
void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc, SourceLocation ArgLoc)
ActOnParamUnparsedDefaultArgument - We&#39;ve seen a default argument for a function parameter, but we can&#39;t parse it yet because we&#39;re inside a class definition.
The parameter type of a method or function.
static IsTupleLike isTupleLike(Sema &S, SourceLocation Loc, QualType T, llvm::APSInt &Size)
void setParam(unsigned i, ParmVarDecl *VD)
Definition: TypeLoc.h:1478
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:191
CanQualType Char16Ty
Definition: ASTContext.h:1002
bool isInherited() const
Definition: Attr.h:95
static bool hasOneRealArgument(MultiExprArg Args)
Determine whether the given list arguments contains exactly one "real" (non-default) argument...
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1841
static unsigned NumImplicitCopyConstructorsDeclared
The number of implicitly-declared copy constructors for which declarations were built.
Definition: ASTContext.h:2691
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:328
void setUnsupportedFriend(bool Unsupported)
Definition: DeclFriend.h:178
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
Definition: DeclCXX.cpp:2466
Declaration of a class template.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
bool isVirtualSpecified() const
Definition: DeclSpec.h:566
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:127
NamedDecl * getAcceptableDecl(NamedDecl *D) const
Retrieve the accepted (re)declaration of the given declaration, if there is one.
Definition: Lookup.h:364
SourceManager & getSourceManager() const
Definition: Sema.h:1198
SourceRange getDefaultArgRange() const
Retrieve the source range that covers the entire default argument.
Definition: Decl.cpp:2510
iterator end() const
Definition: Lookup.h:339
A template-id, e.g., f<int>.
bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionReturnType - Checks whether the return types are covariant, according to C++ [class.virtual]p5.
static bool checkTrivialSubobjectCall(Sema &S, SourceLocation SubobjLoc, QualType SubType, bool ConstRHS, Sema::CXXSpecialMember CSM, TrivialSubobjectKind Kind, bool Diagnose)
Check whether the special member selected for a given type would be trivial.
bool hasInheritedAssignment() const
Determine whether this class has a using-declaration that names a base class assignment operator...
Definition: DeclCXX.h:1457
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:265
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1227
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1509
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2209
AccessSpecifier Access
The access along this inheritance path.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
bool isInlineSpecified() const
Definition: DeclSpec.h:559
static bool defaultedSpecialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, Sema::CXXSpecialMember CSM, bool ConstArg, CXXConstructorDecl *InheritedCtor=nullptr, Sema::InheritedConstructorInfo *Inherited=nullptr)
Determine whether the specified special member function would be constexpr if it were implicitly defi...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3509
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body - that is, if it is a non-delete...
Definition: Decl.h:1980
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:270
SourceLocation getAtomicSpecLoc() const
Definition: DeclSpec.h:543
ExprResult ExprError()
Definition: Ownership.h:267
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated, or computed.
FriendDecl * CheckFriendTypeDecl(SourceLocation LocStart, SourceLocation FriendLoc, TypeSourceInfo *TSInfo)
Perform semantic analysis of the given friend type declaration.
capture_iterator capture_begin() const
Retrieve an iterator pointing to the first lambda capture.
Definition: ExprCXX.cpp:961
static void CheckAbstractClassUsage(AbstractUsageInfo &Info, CXXMethodDecl *MD)
Check for invalid uses of an abstract type in a method declaration.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name.
Definition: DeclCXX.h:3318
NameKind getKind() const
CanQualType IntTy
Definition: ASTContext.h:1004
unsigned getNumElements() const
Definition: Type.h:2950
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:230
TranslationUnitDecl - The top declaration context.
Definition: Decl.h:107
SourceLocation getExplicitSpecLoc() const
Definition: DeclSpec.h:570
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1858
SourceLocation getConstexprSpecLoc() const
Definition: DeclSpec.h:704
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:257
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:956
void CheckConversionDeclarator(Declarator &D, QualType &R, StorageClass &SC)
CheckConversionDeclarator - Called by ActOnDeclarator to check the well-formednes of the conversion f...
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
Definition: Scope.h:229
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
Definition: DeclSpec.h:1424
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:734
bool isUnion() const
Definition: Decl.h:3165
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4493
NamedDecl * getMostRecentDecl()
Definition: Decl.h:436
Expr * getRHS() const
Definition: Expr.h:3031
void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD)
Diagnose methods which overload virtual methods in a base class without overriding any...
CXXMethodDecl * DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl)
Declare the implicit copy assignment operator for the given class.
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2077
bool isPointerType() const
Definition: Type.h:5942
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:3188
bool implicitCopyConstructorHasConstParam() const
Determine whether an implicit copy constructor for this type would have a parameter with a const-qual...
Definition: DeclCXX.h:976
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
Definition: ASTConsumer.cpp:19
void setBaseObjectType(QualType T)
Sets the base object type for this lookup.
Definition: Lookup.h:423
static bool findTrivialSpecialMember(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM, unsigned Quals, bool ConstRHS, CXXMethodDecl **Selected)
Perform lookup for a special member of the specified kind, and determine whether it is trivial...
void setCanPassInRegisters(bool CanPass)
Set that we can pass this RecordDecl in registers.
Definition: DeclCXX.h:1439
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:64
bool needsImplicitMoveConstructor() const
Determine whether this class should get an implicit move constructor or if any existing special membe...
Definition: DeclCXX.h:1041
ArrayRef< Binding > bindings() const
Definition: DeclSpec.h:1690
bool CheckDestructor(CXXDestructorDecl *Destructor)
CheckDestructor - Checks a fully-formed destructor definition for well-formedness, issuing any diagnostics required.
DeclaratorContext getContext() const
Definition: DeclSpec.h:1866
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:586
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace nested inside this namespace, if any.
Definition: Decl.h:588
bool hasDirectFields() const
Determine whether this class has direct non-static data members.
Definition: DeclCXX.h:1282
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:3835
QualType getType() const
Definition: Decl.h:638
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:111
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:342
NoexceptResult getNoexceptSpec(const ASTContext &Ctx) const
Get the meaning of the noexcept spec on this function, if any.
Definition: Type.cpp:2837
A trivial tuple used to represent a source range.
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:301
ASTContext & Context
Definition: Sema.h:316
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, std::unique_ptr< CorrectionCandidateCallback > CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2845
paths_iterator end()
NamedDecl - This represents a decl with a name.
Definition: Decl.h:245
virtual void diagnose(Sema &S, SourceLocation Loc, QualType T)=0
void dropAttr()
Definition: DeclBase.h:506
bool isTranslationUnit() const
Definition: DeclBase.h:1405
Expr * getRepAsExpr() const
Definition: DeclSpec.h:493
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:75
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:455
CanQualType BoolTy
Definition: ASTContext.h:997
Represents a C++ namespace alias.
Definition: DeclCXX.h:2947
No keyword precedes the qualified type name.
Definition: Type.h:4726
SourceRange getSourceRange() const LLVM_READONLY
Retrieves the source range that contains the entire base specifier.
Definition: DeclCXX.h:234
FullExprArg MakeFullDiscardedValueExpr(Expr *Arg)
Definition: Sema.h:3654
iterator begin() const
Definition: Lookup.h:338
Represents C++ using-directive.
Definition: DeclCXX.h:2843
void DiagnoseAbstractType(const CXXRecordDecl *RD)
static Expr * CastForMoving(Sema &SemaRef, Expr *E, QualType T=QualType())
bool isAggregate() const
Determine whether this class is an aggregate (C++ [dcl.init.aggr]), which is a class with no user-dec...
Definition: DeclCXX.h:1236
Describes an entity that is being initialized.
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
attr::Kind getKind() const
Definition: Attr.h:84
MemInitResult ActOnMemInitializer(Decl *ConstructorD, Scope *S, CXXScopeSpec &SS, IdentifierInfo *MemberOrBase, ParsedType TemplateTypeTy, const DeclSpec &DS, SourceLocation IdLoc, SourceLocation LParenLoc, ArrayRef< Expr *> Args, SourceLocation RParenLoc, SourceLocation EllipsisLoc)
Handle a C++ member initializer using parentheses syntax.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Lookup.h:527
The global specifier &#39;::&#39;. There is no stored value.
NestedNameSpecifier * getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
The noexcept specifier is dependent.
Definition: Type.h:3559
NamedDecl * ActOnDecompositionDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists)
The object is actually the complete object.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:2910
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.cpp:277
void setType(QualType newType)
Definition: Decl.h:639
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isExplicit, bool isInline, bool isImplicitlyDeclared, bool isConstexpr, InheritedConstructor Inherited=InheritedConstructor())
Definition: DeclCXX.cpp:2057
ctor_range ctors() const
Definition: DeclCXX.h:835
Wrapper for source info for pointers.
Definition: TypeLoc.h:1271
SourceLocation getBegin() const
ParsedAttributes - A collection of parsed attributes.
SourceLocation ColonLoc
Location of &#39;:&#39;.
Definition: OpenMPClause.h:97
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclTemplate.h:176
const LangOptions & getLangOpts() const
Definition: ASTContext.h:688
void WillReplaceSpecifier(bool ForceReplacement)
bool isParameterPack() const
Determine whether this parameter is actually a function parameter pack.
Definition: Decl.cpp:2549
Wrapper for source info for block pointers.
Definition: TypeLoc.h:1284
void setDeletedAsWritten(bool D=true)
Definition: Decl.h:2079
void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl)
AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared special functions, such as the default constructor, copy constructor, or destructor, to the given C++ class (C++ [special]p1).
An implicit &#39;self&#39; parameter.
void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation)
SetIvarInitializers - This routine builds initialization ASTs for the Objective-C implementation whos...
No in-class initializer.
Definition: Specifiers.h:227
base_class_range vbases()
Definition: DeclCXX.h:790
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2618
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3393
static InitializedEntity InitializeBinding(VarDecl *Binding)
Create the initialization entity for a structured binding.
A deduction-guide name (a template-name)
Declaration of a template function.
Definition: DeclTemplate.h:967
void clear()
Clears out any current state.
Definition: Lookup.h:557
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:4580
MSPropertyDecl * HandleMSProperty(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS, AttributeList *MSPropertyAttr)
HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
bool SetDelegatingInitializer(CXXConstructorDecl *Constructor, CXXCtorInitializer *Initializer)
void DiagnoseAbsenceOfOverrideControl(NamedDecl *D)
DiagnoseAbsenceOfOverrideControl - Diagnose if &#39;override&#39; keyword was not used in the declaration of ...
ParamInfo * Params
Params - This is a pointer to a new[]&#39;d array of ParamInfo objects that describe the parameters speci...
Definition: DeclSpec.h:1310
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2005
Comparison
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:554
static bool checkLiteralOperatorTemplateParameterList(Sema &SemaRef, FunctionTemplateDecl *TpDecl)
Attr - This represents one attribute.
Definition: Attr.h:43
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:738
SourceLocation getLocation() const
Definition: DeclBase.h:416
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3066
bool isExternallyVisible() const
Definition: Decl.h:370
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
A single template declaration.
Definition: TemplateName.h:191
bool isBeingDefined() const
isBeingDefined - Return true if this decl is currently being defined.
Definition: Decl.h:3108
ConstructorUsingShadowDecl * getShadowDecl() const
Definition: DeclCXX.h:2383
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1223
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2434
AttributeList - Represents a syntactic attribute.
Definition: AttributeList.h:95
Decl * ActOnConversionDeclarator(CXXConversionDecl *Conversion)
ActOnConversionDeclarator - Called by ActOnDeclarator to complete the declaration of the given C++ co...
decl_iterator decls_end() const
Definition: DeclBase.h:1582
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1070
static unsigned NumImplicitDestructors
The number of implicitly-declared destructors.
Definition: ASTContext.h:2715
static bool isVisible(Sema &SemaRef, NamedDecl *D)
Determine whether the given declaration is visible to the program.
Definition: Lookup.h:352
NamedDecl * ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams)
bool isTransparentContext() const
isTransparentContext - Determines whether this context is a "transparent" context, meaning that the members declared in this context are semantically declared in the nearest enclosing non-transparent (opaque) context but are lexically declared in this context.
Definition: DeclBase.cpp:1073
param_type_iterator param_type_end() const
Definition: Type.h:3645
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...
unsigned ActOnReenterTemplateScope(Scope *S, Decl *Template)
static void DiagnoseNamespaceInlineMismatch(Sema &S, SourceLocation KeywordLoc, SourceLocation Loc, IdentifierInfo *II, bool *IsInline, NamespaceDecl *PrevNS)
Diagnose a mismatch in &#39;inline&#39; qualifiers when a namespace is reopened.
A RAII object to temporarily push a declaration context.
Definition: Sema.h:705
method_range methods() const
Definition: DeclCXX.h:815
The subobject is a non-static data member.
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:290
bool defaultedDestructorIsDeleted() const
true if a defaulted destructor for this class would be deleted.
Definition: DeclCXX.h:879