clang  8.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"
22 #include "clang/AST/ExprCXX.h"
23 #include "clang/AST/RecordLayout.h"
25 #include "clang/AST/StmtVisitor.h"
26 #include "clang/AST/TypeLoc.h"
27 #include "clang/AST/TypeOrdering.h"
29 #include "clang/Basic/TargetInfo.h"
31 #include "clang/Lex/Preprocessor.h"
33 #include "clang/Sema/DeclSpec.h"
35 #include "clang/Sema/Lookup.h"
37 #include "clang/Sema/Scope.h"
38 #include "clang/Sema/ScopeInfo.h"
40 #include "clang/Sema/Template.h"
41 #include "llvm/ADT/STLExtras.h"
42 #include "llvm/ADT/SmallString.h"
43 #include "llvm/ADT/StringExtras.h"
44 #include <map>
45 #include <set>
46 
47 using namespace clang;
48 
49 //===----------------------------------------------------------------------===//
50 // CheckDefaultArgumentVisitor
51 //===----------------------------------------------------------------------===//
52 
53 namespace {
54  /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
55  /// the default argument of a parameter to determine whether it
56  /// contains any ill-formed subexpressions. For example, this will
57  /// diagnose the use of local variables or parameters within the
58  /// default argument expression.
59  class CheckDefaultArgumentVisitor
60  : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
61  Expr *DefaultArg;
62  Sema *S;
63 
64  public:
65  CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
66  : DefaultArg(defarg), S(s) {}
67 
68  bool VisitExpr(Expr *Node);
69  bool VisitDeclRefExpr(DeclRefExpr *DRE);
70  bool VisitCXXThisExpr(CXXThisExpr *ThisE);
71  bool VisitLambdaExpr(LambdaExpr *Lambda);
72  bool VisitPseudoObjectExpr(PseudoObjectExpr *POE);
73  };
74 
75  /// VisitExpr - Visit all of the children of this expression.
76  bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
77  bool IsInvalid = false;
78  for (Stmt *SubStmt : Node->children())
79  IsInvalid |= Visit(SubStmt);
80  return IsInvalid;
81  }
82 
83  /// VisitDeclRefExpr - Visit a reference to a declaration, to
84  /// determine whether this declaration can be used in the default
85  /// argument expression.
86  bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
87  NamedDecl *Decl = DRE->getDecl();
88  if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
89  // C++ [dcl.fct.default]p9
90  // Default arguments are evaluated each time the function is
91  // called. The order of evaluation of function arguments is
92  // unspecified. Consequently, parameters of a function shall not
93  // be used in default argument expressions, even if they are not
94  // evaluated. Parameters of a function declared before a default
95  // argument expression are in scope and can hide namespace and
96  // class member names.
97  return S->Diag(DRE->getBeginLoc(),
98  diag::err_param_default_argument_references_param)
99  << Param->getDeclName() << DefaultArg->getSourceRange();
100  } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
101  // C++ [dcl.fct.default]p7
102  // Local variables shall not be used in default argument
103  // expressions.
104  if (VDecl->isLocalVarDecl())
105  return S->Diag(DRE->getBeginLoc(),
106  diag::err_param_default_argument_references_local)
107  << VDecl->getDeclName() << DefaultArg->getSourceRange();
108  }
109 
110  return false;
111  }
112 
113  /// VisitCXXThisExpr - Visit a C++ "this" expression.
114  bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
115  // C++ [dcl.fct.default]p8:
116  // The keyword this shall not be used in a default argument of a
117  // member function.
118  return S->Diag(ThisE->getBeginLoc(),
119  diag::err_param_default_argument_references_this)
120  << ThisE->getSourceRange();
121  }
122 
123  bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(PseudoObjectExpr *POE) {
124  bool Invalid = false;
126  i = POE->semantics_begin(), e = POE->semantics_end(); i != e; ++i) {
127  Expr *E = *i;
128 
129  // Look through bindings.
130  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
131  E = OVE->getSourceExpr();
132  assert(E && "pseudo-object binding without source expression?");
133  }
134 
135  Invalid |= Visit(E);
136  }
137  return Invalid;
138  }
139 
140  bool CheckDefaultArgumentVisitor::VisitLambdaExpr(LambdaExpr *Lambda) {
141  // C++11 [expr.lambda.prim]p13:
142  // A lambda-expression appearing in a default argument shall not
143  // implicitly or explicitly capture any entity.
144  if (Lambda->capture_begin() == Lambda->capture_end())
145  return false;
146 
147  return S->Diag(Lambda->getBeginLoc(), 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  case EST_Unparsed:
175  case EST_Uninstantiated:
176  case EST_Unevaluated:
177  llvm_unreachable("should not see unresolved exception specs here");
178 
179  // If this function can throw any exceptions, make a note of that.
180  case EST_MSAny:
181  case EST_None:
182  // FIXME: Whichever we see last of MSAny and None determines our result.
183  // We should make a consistent, order-independent choice here.
184  ClearExceptions();
185  ComputedEST = EST;
186  return;
187  case EST_NoexceptFalse:
188  ClearExceptions();
189  ComputedEST = EST_None;
190  return;
191  // FIXME: If the call to this decl is using any of its default arguments, we
192  // need to search them for potentially-throwing calls.
193  // If this function has a basic noexcept, it doesn't affect the outcome.
194  case EST_BasicNoexcept:
195  case EST_NoexceptTrue:
196  return;
197  // If we're still at noexcept(true) and there's a throw() callee,
198  // change to that specification.
199  case EST_DynamicNone:
200  if (ComputedEST == EST_BasicNoexcept)
201  ComputedEST = EST_DynamicNone;
202  return;
204  llvm_unreachable(
205  "should not generate implicit declarations for dependent cases");
206  case EST_Dynamic:
207  break;
208  }
209  assert(EST == EST_Dynamic && "EST case not considered earlier.");
210  assert(ComputedEST != EST_None &&
211  "Shouldn't collect exceptions when throw-all is guaranteed.");
212  ComputedEST = EST_Dynamic;
213  // Record the exceptions in this function's exception specification.
214  for (const auto &E : Proto->exceptions())
215  if (ExceptionsSeen.insert(Self->Context.getCanonicalType(E)).second)
216  Exceptions.push_back(E);
217 }
218 
220  if (!E || ComputedEST == EST_MSAny)
221  return;
222 
223  // FIXME:
224  //
225  // C++0x [except.spec]p14:
226  // [An] implicit exception-specification specifies the type-id T if and
227  // only if T is allowed by the exception-specification of a function directly
228  // invoked by f's implicit definition; f shall allow all exceptions if any
229  // function it directly invokes allows all exceptions, and f shall allow no
230  // exceptions if every function it directly invokes allows no exceptions.
231  //
232  // Note in particular that if an implicit exception-specification is generated
233  // for a function containing a throw-expression, that specification can still
234  // be noexcept(true).
235  //
236  // Note also that 'directly invoked' is not defined in the standard, and there
237  // is no indication that we should only consider potentially-evaluated calls.
238  //
239  // Ultimately we should implement the intent of the standard: the exception
240  // specification should be the set of exceptions which can be thrown by the
241  // implicit definition. For now, we assume that any non-nothrow expression can
242  // throw any exception.
243 
244  if (Self->canThrow(E))
245  ComputedEST = EST_None;
246 }
247 
248 bool
250  SourceLocation EqualLoc) {
251  if (RequireCompleteType(Param->getLocation(), Param->getType(),
252  diag::err_typecheck_decl_incomplete_type)) {
253  Param->setInvalidDecl();
254  return true;
255  }
256 
257  // C++ [dcl.fct.default]p5
258  // A default argument expression is implicitly converted (clause
259  // 4) to the parameter type. The default argument expression has
260  // the same semantic constraints as the initializer expression in
261  // a declaration of a variable of the parameter type, using the
262  // copy-initialization semantics (8.5).
264  Param);
266  EqualLoc);
267  InitializationSequence InitSeq(*this, Entity, Kind, Arg);
268  ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg);
269  if (Result.isInvalid())
270  return true;
271  Arg = Result.getAs<Expr>();
272 
273  CheckCompletedExpr(Arg, EqualLoc);
274  Arg = MaybeCreateExprWithCleanups(Arg);
275 
276  // Okay: add the default argument to the parameter
277  Param->setDefaultArg(Arg);
278 
279  // We have already instantiated this parameter; provide each of the
280  // instantiations with the uninstantiated default argument.
281  UnparsedDefaultArgInstantiationsMap::iterator InstPos
282  = UnparsedDefaultArgInstantiations.find(Param);
283  if (InstPos != UnparsedDefaultArgInstantiations.end()) {
284  for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
285  InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
286 
287  // We're done tracking this parameter's instantiations.
288  UnparsedDefaultArgInstantiations.erase(InstPos);
289  }
290 
291  return false;
292 }
293 
294 /// ActOnParamDefaultArgument - Check whether the default argument
295 /// provided for a function parameter is well-formed. If so, attach it
296 /// to the parameter declaration.
297 void
299  Expr *DefaultArg) {
300  if (!param || !DefaultArg)
301  return;
302 
303  ParmVarDecl *Param = cast<ParmVarDecl>(param);
304  UnparsedDefaultArgLocs.erase(Param);
305 
306  // Default arguments are only permitted in C++
307  if (!getLangOpts().CPlusPlus) {
308  Diag(EqualLoc, diag::err_param_default_argument)
309  << DefaultArg->getSourceRange();
310  Param->setInvalidDecl();
311  return;
312  }
313 
314  // Check for unexpanded parameter packs.
315  if (DiagnoseUnexpandedParameterPack(DefaultArg, UPPC_DefaultArgument)) {
316  Param->setInvalidDecl();
317  return;
318  }
319 
320  // C++11 [dcl.fct.default]p3
321  // A default argument expression [...] shall not be specified for a
322  // parameter pack.
323  if (Param->isParameterPack()) {
324  Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
325  << DefaultArg->getSourceRange();
326  return;
327  }
328 
329  // Check that the default argument is well-formed
330  CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg, this);
331  if (DefaultArgChecker.Visit(DefaultArg)) {
332  Param->setInvalidDecl();
333  return;
334  }
335 
336  SetParamDefaultArgument(Param, DefaultArg, EqualLoc);
337 }
338 
339 /// ActOnParamUnparsedDefaultArgument - We've seen a default
340 /// argument for a function parameter, but we can't parse it yet
341 /// because we're inside a class definition. Note that this default
342 /// argument will be parsed later.
344  SourceLocation EqualLoc,
345  SourceLocation ArgLoc) {
346  if (!param)
347  return;
348 
349  ParmVarDecl *Param = cast<ParmVarDecl>(param);
350  Param->setUnparsedDefaultArg();
351  UnparsedDefaultArgLocs[Param] = ArgLoc;
352 }
353 
354 /// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
355 /// the default argument for the parameter param failed.
357  SourceLocation EqualLoc) {
358  if (!param)
359  return;
360 
361  ParmVarDecl *Param = cast<ParmVarDecl>(param);
362  Param->setInvalidDecl();
363  UnparsedDefaultArgLocs.erase(Param);
364  Param->setDefaultArg(new(Context)
365  OpaqueValueExpr(EqualLoc,
366  Param->getType().getNonReferenceType(),
367  VK_RValue));
368 }
369 
370 /// CheckExtraCXXDefaultArguments - Check for any extra default
371 /// arguments in the declarator, which is not a function declaration
372 /// or definition and therefore is not permitted to have default
373 /// arguments. This routine should be invoked for every declarator
374 /// that is not a function declaration or definition.
376  // C++ [dcl.fct.default]p3
377  // A default argument expression shall be specified only in the
378  // parameter-declaration-clause of a function declaration or in a
379  // template-parameter (14.1). It shall not be specified for a
380  // parameter pack. If it is specified in a
381  // parameter-declaration-clause, it shall not occur within a
382  // declarator or abstract-declarator of a parameter-declaration.
383  bool MightBeFunction = D.isFunctionDeclarationContext();
384  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
385  DeclaratorChunk &chunk = D.getTypeObject(i);
386  if (chunk.Kind == DeclaratorChunk::Function) {
387  if (MightBeFunction) {
388  // This is a function declaration. It can have default arguments, but
389  // keep looking in case its return type is a function type with default
390  // arguments.
391  MightBeFunction = false;
392  continue;
393  }
394  for (unsigned argIdx = 0, e = chunk.Fun.NumParams; argIdx != e;
395  ++argIdx) {
396  ParmVarDecl *Param = cast<ParmVarDecl>(chunk.Fun.Params[argIdx].Param);
397  if (Param->hasUnparsedDefaultArg()) {
398  std::unique_ptr<CachedTokens> Toks =
399  std::move(chunk.Fun.Params[argIdx].DefaultArgTokens);
400  SourceRange SR;
401  if (Toks->size() > 1)
402  SR = SourceRange((*Toks)[1].getLocation(),
403  Toks->back().getLocation());
404  else
405  SR = UnparsedDefaultArgLocs[Param];
406  Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
407  << SR;
408  } else if (Param->getDefaultArg()) {
409  Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
410  << Param->getDefaultArg()->getSourceRange();
411  Param->setDefaultArg(nullptr);
412  }
413  }
414  } else if (chunk.Kind != DeclaratorChunk::Paren) {
415  MightBeFunction = false;
416  }
417  }
418 }
419 
421  for (unsigned NumParams = FD->getNumParams(); NumParams > 0; --NumParams) {
422  const ParmVarDecl *PVD = FD->getParamDecl(NumParams-1);
423  if (!PVD->hasDefaultArg())
424  return false;
425  if (!PVD->hasInheritedDefaultArg())
426  return true;
427  }
428  return false;
429 }
430 
431 /// MergeCXXFunctionDecl - Merge two declarations of the same C++
432 /// function, once we already know that they have the same
433 /// type. Subroutine of MergeFunctionDecl. Returns true if there was an
434 /// error, false otherwise.
436  Scope *S) {
437  bool Invalid = false;
438 
439  // The declaration context corresponding to the scope is the semantic
440  // parent, unless this is a local function declaration, in which case
441  // it is that surrounding function.
442  DeclContext *ScopeDC = New->isLocalExternDecl()
443  ? New->getLexicalDeclContext()
444  : New->getDeclContext();
445 
446  // Find the previous declaration for the purpose of default arguments.
447  FunctionDecl *PrevForDefaultArgs = Old;
448  for (/**/; PrevForDefaultArgs;
449  // Don't bother looking back past the latest decl if this is a local
450  // extern declaration; nothing else could work.
451  PrevForDefaultArgs = New->isLocalExternDecl()
452  ? nullptr
453  : PrevForDefaultArgs->getPreviousDecl()) {
454  // Ignore hidden declarations.
455  if (!LookupResult::isVisible(*this, PrevForDefaultArgs))
456  continue;
457 
458  if (S && !isDeclInScope(PrevForDefaultArgs, ScopeDC, S) &&
459  !New->isCXXClassMember()) {
460  // Ignore default arguments of old decl if they are not in
461  // the same scope and this is not an out-of-line definition of
462  // a member function.
463  continue;
464  }
465 
466  if (PrevForDefaultArgs->isLocalExternDecl() != New->isLocalExternDecl()) {
467  // If only one of these is a local function declaration, then they are
468  // declared in different scopes, even though isDeclInScope may think
469  // they're in the same scope. (If both are local, the scope check is
470  // sufficient, and if neither is local, then they are in the same scope.)
471  continue;
472  }
473 
474  // We found the right previous declaration.
475  break;
476  }
477 
478  // C++ [dcl.fct.default]p4:
479  // For non-template functions, default arguments can be added in
480  // later declarations of a function in the same
481  // scope. Declarations in different scopes have completely
482  // distinct sets of default arguments. That is, declarations in
483  // inner scopes do not acquire default arguments from
484  // declarations in outer scopes, and vice versa. In a given
485  // function declaration, all parameters subsequent to a
486  // parameter with a default argument shall have default
487  // arguments supplied in this or previous declarations. A
488  // default argument shall not be redefined by a later
489  // declaration (not even to the same value).
490  //
491  // C++ [dcl.fct.default]p6:
492  // Except for member functions of class templates, the default arguments
493  // in a member function definition that appears outside of the class
494  // definition are added to the set of default arguments provided by the
495  // member function declaration in the class definition.
496  for (unsigned p = 0, NumParams = PrevForDefaultArgs
497  ? PrevForDefaultArgs->getNumParams()
498  : 0;
499  p < NumParams; ++p) {
500  ParmVarDecl *OldParam = PrevForDefaultArgs->getParamDecl(p);
501  ParmVarDecl *NewParam = New->getParamDecl(p);
502 
503  bool OldParamHasDfl = OldParam ? OldParam->hasDefaultArg() : false;
504  bool NewParamHasDfl = NewParam->hasDefaultArg();
505 
506  if (OldParamHasDfl && NewParamHasDfl) {
507  unsigned DiagDefaultParamID =
508  diag::err_param_default_argument_redefinition;
509 
510  // MSVC accepts that default parameters be redefined for member functions
511  // of template class. The new default parameter's value is ignored.
512  Invalid = true;
513  if (getLangOpts().MicrosoftExt) {
514  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(New);
515  if (MD && MD->getParent()->getDescribedClassTemplate()) {
516  // Merge the old default argument into the new parameter.
517  NewParam->setHasInheritedDefaultArg();
518  if (OldParam->hasUninstantiatedDefaultArg())
519  NewParam->setUninstantiatedDefaultArg(
520  OldParam->getUninstantiatedDefaultArg());
521  else
522  NewParam->setDefaultArg(OldParam->getInit());
523  DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
524  Invalid = false;
525  }
526  }
527 
528  // FIXME: If we knew where the '=' was, we could easily provide a fix-it
529  // hint here. Alternatively, we could walk the type-source information
530  // for NewParam to find the last source location in the type... but it
531  // isn't worth the effort right now. This is the kind of test case that
532  // is hard to get right:
533  // int f(int);
534  // void g(int (*fp)(int) = f);
535  // void g(int (*fp)(int) = &f);
536  Diag(NewParam->getLocation(), DiagDefaultParamID)
537  << NewParam->getDefaultArgRange();
538 
539  // Look for the function declaration where the default argument was
540  // actually written, which may be a declaration prior to Old.
541  for (auto Older = PrevForDefaultArgs;
542  OldParam->hasInheritedDefaultArg(); /**/) {
543  Older = Older->getPreviousDecl();
544  OldParam = Older->getParamDecl(p);
545  }
546 
547  Diag(OldParam->getLocation(), diag::note_previous_definition)
548  << OldParam->getDefaultArgRange();
549  } else if (OldParamHasDfl) {
550  // Merge the old default argument into the new parameter unless the new
551  // function is a friend declaration in a template class. In the latter
552  // case the default arguments will be inherited when the friend
553  // declaration will be instantiated.
554  if (New->getFriendObjectKind() == Decl::FOK_None ||
556  // It's important to use getInit() here; getDefaultArg()
557  // strips off any top-level ExprWithCleanups.
558  NewParam->setHasInheritedDefaultArg();
559  if (OldParam->hasUnparsedDefaultArg())
560  NewParam->setUnparsedDefaultArg();
561  else if (OldParam->hasUninstantiatedDefaultArg())
562  NewParam->setUninstantiatedDefaultArg(
563  OldParam->getUninstantiatedDefaultArg());
564  else
565  NewParam->setDefaultArg(OldParam->getInit());
566  }
567  } else if (NewParamHasDfl) {
568  if (New->getDescribedFunctionTemplate()) {
569  // Paragraph 4, quoted above, only applies to non-template functions.
570  Diag(NewParam->getLocation(),
571  diag::err_param_default_argument_template_redecl)
572  << NewParam->getDefaultArgRange();
573  Diag(PrevForDefaultArgs->getLocation(),
574  diag::note_template_prev_declaration)
575  << false;
576  } else if (New->getTemplateSpecializationKind()
579  // C++ [temp.expr.spec]p21:
580  // Default function arguments shall not be specified in a declaration
581  // or a definition for one of the following explicit specializations:
582  // - the explicit specialization of a function template;
583  // - the explicit specialization of a member function template;
584  // - the explicit specialization of a member function of a class
585  // template where the class template specialization to which the
586  // member function specialization belongs is implicitly
587  // instantiated.
588  Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
590  << New->getDeclName()
591  << NewParam->getDefaultArgRange();
592  } else if (New->getDeclContext()->isDependentContext()) {
593  // C++ [dcl.fct.default]p6 (DR217):
594  // Default arguments for a member function of a class template shall
595  // be specified on the initial declaration of the member function
596  // within the class template.
597  //
598  // Reading the tea leaves a bit in DR217 and its reference to DR205
599  // leads me to the conclusion that one cannot add default function
600  // arguments for an out-of-line definition of a member function of a
601  // dependent type.
602  int WhichKind = 2;
603  if (CXXRecordDecl *Record
604  = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
605  if (Record->getDescribedClassTemplate())
606  WhichKind = 0;
607  else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
608  WhichKind = 1;
609  else
610  WhichKind = 2;
611  }
612 
613  Diag(NewParam->getLocation(),
614  diag::err_param_default_argument_member_template_redecl)
615  << WhichKind
616  << NewParam->getDefaultArgRange();
617  }
618  }
619  }
620 
621  // DR1344: If a default argument is added outside a class definition and that
622  // default argument makes the function a special member function, the program
623  // is ill-formed. This can only happen for constructors.
624  if (isa<CXXConstructorDecl>(New) &&
626  CXXSpecialMember NewSM = getSpecialMember(cast<CXXMethodDecl>(New)),
627  OldSM = getSpecialMember(cast<CXXMethodDecl>(Old));
628  if (NewSM != OldSM) {
629  ParmVarDecl *NewParam = New->getParamDecl(New->getMinRequiredArguments());
630  assert(NewParam->hasDefaultArg());
631  Diag(NewParam->getLocation(), diag::err_default_arg_makes_ctor_special)
632  << NewParam->getDefaultArgRange() << NewSM;
633  Diag(Old->getLocation(), diag::note_previous_declaration);
634  }
635  }
636 
637  const FunctionDecl *Def;
638  // C++11 [dcl.constexpr]p1: If any declaration of a function or function
639  // template has a constexpr specifier then all its declarations shall
640  // contain the constexpr specifier.
641  if (New->isConstexpr() != Old->isConstexpr()) {
642  Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
643  << New << New->isConstexpr();
644  Diag(Old->getLocation(), diag::note_previous_declaration);
645  Invalid = true;
646  } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
647  Old->isDefined(Def) &&
648  // If a friend function is inlined but does not have 'inline'
649  // specifier, it is a definition. Do not report attribute conflict
650  // in this case, redefinition will be diagnosed later.
651  (New->isInlineSpecified() ||
652  New->getFriendObjectKind() == Decl::FOK_None)) {
653  // C++11 [dcl.fcn.spec]p4:
654  // If the definition of a function appears in a translation unit before its
655  // first declaration as inline, the program is ill-formed.
656  Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
657  Diag(Def->getLocation(), diag::note_previous_definition);
658  Invalid = true;
659  }
660 
661  // FIXME: It's not clear what should happen if multiple declarations of a
662  // deduction guide have different explicitness. For now at least we simply
663  // reject any case where the explicitness changes.
664  auto *NewGuide = dyn_cast<CXXDeductionGuideDecl>(New);
665  if (NewGuide && NewGuide->isExplicitSpecified() !=
666  cast<CXXDeductionGuideDecl>(Old)->isExplicitSpecified()) {
667  Diag(New->getLocation(), diag::err_deduction_guide_explicit_mismatch)
668  << NewGuide->isExplicitSpecified();
669  Diag(Old->getLocation(), diag::note_previous_declaration);
670  }
671 
672  // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
673  // argument expression, that declaration shall be a definition and shall be
674  // the only declaration of the function or function template in the
675  // translation unit.
678  Diag(New->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
679  Diag(Old->getLocation(), diag::note_previous_declaration);
680  Invalid = true;
681  }
682 
683  return Invalid;
684 }
685 
686 NamedDecl *
688  MultiTemplateParamsArg TemplateParamLists) {
689  assert(D.isDecompositionDeclarator());
691 
692  // The syntax only allows a decomposition declarator as a simple-declaration,
693  // a for-range-declaration, or a condition in Clang, but we parse it in more
694  // cases than that.
696  Diag(Decomp.getLSquareLoc(), diag::err_decomp_decl_context)
697  << Decomp.getSourceRange();
698  return nullptr;
699  }
700 
701  if (!TemplateParamLists.empty()) {
702  // FIXME: There's no rule against this, but there are also no rules that
703  // would actually make it usable, so we reject it for now.
704  Diag(TemplateParamLists.front()->getTemplateLoc(),
705  diag::err_decomp_decl_template);
706  return nullptr;
707  }
708 
709  Diag(Decomp.getLSquareLoc(),
710  !getLangOpts().CPlusPlus17
711  ? diag::ext_decomp_decl
713  ? diag::ext_decomp_decl_cond
714  : diag::warn_cxx14_compat_decomp_decl)
715  << Decomp.getSourceRange();
716 
717  // The semantic context is always just the current context.
718  DeclContext *const DC = CurContext;
719 
720  // C++1z [dcl.dcl]/8:
721  // The decl-specifier-seq shall contain only the type-specifier auto
722  // and cv-qualifiers.
723  auto &DS = D.getDeclSpec();
724  {
725  SmallVector<StringRef, 8> BadSpecifiers;
726  SmallVector<SourceLocation, 8> BadSpecifierLocs;
727  if (auto SCS = DS.getStorageClassSpec()) {
728  BadSpecifiers.push_back(DeclSpec::getSpecifierName(SCS));
729  BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());
730  }
731  if (auto TSCS = DS.getThreadStorageClassSpec()) {
732  BadSpecifiers.push_back(DeclSpec::getSpecifierName(TSCS));
733  BadSpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());
734  }
735  if (DS.isConstexprSpecified()) {
736  BadSpecifiers.push_back("constexpr");
737  BadSpecifierLocs.push_back(DS.getConstexprSpecLoc());
738  }
739  if (DS.isInlineSpecified()) {
740  BadSpecifiers.push_back("inline");
741  BadSpecifierLocs.push_back(DS.getInlineSpecLoc());
742  }
743  if (!BadSpecifiers.empty()) {
744  auto &&Err = Diag(BadSpecifierLocs.front(), diag::err_decomp_decl_spec);
745  Err << (int)BadSpecifiers.size()
746  << llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(), " ");
747  // Don't add FixItHints to remove the specifiers; we do still respect
748  // them when building the underlying variable.
749  for (auto Loc : BadSpecifierLocs)
750  Err << SourceRange(Loc, Loc);
751  }
752  // We can't recover from it being declared as a typedef.
753  if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
754  return nullptr;
755  }
756 
757  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
758  QualType R = TInfo->getType();
759 
760  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
761  UPPC_DeclarationType))
762  D.setInvalidType();
763 
764  // The syntax only allows a single ref-qualifier prior to the decomposition
765  // declarator. No other declarator chunks are permitted. Also check the type
766  // specifier here.
767  if (DS.getTypeSpecType() != DeclSpec::TST_auto ||
768  D.hasGroupingParens() || D.getNumTypeObjects() > 1 ||
769  (D.getNumTypeObjects() == 1 &&
771  Diag(Decomp.getLSquareLoc(),
772  (D.hasGroupingParens() ||
773  (D.getNumTypeObjects() &&
775  ? diag::err_decomp_decl_parens
776  : diag::err_decomp_decl_type)
777  << R;
778 
779  // In most cases, there's no actual problem with an explicitly-specified
780  // type, but a function type won't work here, and ActOnVariableDeclarator
781  // shouldn't be called for such a type.
782  if (R->isFunctionType())
783  D.setInvalidType();
784  }
785 
786  // Build the BindingDecls.
788 
789  // Build the BindingDecls.
790  for (auto &B : D.getDecompositionDeclarator().bindings()) {
791  // Check for name conflicts.
792  DeclarationNameInfo NameInfo(B.Name, B.NameLoc);
793  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
794  ForVisibleRedeclaration);
795  LookupName(Previous, S,
796  /*CreateBuiltins*/DC->getRedeclContext()->isTranslationUnit());
797 
798  // It's not permitted to shadow a template parameter name.
799  if (Previous.isSingleResult() &&
800  Previous.getFoundDecl()->isTemplateParameter()) {
801  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
802  Previous.getFoundDecl());
803  Previous.clear();
804  }
805 
806  bool ConsiderLinkage = DC->isFunctionOrMethod() &&
807  DS.getStorageClassSpec() == DeclSpec::SCS_extern;
808  FilterLookupForScope(Previous, DC, S, ConsiderLinkage,
809  /*AllowInlineNamespace*/false);
810  if (!Previous.empty()) {
811  auto *Old = Previous.getRepresentativeDecl();
812  Diag(B.NameLoc, diag::err_redefinition) << B.Name;
813  Diag(Old->getLocation(), diag::note_previous_definition);
814  }
815 
816  auto *BD = BindingDecl::Create(Context, DC, B.NameLoc, B.Name);
817  PushOnScopeChains(BD, S, true);
818  Bindings.push_back(BD);
819  ParsingInitForAutoVars.insert(BD);
820  }
821 
822  // There are no prior lookup results for the variable itself, because it
823  // is unnamed.
824  DeclarationNameInfo NameInfo((IdentifierInfo *)nullptr,
825  Decomp.getLSquareLoc());
826  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
827  ForVisibleRedeclaration);
828 
829  // Build the variable that holds the non-decomposed object.
830  bool AddToScope = true;
831  NamedDecl *New =
832  ActOnVariableDeclarator(S, D, DC, TInfo, Previous,
833  MultiTemplateParamsArg(), AddToScope, Bindings);
834  if (AddToScope) {
835  S->AddDecl(New);
836  CurContext->addHiddenDecl(New);
837  }
838 
839  if (isInOpenMPDeclareTargetContext())
840  checkDeclIsAllowedInOpenMPTarget(nullptr, New);
841 
842  return New;
843 }
844 
846  Sema &S, ArrayRef<BindingDecl *> Bindings, ValueDecl *Src,
847  QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType,
848  llvm::function_ref<ExprResult(SourceLocation, Expr *, unsigned)> GetInit) {
849  if ((int64_t)Bindings.size() != NumElems) {
850  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
851  << DecompType << (unsigned)Bindings.size() << NumElems.toString(10)
852  << (NumElems < Bindings.size());
853  return true;
854  }
855 
856  unsigned I = 0;
857  for (auto *B : Bindings) {
858  SourceLocation Loc = B->getLocation();
859  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
860  if (E.isInvalid())
861  return true;
862  E = GetInit(Loc, E.get(), I++);
863  if (E.isInvalid())
864  return true;
865  B->setBinding(ElemType, E.get());
866  }
867 
868  return false;
869 }
870 
872  ArrayRef<BindingDecl *> Bindings,
873  ValueDecl *Src, QualType DecompType,
874  const llvm::APSInt &NumElems,
875  QualType ElemType) {
877  S, Bindings, Src, DecompType, NumElems, ElemType,
878  [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
879  ExprResult E = S.ActOnIntegerConstant(Loc, I);
880  if (E.isInvalid())
881  return ExprError();
882  return S.CreateBuiltinArraySubscriptExpr(Base, Loc, E.get(), Loc);
883  });
884 }
885 
887  ValueDecl *Src, QualType DecompType,
888  const ConstantArrayType *CAT) {
889  return checkArrayLikeDecomposition(S, Bindings, Src, DecompType,
890  llvm::APSInt(CAT->getSize()),
891  CAT->getElementType());
892 }
893 
895  ValueDecl *Src, QualType DecompType,
896  const VectorType *VT) {
898  S, Bindings, Src, DecompType, llvm::APSInt::get(VT->getNumElements()),
900  DecompType.getQualifiers()));
901 }
902 
904  ArrayRef<BindingDecl *> Bindings,
905  ValueDecl *Src, QualType DecompType,
906  const ComplexType *CT) {
908  S, Bindings, Src, DecompType, llvm::APSInt::get(2),
910  DecompType.getQualifiers()),
911  [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
912  return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
913  });
914 }
915 
917  TemplateArgumentListInfo &Args) {
918  SmallString<128> SS;
919  llvm::raw_svector_ostream OS(SS);
920  bool First = true;
921  for (auto &Arg : Args.arguments()) {
922  if (!First)
923  OS << ", ";
924  Arg.getArgument().print(PrintingPolicy, OS);
925  First = false;
926  }
927  return OS.str();
928 }
929 
930 static bool lookupStdTypeTraitMember(Sema &S, LookupResult &TraitMemberLookup,
931  SourceLocation Loc, StringRef Trait,
933  unsigned DiagID) {
934  auto DiagnoseMissing = [&] {
935  if (DiagID)
936  S.Diag(Loc, DiagID) << printTemplateArgs(S.Context.getPrintingPolicy(),
937  Args);
938  return true;
939  };
940 
941  // FIXME: Factor out duplication with lookupPromiseType in SemaCoroutine.
943  if (!Std)
944  return DiagnoseMissing();
945 
946  // Look up the trait itself, within namespace std. We can diagnose various
947  // problems with this lookup even if we've been asked to not diagnose a
948  // missing specialization, because this can only fail if the user has been
949  // declaring their own names in namespace std or we don't support the
950  // standard library implementation in use.
953  if (!S.LookupQualifiedName(Result, Std))
954  return DiagnoseMissing();
955  if (Result.isAmbiguous())
956  return true;
957 
958  ClassTemplateDecl *TraitTD = Result.getAsSingle<ClassTemplateDecl>();
959  if (!TraitTD) {
960  Result.suppressDiagnostics();
961  NamedDecl *Found = *Result.begin();
962  S.Diag(Loc, diag::err_std_type_trait_not_class_template) << Trait;
963  S.Diag(Found->getLocation(), diag::note_declared_at);
964  return true;
965  }
966 
967  // Build the template-id.
968  QualType TraitTy = S.CheckTemplateIdType(TemplateName(TraitTD), Loc, Args);
969  if (TraitTy.isNull())
970  return true;
971  if (!S.isCompleteType(Loc, TraitTy)) {
972  if (DiagID)
974  Loc, TraitTy, DiagID,
976  return true;
977  }
978 
979  CXXRecordDecl *RD = TraitTy->getAsCXXRecordDecl();
980  assert(RD && "specialization of class template is not a class?");
981 
982  // Look up the member of the trait type.
983  S.LookupQualifiedName(TraitMemberLookup, RD);
984  return TraitMemberLookup.isAmbiguous();
985 }
986 
987 static TemplateArgumentLoc
989  uint64_t I) {
990  TemplateArgument Arg(S.Context, S.Context.MakeIntValue(I, T), T);
991  return S.getTrivialTemplateArgumentLoc(Arg, T, Loc);
992 }
993 
994 static TemplateArgumentLoc
997 }
998 
999 namespace { enum class IsTupleLike { TupleLike, NotTupleLike, Error }; }
1000 
1002  llvm::APSInt &Size) {
1005 
1007  LookupResult R(S, Value, Loc, Sema::LookupOrdinaryName);
1008 
1009  // Form template argument list for tuple_size<T>.
1010  TemplateArgumentListInfo Args(Loc, Loc);
1012 
1013  // If there's no tuple_size specialization, it's not tuple-like.
1014  if (lookupStdTypeTraitMember(S, R, Loc, "tuple_size", Args, /*DiagID*/0))
1015  return IsTupleLike::NotTupleLike;
1016 
1017  // If we get this far, we've committed to the tuple interpretation, but
1018  // we can still fail if there actually isn't a usable ::value.
1019 
1020  struct ICEDiagnoser : Sema::VerifyICEDiagnoser {
1021  LookupResult &R;
1023  ICEDiagnoser(LookupResult &R, TemplateArgumentListInfo &Args)
1024  : R(R), Args(Args) {}
1025  void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) {
1026  S.Diag(Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
1028  }
1029  } Diagnoser(R, Args);
1030 
1031  if (R.empty()) {
1032  Diagnoser.diagnoseNotICE(S, Loc, SourceRange());
1033  return IsTupleLike::Error;
1034  }
1035 
1036  ExprResult E =
1037  S.BuildDeclarationNameExpr(CXXScopeSpec(), R, /*NeedsADL*/false);
1038  if (E.isInvalid())
1039  return IsTupleLike::Error;
1040 
1041  E = S.VerifyIntegerConstantExpression(E.get(), &Size, Diagnoser, false);
1042  if (E.isInvalid())
1043  return IsTupleLike::Error;
1044 
1045  return IsTupleLike::TupleLike;
1046 }
1047 
1048 /// \return std::tuple_element<I, T>::type.
1050  unsigned I, QualType T) {
1051  // Form template argument list for tuple_element<I, T>.
1052  TemplateArgumentListInfo Args(Loc, Loc);
1053  Args.addArgument(
1056 
1057  DeclarationName TypeDN = S.PP.getIdentifierInfo("type");
1058  LookupResult R(S, TypeDN, Loc, Sema::LookupOrdinaryName);
1060  S, R, Loc, "tuple_element", Args,
1061  diag::err_decomp_decl_std_tuple_element_not_specialized))
1062  return QualType();
1063 
1064  auto *TD = R.getAsSingle<TypeDecl>();
1065  if (!TD) {
1066  R.suppressDiagnostics();
1067  S.Diag(Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
1069  if (!R.empty())
1070  S.Diag(R.getRepresentativeDecl()->getLocation(), diag::note_declared_at);
1071  return QualType();
1072  }
1073 
1074  return S.Context.getTypeDeclType(TD);
1075 }
1076 
1077 namespace {
1078 struct BindingDiagnosticTrap {
1079  Sema &S;
1080  DiagnosticErrorTrap Trap;
1081  BindingDecl *BD;
1082 
1083  BindingDiagnosticTrap(Sema &S, BindingDecl *BD)
1084  : S(S), Trap(S.Diags), BD(BD) {}
1085  ~BindingDiagnosticTrap() {
1086  if (Trap.hasErrorOccurred())
1087  S.Diag(BD->getLocation(), diag::note_in_binding_decl_init) << BD;
1088  }
1089 };
1090 }
1091 
1093  ArrayRef<BindingDecl *> Bindings,
1094  VarDecl *Src, QualType DecompType,
1095  const llvm::APSInt &TupleSize) {
1096  if ((int64_t)Bindings.size() != TupleSize) {
1097  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1098  << DecompType << (unsigned)Bindings.size() << TupleSize.toString(10)
1099  << (TupleSize < Bindings.size());
1100  return true;
1101  }
1102 
1103  if (Bindings.empty())
1104  return false;
1105 
1106  DeclarationName GetDN = S.PP.getIdentifierInfo("get");
1107 
1108  // [dcl.decomp]p3:
1109  // The unqualified-id get is looked up in the scope of E by class member
1110  // access lookup ...
1111  LookupResult MemberGet(S, GetDN, Src->getLocation(), Sema::LookupMemberName);
1112  bool UseMemberGet = false;
1113  if (S.isCompleteType(Src->getLocation(), DecompType)) {
1114  if (auto *RD = DecompType->getAsCXXRecordDecl())
1115  S.LookupQualifiedName(MemberGet, RD);
1116  if (MemberGet.isAmbiguous())
1117  return true;
1118  // ... and if that finds at least one declaration that is a function
1119  // template whose first template parameter is a non-type parameter ...
1120  for (NamedDecl *D : MemberGet) {
1121  if (FunctionTemplateDecl *FTD =
1122  dyn_cast<FunctionTemplateDecl>(D->getUnderlyingDecl())) {
1123  TemplateParameterList *TPL = FTD->getTemplateParameters();
1124  if (TPL->size() != 0 &&
1125  isa<NonTypeTemplateParmDecl>(TPL->getParam(0))) {
1126  // ... the initializer is e.get<i>().
1127  UseMemberGet = true;
1128  break;
1129  }
1130  }
1131  }
1132  S.FilterAcceptableTemplateNames(MemberGet);
1133  }
1134 
1135  unsigned I = 0;
1136  for (auto *B : Bindings) {
1137  BindingDiagnosticTrap Trap(S, B);
1138  SourceLocation Loc = B->getLocation();
1139 
1140  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1141  if (E.isInvalid())
1142  return true;
1143 
1144  // e is an lvalue if the type of the entity is an lvalue reference and
1145  // an xvalue otherwise
1146  if (!Src->getType()->isLValueReferenceType())
1147  E = ImplicitCastExpr::Create(S.Context, E.get()->getType(), CK_NoOp,
1148  E.get(), nullptr, VK_XValue);
1149 
1150  TemplateArgumentListInfo Args(Loc, Loc);
1151  Args.addArgument(
1153 
1154  if (UseMemberGet) {
1155  // if [lookup of member get] finds at least one declaration, the
1156  // initializer is e.get<i-1>().
1157  E = S.BuildMemberReferenceExpr(E.get(), DecompType, Loc, false,
1158  CXXScopeSpec(), SourceLocation(), nullptr,
1159  MemberGet, &Args, nullptr);
1160  if (E.isInvalid())
1161  return true;
1162 
1163  E = S.ActOnCallExpr(nullptr, E.get(), Loc, None, Loc);
1164  } else {
1165  // Otherwise, the initializer is get<i-1>(e), where get is looked up
1166  // in the associated namespaces.
1169  DeclarationNameInfo(GetDN, Loc), /*RequiresADL*/true, &Args,
1171 
1172  Expr *Arg = E.get();
1173  E = S.ActOnCallExpr(nullptr, Get, Loc, Arg, Loc);
1174  }
1175  if (E.isInvalid())
1176  return true;
1177  Expr *Init = E.get();
1178 
1179  // Given the type T designated by std::tuple_element<i - 1, E>::type,
1180  QualType T = getTupleLikeElementType(S, Loc, I, DecompType);
1181  if (T.isNull())
1182  return true;
1183 
1184  // each vi is a variable of type "reference to T" initialized with the
1185  // initializer, where the reference is an lvalue reference if the
1186  // initializer is an lvalue and an rvalue reference otherwise
1187  QualType RefType =
1188  S.BuildReferenceType(T, E.get()->isLValue(), Loc, B->getDeclName());
1189  if (RefType.isNull())
1190  return true;
1191  auto *RefVD = VarDecl::Create(
1192  S.Context, Src->getDeclContext(), Loc, Loc,
1193  B->getDeclName().getAsIdentifierInfo(), RefType,
1196  RefVD->setTSCSpec(Src->getTSCSpec());
1197  RefVD->setImplicit();
1198  if (Src->isInlineSpecified())
1199  RefVD->setInlineSpecified();
1200  RefVD->getLexicalDeclContext()->addHiddenDecl(RefVD);
1201 
1204  InitializationSequence Seq(S, Entity, Kind, Init);
1205  E = Seq.Perform(S, Entity, Kind, Init);
1206  if (E.isInvalid())
1207  return true;
1208  E = S.ActOnFinishFullExpr(E.get(), Loc);
1209  if (E.isInvalid())
1210  return true;
1211  RefVD->setInit(E.get());
1212  RefVD->checkInitIsICE();
1213 
1215  DeclarationNameInfo(B->getDeclName(), Loc),
1216  RefVD);
1217  if (E.isInvalid())
1218  return true;
1219 
1220  B->setBinding(T, E.get());
1221  I++;
1222  }
1223 
1224  return false;
1225 }
1226 
1227 /// Find the base class to decompose in a built-in decomposition of a class type.
1228 /// This base class search is, unfortunately, not quite like any other that we
1229 /// perform anywhere else in C++.
1231  const CXXRecordDecl *RD,
1232  CXXCastPath &BasePath) {
1233  auto BaseHasFields = [](const CXXBaseSpecifier *Specifier,
1234  CXXBasePath &Path) {
1235  return Specifier->getType()->getAsCXXRecordDecl()->hasDirectFields();
1236  };
1237 
1238  const CXXRecordDecl *ClassWithFields = nullptr;
1240  if (RD->hasDirectFields())
1241  // [dcl.decomp]p4:
1242  // Otherwise, all of E's non-static data members shall be public direct
1243  // members of E ...
1244  ClassWithFields = RD;
1245  else {
1246  // ... or of ...
1247  CXXBasePaths Paths;
1248  Paths.setOrigin(const_cast<CXXRecordDecl*>(RD));
1249  if (!RD->lookupInBases(BaseHasFields, Paths)) {
1250  // If no classes have fields, just decompose RD itself. (This will work
1251  // if and only if zero bindings were provided.)
1252  return DeclAccessPair::make(const_cast<CXXRecordDecl*>(RD), AS_public);
1253  }
1254 
1255  CXXBasePath *BestPath = nullptr;
1256  for (auto &P : Paths) {
1257  if (!BestPath)
1258  BestPath = &P;
1259  else if (!S.Context.hasSameType(P.back().Base->getType(),
1260  BestPath->back().Base->getType())) {
1261  // ... the same ...
1262  S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1263  << false << RD << BestPath->back().Base->getType()
1264  << P.back().Base->getType();
1265  return DeclAccessPair();
1266  } else if (P.Access < BestPath->Access) {
1267  BestPath = &P;
1268  }
1269  }
1270 
1271  // ... unambiguous ...
1272  QualType BaseType = BestPath->back().Base->getType();
1273  if (Paths.isAmbiguous(S.Context.getCanonicalType(BaseType))) {
1274  S.Diag(Loc, diag::err_decomp_decl_ambiguous_base)
1275  << RD << BaseType << S.getAmbiguousPathsDisplayString(Paths);
1276  return DeclAccessPair();
1277  }
1278 
1279  // ... [accessible, implied by other rules] base class of E.
1280  S.CheckBaseClassAccess(Loc, BaseType, S.Context.getRecordType(RD),
1281  *BestPath, diag::err_decomp_decl_inaccessible_base);
1282  AS = BestPath->Access;
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 DeclAccessPair();
1296  }
1297 
1298  return DeclAccessPair::make(const_cast<CXXRecordDecl*>(ClassWithFields), AS);
1299 }
1300 
1302  ValueDecl *Src, QualType DecompType,
1303  const CXXRecordDecl *OrigRD) {
1304  if (S.RequireCompleteType(Src->getLocation(), DecompType,
1305  diag::err_incomplete_type))
1306  return true;
1307 
1308  CXXCastPath BasePath;
1309  DeclAccessPair BasePair =
1310  findDecomposableBaseClass(S, Src->getLocation(), OrigRD, BasePath);
1311  const CXXRecordDecl *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
1312  if (!RD)
1313  return true;
1315  DecompType.getQualifiers());
1316 
1317  auto DiagnoseBadNumberOfBindings = [&]() -> bool {
1318  unsigned NumFields =
1319  std::count_if(RD->field_begin(), RD->field_end(),
1320  [](FieldDecl *FD) { return !FD->isUnnamedBitfield(); });
1321  assert(Bindings.size() != NumFields);
1322  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1323  << DecompType << (unsigned)Bindings.size() << NumFields
1324  << (NumFields < Bindings.size());
1325  return true;
1326  };
1327 
1328  // all of E's non-static data members shall be [...] well-formed
1329  // when named as e.name in the context of the structured binding,
1330  // E shall not have an anonymous union member, ...
1331  unsigned I = 0;
1332  for (auto *FD : RD->fields()) {
1333  if (FD->isUnnamedBitfield())
1334  continue;
1335 
1336  if (FD->isAnonymousStructOrUnion()) {
1337  S.Diag(Src->getLocation(), diag::err_decomp_decl_anon_union_member)
1338  << DecompType << FD->getType()->isUnionType();
1339  S.Diag(FD->getLocation(), diag::note_declared_at);
1340  return true;
1341  }
1342 
1343  // We have a real field to bind.
1344  if (I >= Bindings.size())
1345  return DiagnoseBadNumberOfBindings();
1346  auto *B = Bindings[I++];
1347  SourceLocation Loc = B->getLocation();
1348 
1349  // The field must be accessible in the context of the structured binding.
1350  // We already checked that the base class is accessible.
1351  // FIXME: Add 'const' to AccessedEntity's classes so we can remove the
1352  // const_cast here.
1354  Loc, const_cast<CXXRecordDecl *>(OrigRD),
1356  BasePair.getAccess(), FD->getAccess())));
1357 
1358  // Initialize the binding to Src.FD.
1359  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1360  if (E.isInvalid())
1361  return true;
1362  E = S.ImpCastExprToType(E.get(), BaseType, CK_UncheckedDerivedToBase,
1363  VK_LValue, &BasePath);
1364  if (E.isInvalid())
1365  return true;
1366  E = S.BuildFieldReferenceExpr(E.get(), /*IsArrow*/ false, Loc,
1367  CXXScopeSpec(), FD,
1368  DeclAccessPair::make(FD, FD->getAccess()),
1369  DeclarationNameInfo(FD->getDeclName(), Loc));
1370  if (E.isInvalid())
1371  return true;
1372 
1373  // If the type of the member is T, the referenced type is cv T, where cv is
1374  // the cv-qualification of the decomposition expression.
1375  //
1376  // FIXME: We resolve a defect here: if the field is mutable, we do not add
1377  // 'const' to the type of the field.
1378  Qualifiers Q = DecompType.getQualifiers();
1379  if (FD->isMutable())
1380  Q.removeConst();
1381  B->setBinding(S.BuildQualifiedType(FD->getType(), Loc, Q), E.get());
1382  }
1383 
1384  if (I != Bindings.size())
1385  return DiagnoseBadNumberOfBindings();
1386 
1387  return false;
1388 }
1389 
1391  QualType DecompType = DD->getType();
1392 
1393  // If the type of the decomposition is dependent, then so is the type of
1394  // each binding.
1395  if (DecompType->isDependentType()) {
1396  for (auto *B : DD->bindings())
1397  B->setType(Context.DependentTy);
1398  return;
1399  }
1400 
1401  DecompType = DecompType.getNonReferenceType();
1402  ArrayRef<BindingDecl*> Bindings = DD->bindings();
1403 
1404  // C++1z [dcl.decomp]/2:
1405  // If E is an array type [...]
1406  // As an extension, we also support decomposition of built-in complex and
1407  // vector types.
1408  if (auto *CAT = Context.getAsConstantArrayType(DecompType)) {
1409  if (checkArrayDecomposition(*this, Bindings, DD, DecompType, CAT))
1410  DD->setInvalidDecl();
1411  return;
1412  }
1413  if (auto *VT = DecompType->getAs<VectorType>()) {
1414  if (checkVectorDecomposition(*this, Bindings, DD, DecompType, VT))
1415  DD->setInvalidDecl();
1416  return;
1417  }
1418  if (auto *CT = DecompType->getAs<ComplexType>()) {
1419  if (checkComplexDecomposition(*this, Bindings, DD, DecompType, CT))
1420  DD->setInvalidDecl();
1421  return;
1422  }
1423 
1424  // C++1z [dcl.decomp]/3:
1425  // if the expression std::tuple_size<E>::value is a well-formed integral
1426  // constant expression, [...]
1427  llvm::APSInt TupleSize(32);
1428  switch (isTupleLike(*this, DD->getLocation(), DecompType, TupleSize)) {
1429  case IsTupleLike::Error:
1430  DD->setInvalidDecl();
1431  return;
1432 
1433  case IsTupleLike::TupleLike:
1434  if (checkTupleLikeDecomposition(*this, Bindings, DD, DecompType, TupleSize))
1435  DD->setInvalidDecl();
1436  return;
1437 
1438  case IsTupleLike::NotTupleLike:
1439  break;
1440  }
1441 
1442  // C++1z [dcl.dcl]/8:
1443  // [E shall be of array or non-union class type]
1444  CXXRecordDecl *RD = DecompType->getAsCXXRecordDecl();
1445  if (!RD || RD->isUnion()) {
1446  Diag(DD->getLocation(), diag::err_decomp_decl_unbindable_type)
1447  << DD << !RD << DecompType;
1448  DD->setInvalidDecl();
1449  return;
1450  }
1451 
1452  // C++1z [dcl.decomp]/4:
1453  // all of E's non-static data members shall be [...] direct members of
1454  // E or of the same unambiguous public base class of E, ...
1455  if (checkMemberDecomposition(*this, Bindings, DD, DecompType, RD))
1456  DD->setInvalidDecl();
1457 }
1458 
1459 /// Merge the exception specifications of two variable declarations.
1460 ///
1461 /// This is called when there's a redeclaration of a VarDecl. The function
1462 /// checks if the redeclaration might have an exception specification and
1463 /// validates compatibility and merges the specs if necessary.
1465  // Shortcut if exceptions are disabled.
1466  if (!getLangOpts().CXXExceptions)
1467  return;
1468 
1469  assert(Context.hasSameType(New->getType(), Old->getType()) &&
1470  "Should only be called if types are otherwise the same.");
1471 
1472  QualType NewType = New->getType();
1473  QualType OldType = Old->getType();
1474 
1475  // We're only interested in pointers and references to functions, as well
1476  // as pointers to member functions.
1477  if (const ReferenceType *R = NewType->getAs<ReferenceType>()) {
1478  NewType = R->getPointeeType();
1479  OldType = OldType->getAs<ReferenceType>()->getPointeeType();
1480  } else if (const PointerType *P = NewType->getAs<PointerType>()) {
1481  NewType = P->getPointeeType();
1482  OldType = OldType->getAs<PointerType>()->getPointeeType();
1483  } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) {
1484  NewType = M->getPointeeType();
1485  OldType = OldType->getAs<MemberPointerType>()->getPointeeType();
1486  }
1487 
1488  if (!NewType->isFunctionProtoType())
1489  return;
1490 
1491  // There's lots of special cases for functions. For function pointers, system
1492  // libraries are hopefully not as broken so that we don't need these
1493  // workarounds.
1494  if (CheckEquivalentExceptionSpec(
1495  OldType->getAs<FunctionProtoType>(), Old->getLocation(),
1496  NewType->getAs<FunctionProtoType>(), New->getLocation())) {
1497  New->setInvalidDecl();
1498  }
1499 }
1500 
1501 /// CheckCXXDefaultArguments - Verify that the default arguments for a
1502 /// function declaration are well-formed according to C++
1503 /// [dcl.fct.default].
1505  unsigned NumParams = FD->getNumParams();
1506  unsigned p;
1507 
1508  // Find first parameter with a default argument
1509  for (p = 0; p < NumParams; ++p) {
1510  ParmVarDecl *Param = FD->getParamDecl(p);
1511  if (Param->hasDefaultArg())
1512  break;
1513  }
1514 
1515  // C++11 [dcl.fct.default]p4:
1516  // In a given function declaration, each parameter subsequent to a parameter
1517  // with a default argument shall have a default argument supplied in this or
1518  // a previous declaration or shall be a function parameter pack. A default
1519  // argument shall not be redefined by a later declaration (not even to the
1520  // same value).
1521  unsigned LastMissingDefaultArg = 0;
1522  for (; p < NumParams; ++p) {
1523  ParmVarDecl *Param = FD->getParamDecl(p);
1524  if (!Param->hasDefaultArg() && !Param->isParameterPack()) {
1525  if (Param->isInvalidDecl())
1526  /* We already complained about this parameter. */;
1527  else if (Param->getIdentifier())
1528  Diag(Param->getLocation(),
1529  diag::err_param_default_argument_missing_name)
1530  << Param->getIdentifier();
1531  else
1532  Diag(Param->getLocation(),
1533  diag::err_param_default_argument_missing);
1534 
1535  LastMissingDefaultArg = p;
1536  }
1537  }
1538 
1539  if (LastMissingDefaultArg > 0) {
1540  // Some default arguments were missing. Clear out all of the
1541  // default arguments up to (and including) the last missing
1542  // default argument, so that we leave the function parameters
1543  // in a semantically valid state.
1544  for (p = 0; p <= LastMissingDefaultArg; ++p) {
1545  ParmVarDecl *Param = FD->getParamDecl(p);
1546  if (Param->hasDefaultArg()) {
1547  Param->setDefaultArg(nullptr);
1548  }
1549  }
1550  }
1551 }
1552 
1553 // CheckConstexprParameterTypes - Check whether a function's parameter types
1554 // are all literal types. If so, return true. If not, produce a suitable
1555 // diagnostic and return false.
1556 static bool CheckConstexprParameterTypes(Sema &SemaRef,
1557  const FunctionDecl *FD) {
1558  unsigned ArgIndex = 0;
1559  const FunctionProtoType *FT = FD->getType()->getAs<FunctionProtoType>();
1561  e = FT->param_type_end();
1562  i != e; ++i, ++ArgIndex) {
1563  const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
1564  SourceLocation ParamLoc = PD->getLocation();
1565  if (!(*i)->isDependentType() &&
1566  SemaRef.RequireLiteralType(ParamLoc, *i,
1567  diag::err_constexpr_non_literal_param,
1568  ArgIndex+1, PD->getSourceRange(),
1569  isa<CXXConstructorDecl>(FD)))
1570  return false;
1571  }
1572  return true;
1573 }
1574 
1575 /// Get diagnostic %select index for tag kind for
1576 /// record diagnostic message.
1577 /// WARNING: Indexes apply to particular diagnostics only!
1578 ///
1579 /// \returns diagnostic %select index.
1581  switch (Tag) {
1582  case TTK_Struct: return 0;
1583  case TTK_Interface: return 1;
1584  case TTK_Class: return 2;
1585  default: llvm_unreachable("Invalid tag kind for record diagnostic!");
1586  }
1587 }
1588 
1589 // CheckConstexprFunctionDecl - Check whether a function declaration satisfies
1590 // the requirements of a constexpr function definition or a constexpr
1591 // constructor definition. If so, return true. If not, produce appropriate
1592 // diagnostics and return false.
1593 //
1594 // This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360.
1596  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
1597  if (MD && MD->isInstance()) {
1598  // C++11 [dcl.constexpr]p4:
1599  // The definition of a constexpr constructor shall satisfy the following
1600  // constraints:
1601  // - the class shall not have any virtual base classes;
1602  const CXXRecordDecl *RD = MD->getParent();
1603  if (RD->getNumVBases()) {
1604  Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base)
1605  << isa<CXXConstructorDecl>(NewFD)
1607  for (const auto &I : RD->vbases())
1608  Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
1609  << I.getSourceRange();
1610  return false;
1611  }
1612  }
1613 
1614  if (!isa<CXXConstructorDecl>(NewFD)) {
1615  // C++11 [dcl.constexpr]p3:
1616  // The definition of a constexpr function shall satisfy the following
1617  // constraints:
1618  // - it shall not be virtual;
1619  const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
1620  if (Method && Method->isVirtual()) {
1621  Method = Method->getCanonicalDecl();
1622  Diag(Method->getLocation(), diag::err_constexpr_virtual);
1623 
1624  // If it's not obvious why this function is virtual, find an overridden
1625  // function which uses the 'virtual' keyword.
1626  const CXXMethodDecl *WrittenVirtual = Method;
1627  while (!WrittenVirtual->isVirtualAsWritten())
1628  WrittenVirtual = *WrittenVirtual->begin_overridden_methods();
1629  if (WrittenVirtual != Method)
1630  Diag(WrittenVirtual->getLocation(),
1631  diag::note_overridden_virtual_function);
1632  return false;
1633  }
1634 
1635  // - its return type shall be a literal type;
1636  QualType RT = NewFD->getReturnType();
1637  if (!RT->isDependentType() &&
1638  RequireLiteralType(NewFD->getLocation(), RT,
1639  diag::err_constexpr_non_literal_return))
1640  return false;
1641  }
1642 
1643  // - each of its parameter types shall be a literal type;
1644  if (!CheckConstexprParameterTypes(*this, NewFD))
1645  return false;
1646 
1647  return true;
1648 }
1649 
1650 /// Check the given declaration statement is legal within a constexpr function
1651 /// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.
1652 ///
1653 /// \return true if the body is OK (maybe only as an extension), false if we
1654 /// have diagnosed a problem.
1655 static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
1656  DeclStmt *DS, SourceLocation &Cxx1yLoc) {
1657  // C++11 [dcl.constexpr]p3 and p4:
1658  // The definition of a constexpr function(p3) or constructor(p4) [...] shall
1659  // contain only
1660  for (const auto *DclIt : DS->decls()) {
1661  switch (DclIt->getKind()) {
1662  case Decl::StaticAssert:
1663  case Decl::Using:
1664  case Decl::UsingShadow:
1665  case Decl::UsingDirective:
1666  case Decl::UnresolvedUsingTypename:
1667  case Decl::UnresolvedUsingValue:
1668  // - static_assert-declarations
1669  // - using-declarations,
1670  // - using-directives,
1671  continue;
1672 
1673  case Decl::Typedef:
1674  case Decl::TypeAlias: {
1675  // - typedef declarations and alias-declarations that do not define
1676  // classes or enumerations,
1677  const auto *TN = cast<TypedefNameDecl>(DclIt);
1678  if (TN->getUnderlyingType()->isVariablyModifiedType()) {
1679  // Don't allow variably-modified types in constexpr functions.
1680  TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
1681  SemaRef.Diag(TL.getBeginLoc(), diag::err_constexpr_vla)
1682  << TL.getSourceRange() << TL.getType()
1683  << isa<CXXConstructorDecl>(Dcl);
1684  return false;
1685  }
1686  continue;
1687  }
1688 
1689  case Decl::Enum:
1690  case Decl::CXXRecord:
1691  // C++1y allows types to be defined, not just declared.
1692  if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition())
1693  SemaRef.Diag(DS->getBeginLoc(),
1694  SemaRef.getLangOpts().CPlusPlus14
1695  ? diag::warn_cxx11_compat_constexpr_type_definition
1696  : diag::ext_constexpr_type_definition)
1697  << isa<CXXConstructorDecl>(Dcl);
1698  continue;
1699 
1700  case Decl::EnumConstant:
1701  case Decl::IndirectField:
1702  case Decl::ParmVar:
1703  // These can only appear with other declarations which are banned in
1704  // C++11 and permitted in C++1y, so ignore them.
1705  continue;
1706 
1707  case Decl::Var:
1708  case Decl::Decomposition: {
1709  // C++1y [dcl.constexpr]p3 allows anything except:
1710  // a definition of a variable of non-literal type or of static or
1711  // thread storage duration or for which no initialization is performed.
1712  const auto *VD = cast<VarDecl>(DclIt);
1713  if (VD->isThisDeclarationADefinition()) {
1714  if (VD->isStaticLocal()) {
1715  SemaRef.Diag(VD->getLocation(),
1716  diag::err_constexpr_local_var_static)
1717  << isa<CXXConstructorDecl>(Dcl)
1718  << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
1719  return false;
1720  }
1721  if (!VD->getType()->isDependentType() &&
1722  SemaRef.RequireLiteralType(
1723  VD->getLocation(), VD->getType(),
1724  diag::err_constexpr_local_var_non_literal_type,
1725  isa<CXXConstructorDecl>(Dcl)))
1726  return false;
1727  if (!VD->getType()->isDependentType() &&
1728  !VD->hasInit() && !VD->isCXXForRangeDecl()) {
1729  SemaRef.Diag(VD->getLocation(),
1730  diag::err_constexpr_local_var_no_init)
1731  << isa<CXXConstructorDecl>(Dcl);
1732  return false;
1733  }
1734  }
1735  SemaRef.Diag(VD->getLocation(),
1736  SemaRef.getLangOpts().CPlusPlus14
1737  ? diag::warn_cxx11_compat_constexpr_local_var
1738  : diag::ext_constexpr_local_var)
1739  << isa<CXXConstructorDecl>(Dcl);
1740  continue;
1741  }
1742 
1743  case Decl::NamespaceAlias:
1744  case Decl::Function:
1745  // These are disallowed in C++11 and permitted in C++1y. Allow them
1746  // everywhere as an extension.
1747  if (!Cxx1yLoc.isValid())
1748  Cxx1yLoc = DS->getBeginLoc();
1749  continue;
1750 
1751  default:
1752  SemaRef.Diag(DS->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
1753  << isa<CXXConstructorDecl>(Dcl);
1754  return false;
1755  }
1756  }
1757 
1758  return true;
1759 }
1760 
1761 /// Check that the given field is initialized within a constexpr constructor.
1762 ///
1763 /// \param Dcl The constexpr constructor being checked.
1764 /// \param Field The field being checked. This may be a member of an anonymous
1765 /// struct or union nested within the class being checked.
1766 /// \param Inits All declarations, including anonymous struct/union members and
1767 /// indirect members, for which any initialization was provided.
1768 /// \param Diagnosed Set to true if an error is produced.
1770  const FunctionDecl *Dcl,
1771  FieldDecl *Field,
1772  llvm::SmallSet<Decl*, 16> &Inits,
1773  bool &Diagnosed) {
1774  if (Field->isInvalidDecl())
1775  return;
1776 
1777  if (Field->isUnnamedBitfield())
1778  return;
1779 
1780  // Anonymous unions with no variant members and empty anonymous structs do not
1781  // need to be explicitly initialized. FIXME: Anonymous structs that contain no
1782  // indirect fields don't need initializing.
1783  if (Field->isAnonymousStructOrUnion() &&
1784  (Field->getType()->isUnionType()
1785  ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
1786  : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
1787  return;
1788 
1789  if (!Inits.count(Field)) {
1790  if (!Diagnosed) {
1791  SemaRef.Diag(Dcl->getLocation(), diag::err_constexpr_ctor_missing_init);
1792  Diagnosed = true;
1793  }
1794  SemaRef.Diag(Field->getLocation(), diag::note_constexpr_ctor_missing_init);
1795  } else if (Field->isAnonymousStructOrUnion()) {
1796  const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
1797  for (auto *I : RD->fields())
1798  // If an anonymous union contains an anonymous struct of which any member
1799  // is initialized, all members must be initialized.
1800  if (!RD->isUnion() || Inits.count(I))
1801  CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed);
1802  }
1803 }
1804 
1805 /// Check the provided statement is allowed in a constexpr function
1806 /// definition.
1807 static bool
1809  SmallVectorImpl<SourceLocation> &ReturnStmts,
1810  SourceLocation &Cxx1yLoc, SourceLocation &Cxx2aLoc) {
1811  // - its function-body shall be [...] a compound-statement that contains only
1812  switch (S->getStmtClass()) {
1813  case Stmt::NullStmtClass:
1814  // - null statements,
1815  return true;
1816 
1817  case Stmt::DeclStmtClass:
1818  // - static_assert-declarations
1819  // - using-declarations,
1820  // - using-directives,
1821  // - typedef declarations and alias-declarations that do not define
1822  // classes or enumerations,
1823  if (!CheckConstexprDeclStmt(SemaRef, Dcl, cast<DeclStmt>(S), Cxx1yLoc))
1824  return false;
1825  return true;
1826 
1827  case Stmt::ReturnStmtClass:
1828  // - and exactly one return statement;
1829  if (isa<CXXConstructorDecl>(Dcl)) {
1830  // C++1y allows return statements in constexpr constructors.
1831  if (!Cxx1yLoc.isValid())
1832  Cxx1yLoc = S->getBeginLoc();
1833  return true;
1834  }
1835 
1836  ReturnStmts.push_back(S->getBeginLoc());
1837  return true;
1838 
1839  case Stmt::CompoundStmtClass: {
1840  // C++1y allows compound-statements.
1841  if (!Cxx1yLoc.isValid())
1842  Cxx1yLoc = S->getBeginLoc();
1843 
1844  CompoundStmt *CompStmt = cast<CompoundStmt>(S);
1845  for (auto *BodyIt : CompStmt->body()) {
1846  if (!CheckConstexprFunctionStmt(SemaRef, Dcl, BodyIt, ReturnStmts,
1847  Cxx1yLoc, Cxx2aLoc))
1848  return false;
1849  }
1850  return true;
1851  }
1852 
1853  case Stmt::AttributedStmtClass:
1854  if (!Cxx1yLoc.isValid())
1855  Cxx1yLoc = S->getBeginLoc();
1856  return true;
1857 
1858  case Stmt::IfStmtClass: {
1859  // C++1y allows if-statements.
1860  if (!Cxx1yLoc.isValid())
1861  Cxx1yLoc = S->getBeginLoc();
1862 
1863  IfStmt *If = cast<IfStmt>(S);
1864  if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
1865  Cxx1yLoc, Cxx2aLoc))
1866  return false;
1867  if (If->getElse() &&
1868  !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
1869  Cxx1yLoc, Cxx2aLoc))
1870  return false;
1871  return true;
1872  }
1873 
1874  case Stmt::WhileStmtClass:
1875  case Stmt::DoStmtClass:
1876  case Stmt::ForStmtClass:
1877  case Stmt::CXXForRangeStmtClass:
1878  case Stmt::ContinueStmtClass:
1879  // C++1y allows all of these. We don't allow them as extensions in C++11,
1880  // because they don't make sense without variable mutation.
1881  if (!SemaRef.getLangOpts().CPlusPlus14)
1882  break;
1883  if (!Cxx1yLoc.isValid())
1884  Cxx1yLoc = S->getBeginLoc();
1885  for (Stmt *SubStmt : S->children())
1886  if (SubStmt &&
1887  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
1888  Cxx1yLoc, Cxx2aLoc))
1889  return false;
1890  return true;
1891 
1892  case Stmt::SwitchStmtClass:
1893  case Stmt::CaseStmtClass:
1894  case Stmt::DefaultStmtClass:
1895  case Stmt::BreakStmtClass:
1896  // C++1y allows switch-statements, and since they don't need variable
1897  // mutation, we can reasonably allow them in C++11 as an extension.
1898  if (!Cxx1yLoc.isValid())
1899  Cxx1yLoc = S->getBeginLoc();
1900  for (Stmt *SubStmt : S->children())
1901  if (SubStmt &&
1902  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
1903  Cxx1yLoc, Cxx2aLoc))
1904  return false;
1905  return true;
1906 
1907  case Stmt::CXXTryStmtClass:
1908  if (Cxx2aLoc.isInvalid())
1909  Cxx2aLoc = S->getBeginLoc();
1910  for (Stmt *SubStmt : S->children()) {
1911  if (SubStmt &&
1912  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
1913  Cxx1yLoc, Cxx2aLoc))
1914  return false;
1915  }
1916  return true;
1917 
1918  case Stmt::CXXCatchStmtClass:
1919  // Do not bother checking the language mode (already covered by the
1920  // try block check).
1921  if (!CheckConstexprFunctionStmt(SemaRef, Dcl,
1922  cast<CXXCatchStmt>(S)->getHandlerBlock(),
1923  ReturnStmts, Cxx1yLoc, Cxx2aLoc))
1924  return false;
1925  return true;
1926 
1927  default:
1928  if (!isa<Expr>(S))
1929  break;
1930 
1931  // C++1y allows expression-statements.
1932  if (!Cxx1yLoc.isValid())
1933  Cxx1yLoc = S->getBeginLoc();
1934  return true;
1935  }
1936 
1937  SemaRef.Diag(S->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
1938  << isa<CXXConstructorDecl>(Dcl);
1939  return false;
1940 }
1941 
1942 /// Check the body for the given constexpr function declaration only contains
1943 /// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.
1944 ///
1945 /// \return true if the body is OK, false if we have diagnosed a problem.
1947  SmallVector<SourceLocation, 4> ReturnStmts;
1948 
1949  if (isa<CXXTryStmt>(Body)) {
1950  // C++11 [dcl.constexpr]p3:
1951  // The definition of a constexpr function shall satisfy the following
1952  // constraints: [...]
1953  // - its function-body shall be = delete, = default, or a
1954  // compound-statement
1955  //
1956  // C++11 [dcl.constexpr]p4:
1957  // In the definition of a constexpr constructor, [...]
1958  // - its function-body shall not be a function-try-block;
1959  //
1960  // This restriction is lifted in C++2a, as long as inner statements also
1961  // apply the general constexpr rules.
1962  Diag(Body->getBeginLoc(),
1963  !getLangOpts().CPlusPlus2a
1964  ? diag::ext_constexpr_function_try_block_cxx2a
1965  : diag::warn_cxx17_compat_constexpr_function_try_block)
1966  << isa<CXXConstructorDecl>(Dcl);
1967  }
1968 
1969  // - its function-body shall be [...] a compound-statement that contains only
1970  // [... list of cases ...]
1971  //
1972  // Note that walking the children here is enough to properly check for
1973  // CompoundStmt and CXXTryStmt body.
1974  SourceLocation Cxx1yLoc, Cxx2aLoc;
1975  for (Stmt *SubStmt : Body->children()) {
1976  if (SubStmt &&
1977  !CheckConstexprFunctionStmt(*this, Dcl, SubStmt, ReturnStmts,
1978  Cxx1yLoc, Cxx2aLoc))
1979  return false;
1980  }
1981 
1982  if (Cxx2aLoc.isValid())
1983  Diag(Cxx2aLoc,
1984  getLangOpts().CPlusPlus2a
1985  ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt
1986  : diag::ext_constexpr_body_invalid_stmt_cxx2a)
1987  << isa<CXXConstructorDecl>(Dcl);
1988  if (Cxx1yLoc.isValid())
1989  Diag(Cxx1yLoc,
1990  getLangOpts().CPlusPlus14
1991  ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
1992  : diag::ext_constexpr_body_invalid_stmt)
1993  << isa<CXXConstructorDecl>(Dcl);
1994 
1995  if (const CXXConstructorDecl *Constructor
1996  = dyn_cast<CXXConstructorDecl>(Dcl)) {
1997  const CXXRecordDecl *RD = Constructor->getParent();
1998  // DR1359:
1999  // - every non-variant non-static data member and base class sub-object
2000  // shall be initialized;
2001  // DR1460:
2002  // - if the class is a union having variant members, exactly one of them
2003  // shall be initialized;
2004  if (RD->isUnion()) {
2005  if (Constructor->getNumCtorInitializers() == 0 &&
2006  RD->hasVariantMembers()) {
2007  Diag(Dcl->getLocation(), diag::err_constexpr_union_ctor_no_init);
2008  return false;
2009  }
2010  } else if (!Constructor->isDependentContext() &&
2011  !Constructor->isDelegatingConstructor()) {
2012  assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases");
2013 
2014  // Skip detailed checking if we have enough initializers, and we would
2015  // allow at most one initializer per member.
2016  bool AnyAnonStructUnionMembers = false;
2017  unsigned Fields = 0;
2019  E = RD->field_end(); I != E; ++I, ++Fields) {
2020  if (I->isAnonymousStructOrUnion()) {
2021  AnyAnonStructUnionMembers = true;
2022  break;
2023  }
2024  }
2025  // DR1460:
2026  // - if the class is a union-like class, but is not a union, for each of
2027  // its anonymous union members having variant members, exactly one of
2028  // them shall be initialized;
2029  if (AnyAnonStructUnionMembers ||
2030  Constructor->getNumCtorInitializers() != RD->getNumBases() + Fields) {
2031  // Check initialization of non-static data members. Base classes are
2032  // always initialized so do not need to be checked. Dependent bases
2033  // might not have initializers in the member initializer list.
2034  llvm::SmallSet<Decl*, 16> Inits;
2035  for (const auto *I: Constructor->inits()) {
2036  if (FieldDecl *FD = I->getMember())
2037  Inits.insert(FD);
2038  else if (IndirectFieldDecl *ID = I->getIndirectMember())
2039  Inits.insert(ID->chain_begin(), ID->chain_end());
2040  }
2041 
2042  bool Diagnosed = false;
2043  for (auto *I : RD->fields())
2044  CheckConstexprCtorInitializer(*this, Dcl, I, Inits, Diagnosed);
2045  if (Diagnosed)
2046  return false;
2047  }
2048  }
2049  } else {
2050  if (ReturnStmts.empty()) {
2051  // C++1y doesn't require constexpr functions to contain a 'return'
2052  // statement. We still do, unless the return type might be void, because
2053  // otherwise if there's no return statement, the function cannot
2054  // be used in a core constant expression.
2055  bool OK = getLangOpts().CPlusPlus14 &&
2056  (Dcl->getReturnType()->isVoidType() ||
2057  Dcl->getReturnType()->isDependentType());
2058  Diag(Dcl->getLocation(),
2059  OK ? diag::warn_cxx11_compat_constexpr_body_no_return
2060  : diag::err_constexpr_body_no_return);
2061  if (!OK)
2062  return false;
2063  } else if (ReturnStmts.size() > 1) {
2064  Diag(ReturnStmts.back(),
2065  getLangOpts().CPlusPlus14
2066  ? diag::warn_cxx11_compat_constexpr_body_multiple_return
2067  : diag::ext_constexpr_body_multiple_return);
2068  for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
2069  Diag(ReturnStmts[I], diag::note_constexpr_body_previous_return);
2070  }
2071  }
2072 
2073  // C++11 [dcl.constexpr]p5:
2074  // if no function argument values exist such that the function invocation
2075  // substitution would produce a constant expression, the program is
2076  // ill-formed; no diagnostic required.
2077  // C++11 [dcl.constexpr]p3:
2078  // - every constructor call and implicit conversion used in initializing the
2079  // return value shall be one of those allowed in a constant expression.
2080  // C++11 [dcl.constexpr]p4:
2081  // - every constructor involved in initializing non-static data members and
2082  // base class sub-objects shall be a constexpr constructor.
2084  if (!Expr::isPotentialConstantExpr(Dcl, Diags)) {
2085  Diag(Dcl->getLocation(), diag::ext_constexpr_function_never_constant_expr)
2086  << isa<CXXConstructorDecl>(Dcl);
2087  for (size_t I = 0, N = Diags.size(); I != N; ++I)
2088  Diag(Diags[I].first, Diags[I].second);
2089  // Don't return false here: we allow this for compatibility in
2090  // system headers.
2091  }
2092 
2093  return true;
2094 }
2095 
2096 /// Get the class that is directly named by the current context. This is the
2097 /// class for which an unqualified-id in this scope could name a constructor
2098 /// or destructor.
2099 ///
2100 /// If the scope specifier denotes a class, this will be that class.
2101 /// If the scope specifier is empty, this will be the class whose
2102 /// member-specification we are currently within. Otherwise, there
2103 /// is no such class.
2105  assert(getLangOpts().CPlusPlus && "No class names in C!");
2106 
2107  if (SS && SS->isInvalid())
2108  return nullptr;
2109 
2110  if (SS && SS->isNotEmpty()) {
2111  DeclContext *DC = computeDeclContext(*SS, true);
2112  return dyn_cast_or_null<CXXRecordDecl>(DC);
2113  }
2114 
2115  return dyn_cast_or_null<CXXRecordDecl>(CurContext);
2116 }
2117 
2118 /// isCurrentClassName - Determine whether the identifier II is the
2119 /// name of the class type currently being defined. In the case of
2120 /// nested classes, this will only return true if II is the name of
2121 /// the innermost class.
2123  const CXXScopeSpec *SS) {
2124  CXXRecordDecl *CurDecl = getCurrentClass(S, SS);
2125  return CurDecl && &II == CurDecl->getIdentifier();
2126 }
2127 
2128 /// Determine whether the identifier II is a typo for the name of
2129 /// the class type currently being defined. If so, update it to the identifier
2130 /// that should have been used.
2132  assert(getLangOpts().CPlusPlus && "No class names in C!");
2133 
2134  if (!getLangOpts().SpellChecking)
2135  return false;
2136 
2137  CXXRecordDecl *CurDecl;
2138  if (SS && SS->isSet() && !SS->isInvalid()) {
2139  DeclContext *DC = computeDeclContext(*SS, true);
2140  CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
2141  } else
2142  CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
2143 
2144  if (CurDecl && CurDecl->getIdentifier() && II != CurDecl->getIdentifier() &&
2145  3 * II->getName().edit_distance(CurDecl->getIdentifier()->getName())
2146  < II->getLength()) {
2147  II = CurDecl->getIdentifier();
2148  return true;
2149  }
2150 
2151  return false;
2152 }
2153 
2154 /// Determine whether the given class is a base class of the given
2155 /// class, including looking at dependent bases.
2156 static bool findCircularInheritance(const CXXRecordDecl *Class,
2157  const CXXRecordDecl *Current) {
2159 
2160  Class = Class->getCanonicalDecl();
2161  while (true) {
2162  for (const auto &I : Current->bases()) {
2163  CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl();
2164  if (!Base)
2165  continue;
2166 
2167  Base = Base->getDefinition();
2168  if (!Base)
2169  continue;
2170 
2171  if (Base->getCanonicalDecl() == Class)
2172  return true;
2173 
2174  Queue.push_back(Base);
2175  }
2176 
2177  if (Queue.empty())
2178  return false;
2179 
2180  Current = Queue.pop_back_val();
2181  }
2182 
2183  return false;
2184 }
2185 
2186 /// Check the validity of a C++ base class specifier.
2187 ///
2188 /// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
2189 /// and returns NULL otherwise.
2192  SourceRange SpecifierRange,
2193  bool Virtual, AccessSpecifier Access,
2194  TypeSourceInfo *TInfo,
2195  SourceLocation EllipsisLoc) {
2196  QualType BaseType = TInfo->getType();
2197 
2198  // C++ [class.union]p1:
2199  // A union shall not have base classes.
2200  if (Class->isUnion()) {
2201  Diag(Class->getLocation(), diag::err_base_clause_on_union)
2202  << SpecifierRange;
2203  return nullptr;
2204  }
2205 
2206  if (EllipsisLoc.isValid() &&
2208  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
2209  << TInfo->getTypeLoc().getSourceRange();
2210  EllipsisLoc = SourceLocation();
2211  }
2212 
2213  SourceLocation BaseLoc = TInfo->getTypeLoc().getBeginLoc();
2214 
2215  if (BaseType->isDependentType()) {
2216  // Make sure that we don't have circular inheritance among our dependent
2217  // bases. For non-dependent bases, the check for completeness below handles
2218  // this.
2219  if (CXXRecordDecl *BaseDecl = BaseType->getAsCXXRecordDecl()) {
2220  if (BaseDecl->getCanonicalDecl() == Class->getCanonicalDecl() ||
2221  ((BaseDecl = BaseDecl->getDefinition()) &&
2222  findCircularInheritance(Class, BaseDecl))) {
2223  Diag(BaseLoc, diag::err_circular_inheritance)
2224  << BaseType << Context.getTypeDeclType(Class);
2225 
2226  if (BaseDecl->getCanonicalDecl() != Class->getCanonicalDecl())
2227  Diag(BaseDecl->getLocation(), diag::note_previous_decl)
2228  << BaseType;
2229 
2230  return nullptr;
2231  }
2232  }
2233 
2234  return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
2235  Class->getTagKind() == TTK_Class,
2236  Access, TInfo, EllipsisLoc);
2237  }
2238 
2239  // Base specifiers must be record types.
2240  if (!BaseType->isRecordType()) {
2241  Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
2242  return nullptr;
2243  }
2244 
2245  // C++ [class.union]p1:
2246  // A union shall not be used as a base class.
2247  if (BaseType->isUnionType()) {
2248  Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
2249  return nullptr;
2250  }
2251 
2252  // For the MS ABI, propagate DLL attributes to base class templates.
2253  if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
2254  if (Attr *ClassAttr = getDLLAttr(Class)) {
2255  if (auto *BaseTemplate = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
2256  BaseType->getAsCXXRecordDecl())) {
2257  propagateDLLAttrToBaseClassTemplate(Class, ClassAttr, BaseTemplate,
2258  BaseLoc);
2259  }
2260  }
2261  }
2262 
2263  // C++ [class.derived]p2:
2264  // The class-name in a base-specifier shall not be an incompletely
2265  // defined class.
2266  if (RequireCompleteType(BaseLoc, BaseType,
2267  diag::err_incomplete_base_class, SpecifierRange)) {
2268  Class->setInvalidDecl();
2269  return nullptr;
2270  }
2271 
2272  // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
2273  RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl();
2274  assert(BaseDecl && "Record type has no declaration");
2275  BaseDecl = BaseDecl->getDefinition();
2276  assert(BaseDecl && "Base type is not incomplete, but has no definition");
2277  CXXRecordDecl *CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
2278  assert(CXXBaseDecl && "Base type is not a C++ type");
2279 
2280  // Microsoft docs say:
2281  // "If a base-class has a code_seg attribute, derived classes must have the
2282  // same attribute."
2283  const auto *BaseCSA = CXXBaseDecl->getAttr<CodeSegAttr>();
2284  const auto *DerivedCSA = Class->getAttr<CodeSegAttr>();
2285  if ((DerivedCSA || BaseCSA) &&
2286  (!BaseCSA || !DerivedCSA || BaseCSA->getName() != DerivedCSA->getName())) {
2287  Diag(Class->getLocation(), diag::err_mismatched_code_seg_base);
2288  Diag(CXXBaseDecl->getLocation(), diag::note_base_class_specified_here)
2289  << CXXBaseDecl;
2290  return nullptr;
2291  }
2292 
2293  // A class which contains a flexible array member is not suitable for use as a
2294  // base class:
2295  // - If the layout determines that a base comes before another base,
2296  // the flexible array member would index into the subsequent base.
2297  // - If the layout determines that base comes before the derived class,
2298  // the flexible array member would index into the derived class.
2299  if (CXXBaseDecl->hasFlexibleArrayMember()) {
2300  Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
2301  << CXXBaseDecl->getDeclName();
2302  return nullptr;
2303  }
2304 
2305  // C++ [class]p3:
2306  // If a class is marked final and it appears as a base-type-specifier in
2307  // base-clause, the program is ill-formed.
2308  if (FinalAttr *FA = CXXBaseDecl->getAttr<FinalAttr>()) {
2309  Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
2310  << CXXBaseDecl->getDeclName()
2311  << FA->isSpelledAsSealed();
2312  Diag(CXXBaseDecl->getLocation(), diag::note_entity_declared_at)
2313  << CXXBaseDecl->getDeclName() << FA->getRange();
2314  return nullptr;
2315  }
2316 
2317  if (BaseDecl->isInvalidDecl())
2318  Class->setInvalidDecl();
2319 
2320  // Create the base specifier.
2321  return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
2322  Class->getTagKind() == TTK_Class,
2323  Access, TInfo, EllipsisLoc);
2324 }
2325 
2326 /// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
2327 /// one entry in the base class list of a class specifier, for
2328 /// example:
2329 /// class foo : public bar, virtual private baz {
2330 /// 'public bar' and 'virtual private baz' are each base-specifiers.
2331 BaseResult
2332 Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange,
2333  ParsedAttributes &Attributes,
2334  bool Virtual, AccessSpecifier Access,
2335  ParsedType basetype, SourceLocation BaseLoc,
2336  SourceLocation EllipsisLoc) {
2337  if (!classdecl)
2338  return true;
2339 
2340  AdjustDeclIfTemplate(classdecl);
2341  CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl);
2342  if (!Class)
2343  return true;
2344 
2345  // We haven't yet attached the base specifiers.
2346  Class->setIsParsingBaseSpecifiers();
2347 
2348  // We do not support any C++11 attributes on base-specifiers yet.
2349  // Diagnose any attributes we see.
2350  for (const ParsedAttr &AL : Attributes) {
2351  if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute)
2352  continue;
2353  Diag(AL.getLoc(), AL.getKind() == ParsedAttr::UnknownAttribute
2354  ? (unsigned)diag::warn_unknown_attribute_ignored
2355  : (unsigned)diag::err_base_specifier_attribute)
2356  << AL.getName();
2357  }
2358 
2359  TypeSourceInfo *TInfo = nullptr;
2360  GetTypeFromParser(basetype, &TInfo);
2361 
2362  if (EllipsisLoc.isInvalid() &&
2363  DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo,
2364  UPPC_BaseType))
2365  return true;
2366 
2367  if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
2368  Virtual, Access, TInfo,
2369  EllipsisLoc))
2370  return BaseSpec;
2371  else
2372  Class->setInvalidDecl();
2373 
2374  return true;
2375 }
2376 
2377 /// Use small set to collect indirect bases. As this is only used
2378 /// locally, there's no need to abstract the small size parameter.
2379 typedef llvm::SmallPtrSet<QualType, 4> IndirectBaseSet;
2380 
2381 /// Recursively add the bases of Type. Don't add Type itself.
2382 static void
2383 NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set,
2384  const QualType &Type)
2385 {
2386  // Even though the incoming type is a base, it might not be
2387  // a class -- it could be a template parm, for instance.
2388  if (auto Rec = Type->getAs<RecordType>()) {
2389  auto Decl = Rec->getAsCXXRecordDecl();
2390 
2391  // Iterate over its bases.
2392  for (const auto &BaseSpec : Decl->bases()) {
2393  QualType Base = Context.getCanonicalType(BaseSpec.getType())
2394  .getUnqualifiedType();
2395  if (Set.insert(Base).second)
2396  // If we've not already seen it, recurse.
2397  NoteIndirectBases(Context, Set, Base);
2398  }
2399  }
2400 }
2401 
2402 /// Performs the actual work of attaching the given base class
2403 /// specifiers to a C++ class.
2406  if (Bases.empty())
2407  return false;
2408 
2409  // Used to keep track of which base types we have already seen, so
2410  // that we can properly diagnose redundant direct base types. Note
2411  // that the key is always the unqualified canonical type of the base
2412  // class.
2413  std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
2414 
2415  // Used to track indirect bases so we can see if a direct base is
2416  // ambiguous.
2417  IndirectBaseSet IndirectBaseTypes;
2418 
2419  // Copy non-redundant base specifiers into permanent storage.
2420  unsigned NumGoodBases = 0;
2421  bool Invalid = false;
2422  for (unsigned idx = 0; idx < Bases.size(); ++idx) {
2423  QualType NewBaseType
2424  = Context.getCanonicalType(Bases[idx]->getType());
2425  NewBaseType = NewBaseType.getLocalUnqualifiedType();
2426 
2427  CXXBaseSpecifier *&KnownBase = KnownBaseTypes[NewBaseType];
2428  if (KnownBase) {
2429  // C++ [class.mi]p3:
2430  // A class shall not be specified as a direct base class of a
2431  // derived class more than once.
2432  Diag(Bases[idx]->getBeginLoc(), diag::err_duplicate_base_class)
2433  << KnownBase->getType() << Bases[idx]->getSourceRange();
2434 
2435  // Delete the duplicate base class specifier; we're going to
2436  // overwrite its pointer later.
2437  Context.Deallocate(Bases[idx]);
2438 
2439  Invalid = true;
2440  } else {
2441  // Okay, add this new base class.
2442  KnownBase = Bases[idx];
2443  Bases[NumGoodBases++] = Bases[idx];
2444 
2445  // Note this base's direct & indirect bases, if there could be ambiguity.
2446  if (Bases.size() > 1)
2447  NoteIndirectBases(Context, IndirectBaseTypes, NewBaseType);
2448 
2449  if (const RecordType *Record = NewBaseType->getAs<RecordType>()) {
2450  const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
2451  if (Class->isInterface() &&
2452  (!RD->isInterfaceLike() ||
2453  KnownBase->getAccessSpecifier() != AS_public)) {
2454  // The Microsoft extension __interface does not permit bases that
2455  // are not themselves public interfaces.
2456  Diag(KnownBase->getBeginLoc(), diag::err_invalid_base_in_interface)
2457  << getRecordDiagFromTagKind(RD->getTagKind()) << RD
2458  << RD->getSourceRange();
2459  Invalid = true;
2460  }
2461  if (RD->hasAttr<WeakAttr>())
2462  Class->addAttr(WeakAttr::CreateImplicit(Context));
2463  }
2464  }
2465  }
2466 
2467  // Attach the remaining base class specifiers to the derived class.
2468  Class->setBases(Bases.data(), NumGoodBases);
2469 
2470  // Check that the only base classes that are duplicate are virtual.
2471  for (unsigned idx = 0; idx < NumGoodBases; ++idx) {
2472  // Check whether this direct base is inaccessible due to ambiguity.
2473  QualType BaseType = Bases[idx]->getType();
2474 
2475  // Skip all dependent types in templates being used as base specifiers.
2476  // Checks below assume that the base specifier is a CXXRecord.
2477  if (BaseType->isDependentType())
2478  continue;
2479 
2480  CanQualType CanonicalBase = Context.getCanonicalType(BaseType)
2481  .getUnqualifiedType();
2482 
2483  if (IndirectBaseTypes.count(CanonicalBase)) {
2484  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2485  /*DetectVirtual=*/true);
2486  bool found
2487  = Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
2488  assert(found);
2489  (void)found;
2490 
2491  if (Paths.isAmbiguous(CanonicalBase))
2492  Diag(Bases[idx]->getBeginLoc(), diag::warn_inaccessible_base_class)
2493  << BaseType << getAmbiguousPathsDisplayString(Paths)
2494  << Bases[idx]->getSourceRange();
2495  else
2496  assert(Bases[idx]->isVirtual());
2497  }
2498 
2499  // Delete the base class specifier, since its data has been copied
2500  // into the CXXRecordDecl.
2501  Context.Deallocate(Bases[idx]);
2502  }
2503 
2504  return Invalid;
2505 }
2506 
2507 /// ActOnBaseSpecifiers - Attach the given base specifiers to the
2508 /// class, after checking whether there are any duplicate base
2509 /// classes.
2510 void Sema::ActOnBaseSpecifiers(Decl *ClassDecl,
2512  if (!ClassDecl || Bases.empty())
2513  return;
2514 
2515  AdjustDeclIfTemplate(ClassDecl);
2516  AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), Bases);
2517 }
2518 
2519 /// Determine whether the type \p Derived is a C++ class that is
2520 /// derived from the type \p Base.
2522  if (!getLangOpts().CPlusPlus)
2523  return false;
2524 
2525  CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
2526  if (!DerivedRD)
2527  return false;
2528 
2529  CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
2530  if (!BaseRD)
2531  return false;
2532 
2533  // If either the base or the derived type is invalid, don't try to
2534  // check whether one is derived from the other.
2535  if (BaseRD->isInvalidDecl() || DerivedRD->isInvalidDecl())
2536  return false;
2537 
2538  // FIXME: In a modules build, do we need the entire path to be visible for us
2539  // to be able to use the inheritance relationship?
2540  if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
2541  return false;
2542 
2543  return DerivedRD->isDerivedFrom(BaseRD);
2544 }
2545 
2546 /// Determine whether the type \p Derived is a C++ class that is
2547 /// derived from the type \p Base.
2549  CXXBasePaths &Paths) {
2550  if (!getLangOpts().CPlusPlus)
2551  return false;
2552 
2553  CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
2554  if (!DerivedRD)
2555  return false;
2556 
2557  CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
2558  if (!BaseRD)
2559  return false;
2560 
2561  if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
2562  return false;
2563 
2564  return DerivedRD->isDerivedFrom(BaseRD, Paths);
2565 }
2566 
2567 static void BuildBasePathArray(const CXXBasePath &Path,
2568  CXXCastPath &BasePathArray) {
2569  // We first go backward and check if we have a virtual base.
2570  // FIXME: It would be better if CXXBasePath had the base specifier for
2571  // the nearest virtual base.
2572  unsigned Start = 0;
2573  for (unsigned I = Path.size(); I != 0; --I) {
2574  if (Path[I - 1].Base->isVirtual()) {
2575  Start = I - 1;
2576  break;
2577  }
2578  }
2579 
2580  // Now add all bases.
2581  for (unsigned I = Start, E = Path.size(); I != E; ++I)
2582  BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
2583 }
2584 
2585 
2587  CXXCastPath &BasePathArray) {
2588  assert(BasePathArray.empty() && "Base path array must be empty!");
2589  assert(Paths.isRecordingPaths() && "Must record paths!");
2590  return ::BuildBasePathArray(Paths.front(), BasePathArray);
2591 }
2592 /// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
2593 /// conversion (where Derived and Base are class types) is
2594 /// well-formed, meaning that the conversion is unambiguous (and
2595 /// that all of the base classes are accessible). Returns true
2596 /// and emits a diagnostic if the code is ill-formed, returns false
2597 /// otherwise. Loc is the location where this routine should point to
2598 /// if there is an error, and Range is the source range to highlight
2599 /// if there is an error.
2600 ///
2601 /// If either InaccessibleBaseID or AmbigiousBaseConvID are 0, then the
2602 /// diagnostic for the respective type of error will be suppressed, but the
2603 /// check for ill-formed code will still be performed.
2604 bool
2606  unsigned InaccessibleBaseID,
2607  unsigned AmbigiousBaseConvID,
2608  SourceLocation Loc, SourceRange Range,
2609  DeclarationName Name,
2610  CXXCastPath *BasePath,
2611  bool IgnoreAccess) {
2612  // First, determine whether the path from Derived to Base is
2613  // ambiguous. This is slightly more expensive than checking whether
2614  // the Derived to Base conversion exists, because here we need to
2615  // explore multiple paths to determine if there is an ambiguity.
2616  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2617  /*DetectVirtual=*/false);
2618  bool DerivationOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
2619  if (!DerivationOkay)
2620  return true;
2621 
2622  const CXXBasePath *Path = nullptr;
2623  if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType()))
2624  Path = &Paths.front();
2625 
2626  // For MSVC compatibility, check if Derived directly inherits from Base. Clang
2627  // warns about this hierarchy under -Winaccessible-base, but MSVC allows the
2628  // user to access such bases.
2629  if (!Path && getLangOpts().MSVCCompat) {
2630  for (const CXXBasePath &PossiblePath : Paths) {
2631  if (PossiblePath.size() == 1) {
2632  Path = &PossiblePath;
2633  if (AmbigiousBaseConvID)
2634  Diag(Loc, diag::ext_ms_ambiguous_direct_base)
2635  << Base << Derived << Range;
2636  break;
2637  }
2638  }
2639  }
2640 
2641  if (Path) {
2642  if (!IgnoreAccess) {
2643  // Check that the base class can be accessed.
2644  switch (
2645  CheckBaseClassAccess(Loc, Base, Derived, *Path, InaccessibleBaseID)) {
2646  case AR_inaccessible:
2647  return true;
2648  case AR_accessible:
2649  case AR_dependent:
2650  case AR_delayed:
2651  break;
2652  }
2653  }
2654 
2655  // Build a base path if necessary.
2656  if (BasePath)
2657  ::BuildBasePathArray(*Path, *BasePath);
2658  return false;
2659  }
2660 
2661  if (AmbigiousBaseConvID) {
2662  // We know that the derived-to-base conversion is ambiguous, and
2663  // we're going to produce a diagnostic. Perform the derived-to-base
2664  // search just one more time to compute all of the possible paths so
2665  // that we can print them out. This is more expensive than any of
2666  // the previous derived-to-base checks we've done, but at this point
2667  // performance isn't as much of an issue.
2668  Paths.clear();
2669  Paths.setRecordingPaths(true);
2670  bool StillOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
2671  assert(StillOkay && "Can only be used with a derived-to-base conversion");
2672  (void)StillOkay;
2673 
2674  // Build up a textual representation of the ambiguous paths, e.g.,
2675  // D -> B -> A, that will be used to illustrate the ambiguous
2676  // conversions in the diagnostic. We only print one of the paths
2677  // to each base class subobject.
2678  std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
2679 
2680  Diag(Loc, AmbigiousBaseConvID)
2681  << Derived << Base << PathDisplayStr << Range << Name;
2682  }
2683  return true;
2684 }
2685 
2686 bool
2688  SourceLocation Loc, SourceRange Range,
2689  CXXCastPath *BasePath,
2690  bool IgnoreAccess) {
2691  return CheckDerivedToBaseConversion(
2692  Derived, Base, diag::err_upcast_to_inaccessible_base,
2693  diag::err_ambiguous_derived_to_base_conv, Loc, Range, DeclarationName(),
2694  BasePath, IgnoreAccess);
2695 }
2696 
2697 
2698 /// Builds a string representing ambiguous paths from a
2699 /// specific derived class to different subobjects of the same base
2700 /// class.
2701 ///
2702 /// This function builds a string that can be used in error messages
2703 /// to show the different paths that one can take through the
2704 /// inheritance hierarchy to go from the derived class to different
2705 /// subobjects of a base class. The result looks something like this:
2706 /// @code
2707 /// struct D -> struct B -> struct A
2708 /// struct D -> struct C -> struct A
2709 /// @endcode
2711  std::string PathDisplayStr;
2712  std::set<unsigned> DisplayedPaths;
2713  for (CXXBasePaths::paths_iterator Path = Paths.begin();
2714  Path != Paths.end(); ++Path) {
2715  if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
2716  // We haven't displayed a path to this particular base
2717  // class subobject yet.
2718  PathDisplayStr += "\n ";
2719  PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
2720  for (CXXBasePath::const_iterator Element = Path->begin();
2721  Element != Path->end(); ++Element)
2722  PathDisplayStr += " -> " + Element->Base->getType().getAsString();
2723  }
2724  }
2725 
2726  return PathDisplayStr;
2727 }
2728 
2729 //===----------------------------------------------------------------------===//
2730 // C++ class member Handling
2731 //===----------------------------------------------------------------------===//
2732 
2733 /// ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
2736  const ParsedAttributesView &Attrs) {
2737  assert(Access != AS_none && "Invalid kind for syntactic access specifier!");
2738  AccessSpecDecl *ASDecl = AccessSpecDecl::Create(Context, Access, CurContext,
2739  ASLoc, ColonLoc);
2740  CurContext->addHiddenDecl(ASDecl);
2741  return ProcessAccessDeclAttributeList(ASDecl, Attrs);
2742 }
2743 
2744 /// CheckOverrideControl - Check C++11 override control semantics.
2746  if (D->isInvalidDecl())
2747  return;
2748 
2749  // We only care about "override" and "final" declarations.
2750  if (!D->hasAttr<OverrideAttr>() && !D->hasAttr<FinalAttr>())
2751  return;
2752 
2753  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
2754 
2755  // We can't check dependent instance methods.
2756  if (MD && MD->isInstance() &&
2757  (MD->getParent()->hasAnyDependentBases() ||
2758  MD->getType()->isDependentType()))
2759  return;
2760 
2761  if (MD && !MD->isVirtual()) {
2762  // If we have a non-virtual method, check if if hides a virtual method.
2763  // (In that case, it's most likely the method has the wrong type.)
2764  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
2765  FindHiddenVirtualMethods(MD, OverloadedMethods);
2766 
2767  if (!OverloadedMethods.empty()) {
2768  if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
2769  Diag(OA->getLocation(),
2770  diag::override_keyword_hides_virtual_member_function)
2771  << "override" << (OverloadedMethods.size() > 1);
2772  } else if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
2773  Diag(FA->getLocation(),
2774  diag::override_keyword_hides_virtual_member_function)
2775  << (FA->isSpelledAsSealed() ? "sealed" : "final")
2776  << (OverloadedMethods.size() > 1);
2777  }
2778  NoteHiddenVirtualMethods(MD, OverloadedMethods);
2779  MD->setInvalidDecl();
2780  return;
2781  }
2782  // Fall through into the general case diagnostic.
2783  // FIXME: We might want to attempt typo correction here.
2784  }
2785 
2786  if (!MD || !MD->isVirtual()) {
2787  if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
2788  Diag(OA->getLocation(),
2789  diag::override_keyword_only_allowed_on_virtual_member_functions)
2790  << "override" << FixItHint::CreateRemoval(OA->getLocation());
2791  D->dropAttr<OverrideAttr>();
2792  }
2793  if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
2794  Diag(FA->getLocation(),
2795  diag::override_keyword_only_allowed_on_virtual_member_functions)
2796  << (FA->isSpelledAsSealed() ? "sealed" : "final")
2797  << FixItHint::CreateRemoval(FA->getLocation());
2798  D->dropAttr<FinalAttr>();
2799  }
2800  return;
2801  }
2802 
2803  // C++11 [class.virtual]p5:
2804  // If a function is marked with the virt-specifier override and
2805  // does not override a member function of a base class, the program is
2806  // ill-formed.
2807  bool HasOverriddenMethods = MD->size_overridden_methods() != 0;
2808  if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)
2809  Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding)
2810  << MD->getDeclName();
2811 }
2812 
2814  if (D->isInvalidDecl() || D->hasAttr<OverrideAttr>())
2815  return;
2816  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
2817  if (!MD || MD->isImplicit() || MD->hasAttr<FinalAttr>())
2818  return;
2819 
2820  SourceLocation Loc = MD->getLocation();
2821  SourceLocation SpellingLoc = Loc;
2822  if (getSourceManager().isMacroArgExpansion(Loc))
2823  SpellingLoc = getSourceManager().getImmediateExpansionRange(Loc).getBegin();
2824  SpellingLoc = getSourceManager().getSpellingLoc(SpellingLoc);
2825  if (SpellingLoc.isValid() && getSourceManager().isInSystemHeader(SpellingLoc))
2826  return;
2827 
2828  if (MD->size_overridden_methods() > 0) {
2829  unsigned DiagID = isa<CXXDestructorDecl>(MD)
2830  ? diag::warn_destructor_marked_not_override_overriding
2831  : diag::warn_function_marked_not_override_overriding;
2832  Diag(MD->getLocation(), DiagID) << MD->getDeclName();
2833  const CXXMethodDecl *OMD = *MD->begin_overridden_methods();
2834  Diag(OMD->getLocation(), diag::note_overridden_virtual_function);
2835  }
2836 }
2837 
2838 /// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member
2839 /// function overrides a virtual member function marked 'final', according to
2840 /// C++11 [class.virtual]p4.
2842  const CXXMethodDecl *Old) {
2843  FinalAttr *FA = Old->getAttr<FinalAttr>();
2844  if (!FA)
2845  return false;
2846 
2847  Diag(New->getLocation(), diag::err_final_function_overridden)
2848  << New->getDeclName()
2849  << FA->isSpelledAsSealed();
2850  Diag(Old->getLocation(), diag::note_overridden_virtual_function);
2851  return true;
2852 }
2853 
2854 static bool InitializationHasSideEffects(const FieldDecl &FD) {
2855  const Type *T = FD.getType()->getBaseElementTypeUnsafe();
2856  // FIXME: Destruction of ObjC lifetime types has side-effects.
2857  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
2858  return !RD->isCompleteDefinition() ||
2859  !RD->hasTrivialDefaultConstructor() ||
2860  !RD->hasTrivialDestructor();
2861  return false;
2862 }
2863 
2866  llvm::find_if(list, [](const ParsedAttr &AL) {
2867  return AL.isDeclspecPropertyAttribute();
2868  });
2869  if (Itr != list.end())
2870  return &*Itr;
2871  return nullptr;
2872 }
2873 
2874 // Check if there is a field shadowing.
2875 void Sema::CheckShadowInheritedFields(const SourceLocation &Loc,
2876  DeclarationName FieldName,
2877  const CXXRecordDecl *RD,
2878  bool DeclIsField) {
2879  if (Diags.isIgnored(diag::warn_shadow_field, Loc))
2880  return;
2881 
2882  // To record a shadowed field in a base
2883  std::map<CXXRecordDecl*, NamedDecl*> Bases;
2884  auto FieldShadowed = [&](const CXXBaseSpecifier *Specifier,
2885  CXXBasePath &Path) {
2886  const auto Base = Specifier->getType()->getAsCXXRecordDecl();
2887  // Record an ambiguous path directly
2888  if (Bases.find(Base) != Bases.end())
2889  return true;
2890  for (const auto Field : Base->lookup(FieldName)) {
2891  if ((isa<FieldDecl>(Field) || isa<IndirectFieldDecl>(Field)) &&
2892  Field->getAccess() != AS_private) {
2893  assert(Field->getAccess() != AS_none);
2894  assert(Bases.find(Base) == Bases.end());
2895  Bases[Base] = Field;
2896  return true;
2897  }
2898  }
2899  return false;
2900  };
2901 
2902  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2903  /*DetectVirtual=*/true);
2904  if (!RD->lookupInBases(FieldShadowed, Paths))
2905  return;
2906 
2907  for (const auto &P : Paths) {
2908  auto Base = P.back().Base->getType()->getAsCXXRecordDecl();
2909  auto It = Bases.find(Base);
2910  // Skip duplicated bases
2911  if (It == Bases.end())
2912  continue;
2913  auto BaseField = It->second;
2914  assert(BaseField->getAccess() != AS_private);
2915  if (AS_none !=
2916  CXXRecordDecl::MergeAccess(P.Access, BaseField->getAccess())) {
2917  Diag(Loc, diag::warn_shadow_field)
2918  << FieldName << RD << Base << DeclIsField;
2919  Diag(BaseField->getLocation(), diag::note_shadow_field);
2920  Bases.erase(It);
2921  }
2922  }
2923 }
2924 
2925 /// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
2926 /// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
2927 /// bitfield width if there is one, 'InitExpr' specifies the initializer if
2928 /// one has been parsed, and 'InitStyle' is set if an in-class initializer is
2929 /// present (but parsing it has been deferred).
2930 NamedDecl *
2932  MultiTemplateParamsArg TemplateParameterLists,
2933  Expr *BW, const VirtSpecifiers &VS,
2934  InClassInitStyle InitStyle) {
2935  const DeclSpec &DS = D.getDeclSpec();
2936  DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
2937  DeclarationName Name = NameInfo.getName();
2938  SourceLocation Loc = NameInfo.getLoc();
2939 
2940  // For anonymous bitfields, the location should point to the type.
2941  if (Loc.isInvalid())
2942  Loc = D.getBeginLoc();
2943 
2944  Expr *BitWidth = static_cast<Expr*>(BW);
2945 
2946  assert(isa<CXXRecordDecl>(CurContext));
2947  assert(!DS.isFriendSpecified());
2948 
2949  bool isFunc = D.isDeclarationOfFunction();
2950  const ParsedAttr *MSPropertyAttr =
2952 
2953  if (cast<CXXRecordDecl>(CurContext)->isInterface()) {
2954  // The Microsoft extension __interface only permits public member functions
2955  // and prohibits constructors, destructors, operators, non-public member
2956  // functions, static methods and data members.
2957  unsigned InvalidDecl;
2958  bool ShowDeclName = true;
2959  if (!isFunc &&
2960  (DS.getStorageClassSpec() == DeclSpec::SCS_typedef || MSPropertyAttr))
2961  InvalidDecl = 0;
2962  else if (!isFunc)
2963  InvalidDecl = 1;
2964  else if (AS != AS_public)
2965  InvalidDecl = 2;
2966  else if (DS.getStorageClassSpec() == DeclSpec::SCS_static)
2967  InvalidDecl = 3;
2968  else switch (Name.getNameKind()) {
2970  InvalidDecl = 4;
2971  ShowDeclName = false;
2972  break;
2973 
2975  InvalidDecl = 5;
2976  ShowDeclName = false;
2977  break;
2978 
2981  InvalidDecl = 6;
2982  break;
2983 
2984  default:
2985  InvalidDecl = 0;
2986  break;
2987  }
2988 
2989  if (InvalidDecl) {
2990  if (ShowDeclName)
2991  Diag(Loc, diag::err_invalid_member_in_interface)
2992  << (InvalidDecl-1) << Name;
2993  else
2994  Diag(Loc, diag::err_invalid_member_in_interface)
2995  << (InvalidDecl-1) << "";
2996  return nullptr;
2997  }
2998  }
2999 
3000  // C++ 9.2p6: A member shall not be declared to have automatic storage
3001  // duration (auto, register) or with the extern storage-class-specifier.
3002  // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
3003  // data members and cannot be applied to names declared const or static,
3004  // and cannot be applied to reference members.
3005  switch (DS.getStorageClassSpec()) {
3007  case DeclSpec::SCS_typedef:
3008  case DeclSpec::SCS_static:
3009  break;
3010  case DeclSpec::SCS_mutable:
3011  if (isFunc) {
3012  Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
3013 
3014  // FIXME: It would be nicer if the keyword was ignored only for this
3015  // declarator. Otherwise we could get follow-up errors.
3017  }
3018  break;
3019  default:
3021  diag::err_storageclass_invalid_for_member);
3023  break;
3024  }
3025 
3026  bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
3028  !isFunc);
3029 
3030  if (DS.isConstexprSpecified() && isInstField) {
3032  Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr_member);
3033  SourceLocation ConstexprLoc = DS.getConstexprSpecLoc();
3034  if (InitStyle == ICIS_NoInit) {
3035  B << 0 << 0;
3037  B << FixItHint::CreateRemoval(ConstexprLoc);
3038  else {
3039  B << FixItHint::CreateReplacement(ConstexprLoc, "const");
3041  const char *PrevSpec;
3042  unsigned DiagID;
3043  bool Failed = D.getMutableDeclSpec().SetTypeQual(
3044  DeclSpec::TQ_const, ConstexprLoc, PrevSpec, DiagID, getLangOpts());
3045  (void)Failed;
3046  assert(!Failed && "Making a constexpr member const shouldn't fail");
3047  }
3048  } else {
3049  B << 1;
3050  const char *PrevSpec;
3051  unsigned DiagID;
3053  *this, DeclSpec::SCS_static, ConstexprLoc, PrevSpec, DiagID,
3054  Context.getPrintingPolicy())) {
3055  assert(DS.getStorageClassSpec() == DeclSpec::SCS_mutable &&
3056  "This is the only DeclSpec that should fail to be applied");
3057  B << 1;
3058  } else {
3059  B << 0 << FixItHint::CreateInsertion(ConstexprLoc, "static ");
3060  isInstField = false;
3061  }
3062  }
3063  }
3064 
3065  NamedDecl *Member;
3066  if (isInstField) {
3067  CXXScopeSpec &SS = D.getCXXScopeSpec();
3068 
3069  // Data members must have identifiers for names.
3070  if (!Name.isIdentifier()) {
3071  Diag(Loc, diag::err_bad_variable_name)
3072  << Name;
3073  return nullptr;
3074  }
3075 
3076  IdentifierInfo *II = Name.getAsIdentifierInfo();
3077 
3078  // Member field could not be with "template" keyword.
3079  // So TemplateParameterLists should be empty in this case.
3080  if (TemplateParameterLists.size()) {
3081  TemplateParameterList* TemplateParams = TemplateParameterLists[0];
3082  if (TemplateParams->size()) {
3083  // There is no such thing as a member field template.
3084  Diag(D.getIdentifierLoc(), diag::err_template_member)
3085  << II
3086  << SourceRange(TemplateParams->getTemplateLoc(),
3087  TemplateParams->getRAngleLoc());
3088  } else {
3089  // There is an extraneous 'template<>' for this member.
3090  Diag(TemplateParams->getTemplateLoc(),
3091  diag::err_template_member_noparams)
3092  << II
3093  << SourceRange(TemplateParams->getTemplateLoc(),
3094  TemplateParams->getRAngleLoc());
3095  }
3096  return nullptr;
3097  }
3098 
3099  if (SS.isSet() && !SS.isInvalid()) {
3100  // The user provided a superfluous scope specifier inside a class
3101  // definition:
3102  //
3103  // class X {
3104  // int X::member;
3105  // };
3106  if (DeclContext *DC = computeDeclContext(SS, false))
3107  diagnoseQualifiedDeclaration(SS, DC, Name, D.getIdentifierLoc(),
3108  D.getName().getKind() ==
3110  else
3111  Diag(D.getIdentifierLoc(), diag::err_member_qualification)
3112  << Name << SS.getRange();
3113 
3114  SS.clear();
3115  }
3116 
3117  if (MSPropertyAttr) {
3118  Member = HandleMSProperty(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3119  BitWidth, InitStyle, AS, *MSPropertyAttr);
3120  if (!Member)
3121  return nullptr;
3122  isInstField = false;
3123  } else {
3124  Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3125  BitWidth, InitStyle, AS);
3126  if (!Member)
3127  return nullptr;
3128  }
3129 
3130  CheckShadowInheritedFields(Loc, Name, cast<CXXRecordDecl>(CurContext));
3131  } else {
3132  Member = HandleDeclarator(S, D, TemplateParameterLists);
3133  if (!Member)
3134  return nullptr;
3135 
3136  // Non-instance-fields can't have a bitfield.
3137  if (BitWidth) {
3138  if (Member->isInvalidDecl()) {
3139  // don't emit another diagnostic.
3140  } else if (isa<VarDecl>(Member) || isa<VarTemplateDecl>(Member)) {
3141  // C++ 9.6p3: A bit-field shall not be a static member.
3142  // "static member 'A' cannot be a bit-field"
3143  Diag(Loc, diag::err_static_not_bitfield)
3144  << Name << BitWidth->getSourceRange();
3145  } else if (isa<TypedefDecl>(Member)) {
3146  // "typedef member 'x' cannot be a bit-field"
3147  Diag(Loc, diag::err_typedef_not_bitfield)
3148  << Name << BitWidth->getSourceRange();
3149  } else {
3150  // A function typedef ("typedef int f(); f a;").
3151  // C++ 9.6p3: A bit-field shall have integral or enumeration type.
3152  Diag(Loc, diag::err_not_integral_type_bitfield)
3153  << Name << cast<ValueDecl>(Member)->getType()
3154  << BitWidth->getSourceRange();
3155  }
3156 
3157  BitWidth = nullptr;
3158  Member->setInvalidDecl();
3159  }
3160 
3161  NamedDecl *NonTemplateMember = Member;
3162  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
3163  NonTemplateMember = FunTmpl->getTemplatedDecl();
3164  else if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(Member))
3165  NonTemplateMember = VarTmpl->getTemplatedDecl();
3166 
3167  Member->setAccess(AS);
3168 
3169  // If we have declared a member function template or static data member
3170  // template, set the access of the templated declaration as well.
3171  if (NonTemplateMember != Member)
3172  NonTemplateMember->setAccess(AS);
3173 
3174  // C++ [temp.deduct.guide]p3:
3175  // A deduction guide [...] for a member class template [shall be
3176  // declared] with the same access [as the template].
3177  if (auto *DG = dyn_cast<CXXDeductionGuideDecl>(NonTemplateMember)) {
3178  auto *TD = DG->getDeducedTemplate();
3179  if (AS != TD->getAccess()) {
3180  Diag(DG->getBeginLoc(), diag::err_deduction_guide_wrong_access);
3181  Diag(TD->getBeginLoc(), diag::note_deduction_guide_template_access)
3182  << TD->getAccess();
3183  const AccessSpecDecl *LastAccessSpec = nullptr;
3184  for (const auto *D : cast<CXXRecordDecl>(CurContext)->decls()) {
3185  if (const auto *AccessSpec = dyn_cast<AccessSpecDecl>(D))
3186  LastAccessSpec = AccessSpec;
3187  }
3188  assert(LastAccessSpec && "differing access with no access specifier");
3189  Diag(LastAccessSpec->getBeginLoc(), diag::note_deduction_guide_access)
3190  << AS;
3191  }
3192  }
3193  }
3194 
3195  if (VS.isOverrideSpecified())
3196  Member->addAttr(new (Context) OverrideAttr(VS.getOverrideLoc(), Context, 0));
3197  if (VS.isFinalSpecified())
3198  Member->addAttr(new (Context) FinalAttr(VS.getFinalLoc(), Context,
3199  VS.isFinalSpelledSealed()));
3200 
3201  if (VS.getLastLocation().isValid()) {
3202  // Update the end location of a method that has a virt-specifiers.
3203  if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member))
3204  MD->setRangeEnd(VS.getLastLocation());
3205  }
3206 
3207  CheckOverrideControl(Member);
3208 
3209  assert((Name || isInstField) && "No identifier for non-field ?");
3210 
3211  if (isInstField) {
3212  FieldDecl *FD = cast<FieldDecl>(Member);
3213  FieldCollector->Add(FD);
3214 
3215  if (!Diags.isIgnored(diag::warn_unused_private_field, FD->getLocation())) {
3216  // Remember all explicit private FieldDecls that have a name, no side
3217  // effects and are not part of a dependent type declaration.
3218  if (!FD->isImplicit() && FD->getDeclName() &&
3219  FD->getAccess() == AS_private &&
3220  !FD->hasAttr<UnusedAttr>() &&
3221  !FD->getParent()->isDependentContext() &&
3223  UnusedPrivateFields.insert(FD);
3224  }
3225  }
3226 
3227  return Member;
3228 }
3229 
3230 namespace {
3231  class UninitializedFieldVisitor
3232  : public EvaluatedExprVisitor<UninitializedFieldVisitor> {
3233  Sema &S;
3234  // List of Decls to generate a warning on. Also remove Decls that become
3235  // initialized.
3236  llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
3237  // List of base classes of the record. Classes are removed after their
3238  // initializers.
3239  llvm::SmallPtrSetImpl<QualType> &BaseClasses;
3240  // Vector of decls to be removed from the Decl set prior to visiting the
3241  // nodes. These Decls may have been initialized in the prior initializer.
3242  llvm::SmallVector<ValueDecl*, 4> DeclsToRemove;
3243  // If non-null, add a note to the warning pointing back to the constructor.
3244  const CXXConstructorDecl *Constructor;
3245  // Variables to hold state when processing an initializer list. When
3246  // InitList is true, special case initialization of FieldDecls matching
3247  // InitListFieldDecl.
3248  bool InitList;
3249  FieldDecl *InitListFieldDecl;
3250  llvm::SmallVector<unsigned, 4> InitFieldIndex;
3251 
3252  public:
3254  UninitializedFieldVisitor(Sema &S,
3255  llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
3256  llvm::SmallPtrSetImpl<QualType> &BaseClasses)
3257  : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
3258  Constructor(nullptr), InitList(false), InitListFieldDecl(nullptr) {}
3259 
3260  // Returns true if the use of ME is not an uninitialized use.
3261  bool IsInitListMemberExprInitialized(MemberExpr *ME,
3262  bool CheckReferenceOnly) {
3264  bool ReferenceField = false;
3265  while (ME) {
3266  FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
3267  if (!FD)
3268  return false;
3269  Fields.push_back(FD);
3270  if (FD->getType()->isReferenceType())
3271  ReferenceField = true;
3272  ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParenImpCasts());
3273  }
3274 
3275  // Binding a reference to an uninitialized field is not an
3276  // uninitialized use.
3277  if (CheckReferenceOnly && !ReferenceField)
3278  return true;
3279 
3280  llvm::SmallVector<unsigned, 4> UsedFieldIndex;
3281  // Discard the first field since it is the field decl that is being
3282  // initialized.
3283  for (auto I = Fields.rbegin() + 1, E = Fields.rend(); I != E; ++I) {
3284  UsedFieldIndex.push_back((*I)->getFieldIndex());
3285  }
3286 
3287  for (auto UsedIter = UsedFieldIndex.begin(),
3288  UsedEnd = UsedFieldIndex.end(),
3289  OrigIter = InitFieldIndex.begin(),
3290  OrigEnd = InitFieldIndex.end();
3291  UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
3292  if (*UsedIter < *OrigIter)
3293  return true;
3294  if (*UsedIter > *OrigIter)
3295  break;
3296  }
3297 
3298  return false;
3299  }
3300 
3301  void HandleMemberExpr(MemberExpr *ME, bool CheckReferenceOnly,
3302  bool AddressOf) {
3303  if (isa<EnumConstantDecl>(ME->getMemberDecl()))
3304  return;
3305 
3306  // FieldME is the inner-most MemberExpr that is not an anonymous struct
3307  // or union.
3308  MemberExpr *FieldME = ME;
3309 
3310  bool AllPODFields = FieldME->getType().isPODType(S.Context);
3311 
3312  Expr *Base = ME;
3313  while (MemberExpr *SubME =
3314  dyn_cast<MemberExpr>(Base->IgnoreParenImpCasts())) {
3315 
3316  if (isa<VarDecl>(SubME->getMemberDecl()))
3317  return;
3318 
3319  if (FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
3320  if (!FD->isAnonymousStructOrUnion())
3321  FieldME = SubME;
3322 
3323  if (!FieldME->getType().isPODType(S.Context))
3324  AllPODFields = false;
3325 
3326  Base = SubME->getBase();
3327  }
3328 
3329  if (!isa<CXXThisExpr>(Base->IgnoreParenImpCasts()))
3330  return;
3331 
3332  if (AddressOf && AllPODFields)
3333  return;
3334 
3335  ValueDecl* FoundVD = FieldME->getMemberDecl();
3336 
3337  if (ImplicitCastExpr *BaseCast = dyn_cast<ImplicitCastExpr>(Base)) {
3338  while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
3339  BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
3340  }
3341 
3342  if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
3343  QualType T = BaseCast->getType();
3344  if (T->isPointerType() &&
3345  BaseClasses.count(T->getPointeeType())) {
3346  S.Diag(FieldME->getExprLoc(), diag::warn_base_class_is_uninit)
3347  << T->getPointeeType() << FoundVD;
3348  }
3349  }
3350  }
3351 
3352  if (!Decls.count(FoundVD))
3353  return;
3354 
3355  const bool IsReference = FoundVD->getType()->isReferenceType();
3356 
3357  if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
3358  // Special checking for initializer lists.
3359  if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
3360  return;
3361  }
3362  } else {
3363  // Prevent double warnings on use of unbounded references.
3364  if (CheckReferenceOnly && !IsReference)
3365  return;
3366  }
3367 
3368  unsigned diag = IsReference
3369  ? diag::warn_reference_field_is_uninit
3370  : diag::warn_field_is_uninit;
3371  S.Diag(FieldME->getExprLoc(), diag) << FoundVD;
3372  if (Constructor)
3373  S.Diag(Constructor->getLocation(),
3374  diag::note_uninit_in_this_constructor)
3375  << (Constructor->isDefaultConstructor() && Constructor->isImplicit());
3376 
3377  }
3378 
3379  void HandleValue(Expr *E, bool AddressOf) {
3380  E = E->IgnoreParens();
3381 
3382  if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
3383  HandleMemberExpr(ME, false /*CheckReferenceOnly*/,
3384  AddressOf /*AddressOf*/);
3385  return;
3386  }
3387 
3388  if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
3389  Visit(CO->getCond());
3390  HandleValue(CO->getTrueExpr(), AddressOf);
3391  HandleValue(CO->getFalseExpr(), AddressOf);
3392  return;
3393  }
3394 
3395  if (BinaryConditionalOperator *BCO =
3396  dyn_cast<BinaryConditionalOperator>(E)) {
3397  Visit(BCO->getCond());
3398  HandleValue(BCO->getFalseExpr(), AddressOf);
3399  return;
3400  }
3401 
3402  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
3403  HandleValue(OVE->getSourceExpr(), AddressOf);
3404  return;
3405  }
3406 
3407  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
3408  switch (BO->getOpcode()) {
3409  default:
3410  break;
3411  case(BO_PtrMemD):
3412  case(BO_PtrMemI):
3413  HandleValue(BO->getLHS(), AddressOf);
3414  Visit(BO->getRHS());
3415  return;
3416  case(BO_Comma):
3417  Visit(BO->getLHS());
3418  HandleValue(BO->getRHS(), AddressOf);
3419  return;
3420  }
3421  }
3422 
3423  Visit(E);
3424  }
3425 
3426  void CheckInitListExpr(InitListExpr *ILE) {
3427  InitFieldIndex.push_back(0);
3428  for (auto Child : ILE->children()) {
3429  if (InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
3430  CheckInitListExpr(SubList);
3431  } else {
3432  Visit(Child);
3433  }
3434  ++InitFieldIndex.back();
3435  }
3436  InitFieldIndex.pop_back();
3437  }
3438 
3439  void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor,
3440  FieldDecl *Field, const Type *BaseClass) {
3441  // Remove Decls that may have been initialized in the previous
3442  // initializer.
3443  for (ValueDecl* VD : DeclsToRemove)
3444  Decls.erase(VD);
3445  DeclsToRemove.clear();
3446 
3447  Constructor = FieldConstructor;
3448  InitListExpr *ILE = dyn_cast<InitListExpr>(E);
3449 
3450  if (ILE && Field) {
3451  InitList = true;
3452  InitListFieldDecl = Field;
3453  InitFieldIndex.clear();
3454  CheckInitListExpr(ILE);
3455  } else {
3456  InitList = false;
3457  Visit(E);
3458  }
3459 
3460  if (Field)
3461  Decls.erase(Field);
3462  if (BaseClass)
3463  BaseClasses.erase(BaseClass->getCanonicalTypeInternal());
3464  }
3465 
3466  void VisitMemberExpr(MemberExpr *ME) {
3467  // All uses of unbounded reference fields will warn.
3468  HandleMemberExpr(ME, true /*CheckReferenceOnly*/, false /*AddressOf*/);
3469  }
3470 
3471  void VisitImplicitCastExpr(ImplicitCastExpr *E) {
3472  if (E->getCastKind() == CK_LValueToRValue) {
3473  HandleValue(E->getSubExpr(), false /*AddressOf*/);
3474  return;
3475  }
3476 
3477  Inherited::VisitImplicitCastExpr(E);
3478  }
3479 
3480  void VisitCXXConstructExpr(CXXConstructExpr *E) {
3481  if (E->getConstructor()->isCopyConstructor()) {
3482  Expr *ArgExpr = E->getArg(0);
3483  if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
3484  if (ILE->getNumInits() == 1)
3485  ArgExpr = ILE->getInit(0);
3486  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
3487  if (ICE->getCastKind() == CK_NoOp)
3488  ArgExpr = ICE->getSubExpr();
3489  HandleValue(ArgExpr, false /*AddressOf*/);
3490  return;
3491  }
3492  Inherited::VisitCXXConstructExpr(E);
3493  }
3494 
3495  void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
3496  Expr *Callee = E->getCallee();
3497  if (isa<MemberExpr>(Callee)) {
3498  HandleValue(Callee, false /*AddressOf*/);
3499  for (auto Arg : E->arguments())
3500  Visit(Arg);
3501  return;
3502  }
3503 
3504  Inherited::VisitCXXMemberCallExpr(E);
3505  }
3506 
3507  void VisitCallExpr(CallExpr *E) {
3508  // Treat std::move as a use.
3509  if (E->isCallToStdMove()) {
3510  HandleValue(E->getArg(0), /*AddressOf=*/false);
3511  return;
3512  }
3513 
3514  Inherited::VisitCallExpr(E);
3515  }
3516 
3517  void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
3518  Expr *Callee = E->getCallee();
3519 
3520  if (isa<UnresolvedLookupExpr>(Callee))
3521  return Inherited::VisitCXXOperatorCallExpr(E);
3522 
3523  Visit(Callee);
3524  for (auto Arg : E->arguments())
3525  HandleValue(Arg->IgnoreParenImpCasts(), false /*AddressOf*/);
3526  }
3527 
3528  void VisitBinaryOperator(BinaryOperator *E) {
3529  // If a field assignment is detected, remove the field from the
3530  // uninitiailized field set.
3531  if (E->getOpcode() == BO_Assign)
3532  if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getLHS()))
3533  if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
3534  if (!FD->getType()->isReferenceType())
3535  DeclsToRemove.push_back(FD);
3536 
3537  if (E->isCompoundAssignmentOp()) {
3538  HandleValue(E->getLHS(), false /*AddressOf*/);
3539  Visit(E->getRHS());
3540  return;
3541  }
3542 
3543  Inherited::VisitBinaryOperator(E);
3544  }
3545 
3546  void VisitUnaryOperator(UnaryOperator *E) {
3547  if (E->isIncrementDecrementOp()) {
3548  HandleValue(E->getSubExpr(), false /*AddressOf*/);
3549  return;
3550  }
3551  if (E->getOpcode() == UO_AddrOf) {
3552  if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getSubExpr())) {
3553  HandleValue(ME->getBase(), true /*AddressOf*/);
3554  return;
3555  }
3556  }
3557 
3558  Inherited::VisitUnaryOperator(E);
3559  }
3560  };
3561 
3562  // Diagnose value-uses of fields to initialize themselves, e.g.
3563  // foo(foo)
3564  // where foo is not also a parameter to the constructor.
3565  // Also diagnose across field uninitialized use such as
3566  // x(y), y(x)
3567  // TODO: implement -Wuninitialized and fold this into that framework.
3568  static void DiagnoseUninitializedFields(
3569  Sema &SemaRef, const CXXConstructorDecl *Constructor) {
3570 
3571  if (SemaRef.getDiagnostics().isIgnored(diag::warn_field_is_uninit,
3572  Constructor->getLocation())) {
3573  return;
3574  }
3575 
3576  if (Constructor->isInvalidDecl())
3577  return;
3578 
3579  const CXXRecordDecl *RD = Constructor->getParent();
3580 
3581  if (RD->getDescribedClassTemplate())
3582  return;
3583 
3584  // Holds fields that are uninitialized.
3585  llvm::SmallPtrSet<ValueDecl*, 4> UninitializedFields;
3586 
3587  // At the beginning, all fields are uninitialized.
3588  for (auto *I : RD->decls()) {
3589  if (auto *FD = dyn_cast<FieldDecl>(I)) {
3590  UninitializedFields.insert(FD);
3591  } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
3592  UninitializedFields.insert(IFD->getAnonField());
3593  }
3594  }
3595 
3596  llvm::SmallPtrSet<QualType, 4> UninitializedBaseClasses;
3597  for (auto I : RD->bases())
3598  UninitializedBaseClasses.insert(I.getType().getCanonicalType());
3599 
3600  if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
3601  return;
3602 
3603  UninitializedFieldVisitor UninitializedChecker(SemaRef,
3604  UninitializedFields,
3605  UninitializedBaseClasses);
3606 
3607  for (const auto *FieldInit : Constructor->inits()) {
3608  if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
3609  break;
3610 
3611  Expr *InitExpr = FieldInit->getInit();
3612  if (!InitExpr)
3613  continue;
3614 
3616  dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
3617  InitExpr = Default->getExpr();
3618  if (!InitExpr)
3619  continue;
3620  // In class initializers will point to the constructor.
3621  UninitializedChecker.CheckInitializer(InitExpr, Constructor,
3622  FieldInit->getAnyMember(),
3623  FieldInit->getBaseClass());
3624  } else {
3625  UninitializedChecker.CheckInitializer(InitExpr, nullptr,
3626  FieldInit->getAnyMember(),
3627  FieldInit->getBaseClass());
3628  }
3629  }
3630  }
3631 } // namespace
3632 
3633 /// Enter a new C++ default initializer scope. After calling this, the
3634 /// caller must call \ref ActOnFinishCXXInClassMemberInitializer, even if
3635 /// parsing or instantiating the initializer failed.
3637  // Create a synthetic function scope to represent the call to the constructor
3638  // that notionally surrounds a use of this initializer.
3639  PushFunctionScope();
3640 }
3641 
3642 /// This is invoked after parsing an in-class initializer for a
3643 /// non-static C++ class member, and after instantiating an in-class initializer
3644 /// in a class template. Such actions are deferred until the class is complete.
3646  SourceLocation InitLoc,
3647  Expr *InitExpr) {
3648  // Pop the notional constructor scope we created earlier.
3649  PopFunctionScopeInfo(nullptr, D);
3650 
3651  FieldDecl *FD = dyn_cast<FieldDecl>(D);
3652  assert((isa<MSPropertyDecl>(D) || FD->getInClassInitStyle() != ICIS_NoInit) &&
3653  "must set init style when field is created");
3654 
3655  if (!InitExpr) {
3656  D->setInvalidDecl();
3657  if (FD)
3659  return;
3660  }
3661 
3662  if (DiagnoseUnexpandedParameterPack(InitExpr, UPPC_Initializer)) {
3663  FD->setInvalidDecl();
3665  return;
3666  }
3667 
3668  ExprResult Init = InitExpr;
3669  if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent()) {
3670  InitializedEntity Entity =
3675  InitExpr->getBeginLoc(),
3676  InitExpr->getEndLoc())
3677  : InitializationKind::CreateCopy(InitExpr->getBeginLoc(), InitLoc);
3678  InitializationSequence Seq(*this, Entity, Kind, InitExpr);
3679  Init = Seq.Perform(*this, Entity, Kind, InitExpr);
3680  if (Init.isInvalid()) {
3681  FD->setInvalidDecl();
3682  return;
3683  }
3684  }
3685 
3686  // C++11 [class.base.init]p7:
3687  // The initialization of each base and member constitutes a
3688  // full-expression.
3689  Init = ActOnFinishFullExpr(Init.get(), InitLoc);
3690  if (Init.isInvalid()) {
3691  FD->setInvalidDecl();
3692  return;
3693  }
3694 
3695  InitExpr = Init.get();
3696 
3697  FD->setInClassInitializer(InitExpr);
3698 }
3699 
3700 /// Find the direct and/or virtual base specifiers that
3701 /// correspond to the given base type, for use in base initialization
3702 /// within a constructor.
3703 static bool FindBaseInitializer(Sema &SemaRef,
3704  CXXRecordDecl *ClassDecl,
3705  QualType BaseType,
3706  const CXXBaseSpecifier *&DirectBaseSpec,
3707  const CXXBaseSpecifier *&VirtualBaseSpec) {
3708  // First, check for a direct base class.
3709  DirectBaseSpec = nullptr;
3710  for (const auto &Base : ClassDecl->bases()) {
3711  if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base.getType())) {
3712  // We found a direct base of this type. That's what we're
3713  // initializing.
3714  DirectBaseSpec = &Base;
3715  break;
3716  }
3717  }
3718 
3719  // Check for a virtual base class.
3720  // FIXME: We might be able to short-circuit this if we know in advance that
3721  // there are no virtual bases.
3722  VirtualBaseSpec = nullptr;
3723  if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
3724  // We haven't found a base yet; search the class hierarchy for a
3725  // virtual base class.
3726  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3727  /*DetectVirtual=*/false);
3728  if (SemaRef.IsDerivedFrom(ClassDecl->getLocation(),
3729  SemaRef.Context.getTypeDeclType(ClassDecl),
3730  BaseType, Paths)) {
3731  for (CXXBasePaths::paths_iterator Path = Paths.begin();
3732  Path != Paths.end(); ++Path) {
3733  if (Path->back().Base->isVirtual()) {
3734  VirtualBaseSpec = Path->back().Base;
3735  break;
3736  }
3737  }
3738  }
3739  }
3740 
3741  return DirectBaseSpec || VirtualBaseSpec;
3742 }
3743 
3744 /// Handle a C++ member initializer using braced-init-list syntax.
3746 Sema::ActOnMemInitializer(Decl *ConstructorD,
3747  Scope *S,
3748  CXXScopeSpec &SS,
3749  IdentifierInfo *MemberOrBase,
3750  ParsedType TemplateTypeTy,
3751  const DeclSpec &DS,
3752  SourceLocation IdLoc,
3753  Expr *InitList,
3754  SourceLocation EllipsisLoc) {
3755  return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
3756  DS, IdLoc, InitList,
3757  EllipsisLoc);
3758 }
3759 
3760 /// Handle a C++ member initializer using parentheses syntax.
3762 Sema::ActOnMemInitializer(Decl *ConstructorD,
3763  Scope *S,
3764  CXXScopeSpec &SS,
3765  IdentifierInfo *MemberOrBase,
3766  ParsedType TemplateTypeTy,
3767  const DeclSpec &DS,
3768  SourceLocation IdLoc,
3769  SourceLocation LParenLoc,
3770  ArrayRef<Expr *> Args,
3771  SourceLocation RParenLoc,
3772  SourceLocation EllipsisLoc) {
3773  Expr *List = ParenListExpr::Create(Context, LParenLoc, Args, RParenLoc);
3774  return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
3775  DS, IdLoc, List, EllipsisLoc);
3776 }
3777 
3778 namespace {
3779 
3780 // Callback to only accept typo corrections that can be a valid C++ member
3781 // intializer: either a non-static field member or a base class.
3782 class MemInitializerValidatorCCC : public CorrectionCandidateCallback {
3783 public:
3784  explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl)
3785  : ClassDecl(ClassDecl) {}
3786 
3787  bool ValidateCandidate(const TypoCorrection &candidate) override {
3788  if (NamedDecl *ND = candidate.getCorrectionDecl()) {
3789  if (FieldDecl *Member = dyn_cast<FieldDecl>(ND))
3790  return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
3791  return isa<TypeDecl>(ND);
3792  }
3793  return false;
3794  }
3795 
3796 private:
3797  CXXRecordDecl *ClassDecl;
3798 };
3799 
3800 }
3801 
3802 ValueDecl *Sema::tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl,
3803  CXXScopeSpec &SS,
3804  ParsedType TemplateTypeTy,
3805  IdentifierInfo *MemberOrBase) {
3806  if (SS.getScopeRep() || TemplateTypeTy)
3807  return nullptr;
3808  DeclContext::lookup_result Result = ClassDecl->lookup(MemberOrBase);
3809  if (Result.empty())
3810  return nullptr;
3811  ValueDecl *Member;
3812  if ((Member = dyn_cast<FieldDecl>(Result.front())) ||
3813  (Member = dyn_cast<IndirectFieldDecl>(Result.front())))
3814  return Member;
3815  return nullptr;
3816 }
3817 
3818 /// Handle a C++ member initializer.
3820 Sema::BuildMemInitializer(Decl *ConstructorD,
3821  Scope *S,
3822  CXXScopeSpec &SS,
3823  IdentifierInfo *MemberOrBase,
3824  ParsedType TemplateTypeTy,
3825  const DeclSpec &DS,
3826  SourceLocation IdLoc,
3827  Expr *Init,
3828  SourceLocation EllipsisLoc) {
3829  ExprResult Res = CorrectDelayedTyposInExpr(Init);
3830  if (!Res.isUsable())
3831  return true;
3832  Init = Res.get();
3833 
3834  if (!ConstructorD)
3835  return true;
3836 
3837  AdjustDeclIfTemplate(ConstructorD);
3838 
3839  CXXConstructorDecl *Constructor
3840  = dyn_cast<CXXConstructorDecl>(ConstructorD);
3841  if (!Constructor) {
3842  // The user wrote a constructor initializer on a function that is
3843  // not a C++ constructor. Ignore the error for now, because we may
3844  // have more member initializers coming; we'll diagnose it just
3845  // once in ActOnMemInitializers.
3846  return true;
3847  }
3848 
3849  CXXRecordDecl *ClassDecl = Constructor->getParent();
3850 
3851  // C++ [class.base.init]p2:
3852  // Names in a mem-initializer-id are looked up in the scope of the
3853  // constructor's class and, if not found in that scope, are looked
3854  // up in the scope containing the constructor's definition.
3855  // [Note: if the constructor's class contains a member with the
3856  // same name as a direct or virtual base class of the class, a
3857  // mem-initializer-id naming the member or base class and composed
3858  // of a single identifier refers to the class member. A
3859  // mem-initializer-id for the hidden base class may be specified
3860  // using a qualified name. ]
3861 
3862  // Look for a member, first.
3863  if (ValueDecl *Member = tryLookupCtorInitMemberDecl(
3864  ClassDecl, SS, TemplateTypeTy, MemberOrBase)) {
3865  if (EllipsisLoc.isValid())
3866  Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
3867  << MemberOrBase
3868  << SourceRange(IdLoc, Init->getSourceRange().getEnd());
3869 
3870  return BuildMemberInitializer(Member, Init, IdLoc);
3871  }
3872  // It didn't name a member, so see if it names a class.
3873  QualType BaseType;
3874  TypeSourceInfo *TInfo = nullptr;
3875 
3876  if (TemplateTypeTy) {
3877  BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
3878  } else if (DS.getTypeSpecType() == TST_decltype) {
3879  BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
3880  } else if (DS.getTypeSpecType() == TST_decltype_auto) {
3881  Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);
3882  return true;
3883  } else {
3884  LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
3885  LookupParsedName(R, S, &SS);
3886 
3887  TypeDecl *TyD = R.getAsSingle<TypeDecl>();
3888  if (!TyD) {
3889  if (R.isAmbiguous()) return true;
3890 
3891  // We don't want access-control diagnostics here.
3892  R.suppressDiagnostics();
3893 
3894  if (SS.isSet() && isDependentScopeSpecifier(SS)) {
3895  bool NotUnknownSpecialization = false;
3896  DeclContext *DC = computeDeclContext(SS, false);
3897  if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
3898  NotUnknownSpecialization = !Record->hasAnyDependentBases();
3899 
3900  if (!NotUnknownSpecialization) {
3901  // When the scope specifier can refer to a member of an unknown
3902  // specialization, we take it as a type name.
3903  BaseType = CheckTypenameType(ETK_None, SourceLocation(),
3904  SS.getWithLocInContext(Context),
3905  *MemberOrBase, IdLoc);
3906  if (BaseType.isNull())
3907  return true;
3908 
3909  TInfo = Context.CreateTypeSourceInfo(BaseType);
3912  if (!TL.isNull()) {
3913  TL.setNameLoc(IdLoc);
3915  TL.setQualifierLoc(SS.getWithLocInContext(Context));
3916  }
3917 
3918  R.clear();
3919  R.setLookupName(MemberOrBase);
3920  }
3921  }
3922 
3923  // If no results were found, try to correct typos.
3924  TypoCorrection Corr;
3925  if (R.empty() && BaseType.isNull() &&
3926  (Corr = CorrectTypo(
3927  R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
3928  llvm::make_unique<MemInitializerValidatorCCC>(ClassDecl),
3929  CTK_ErrorRecovery, ClassDecl))) {
3930  if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
3931  // We have found a non-static data member with a similar
3932  // name to what was typed; complain and initialize that
3933  // member.
3934  diagnoseTypo(Corr,
3935  PDiag(diag::err_mem_init_not_member_or_class_suggest)
3936  << MemberOrBase << true);
3937  return BuildMemberInitializer(Member, Init, IdLoc);
3938  } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
3939  const CXXBaseSpecifier *DirectBaseSpec;
3940  const CXXBaseSpecifier *VirtualBaseSpec;
3941  if (FindBaseInitializer(*this, ClassDecl,
3942  Context.getTypeDeclType(Type),
3943  DirectBaseSpec, VirtualBaseSpec)) {
3944  // We have found a direct or virtual base class with a
3945  // similar name to what was typed; complain and initialize
3946  // that base class.
3947  diagnoseTypo(Corr,
3948  PDiag(diag::err_mem_init_not_member_or_class_suggest)
3949  << MemberOrBase << false,
3950  PDiag() /*Suppress note, we provide our own.*/);
3951 
3952  const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
3953  : VirtualBaseSpec;
3954  Diag(BaseSpec->getBeginLoc(), diag::note_base_class_specified_here)
3955  << BaseSpec->getType() << BaseSpec->getSourceRange();
3956 
3957  TyD = Type;
3958  }
3959  }
3960  }
3961 
3962  if (!TyD && BaseType.isNull()) {
3963  Diag(IdLoc, diag::err_mem_init_not_member_or_class)
3964  << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
3965  return true;
3966  }
3967  }
3968 
3969  if (BaseType.isNull()) {
3970  BaseType = Context.getTypeDeclType(TyD);
3971  MarkAnyDeclReferenced(TyD->getLocation(), TyD, /*OdrUse=*/false);
3972  if (SS.isSet()) {
3973  BaseType = Context.getElaboratedType(ETK_None, SS.getScopeRep(),
3974  BaseType);
3975  TInfo = Context.CreateTypeSourceInfo(BaseType);
3977  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
3979  TL.setQualifierLoc(SS.getWithLocInContext(Context));
3980  }
3981  }
3982  }
3983 
3984  if (!TInfo)
3985  TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
3986 
3987  return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc);
3988 }
3989 
3992  SourceLocation IdLoc) {
3993  FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member);
3994  IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member);
3995  assert((DirectMember || IndirectMember) &&
3996  "Member must be a FieldDecl or IndirectFieldDecl");
3997 
3998  if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
3999  return true;
4000 
4001  if (Member->isInvalidDecl())
4002  return true;
4003 
4004  MultiExprArg Args;
4005  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4006  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4007  } else if (InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
4008  Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
4009  } else {
4010  // Template instantiation doesn't reconstruct ParenListExprs for us.
4011  Args = Init;
4012  }
4013 
4014  SourceRange InitRange = Init->getSourceRange();
4015 
4016  if (Member->getType()->isDependentType() || Init->isTypeDependent()) {
4017  // Can't check initialization for a member of dependent type or when
4018  // any of the arguments are type-dependent expressions.
4019  DiscardCleanupsInEvaluationContext();
4020  } else {
4021  bool InitList = false;
4022  if (isa<InitListExpr>(Init)) {
4023  InitList = true;
4024  Args = Init;
4025  }
4026 
4027  // Initialize the member.
4028  InitializedEntity MemberEntity =
4029  DirectMember ? InitializedEntity::InitializeMember(DirectMember, nullptr)
4030  : InitializedEntity::InitializeMember(IndirectMember,
4031  nullptr);
4034  IdLoc, Init->getBeginLoc(), Init->getEndLoc())
4035  : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(),
4036  InitRange.getEnd());
4037 
4038  InitializationSequence InitSeq(*this, MemberEntity, Kind, Args);
4039  ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind, Args,
4040  nullptr);
4041  if (MemberInit.isInvalid())
4042  return true;
4043 
4044  // C++11 [class.base.init]p7:
4045  // The initialization of each base and member constitutes a
4046  // full-expression.
4047  MemberInit = ActOnFinishFullExpr(MemberInit.get(), InitRange.getBegin());
4048  if (MemberInit.isInvalid())
4049  return true;
4050 
4051  Init = MemberInit.get();
4052  }
4053 
4054  if (DirectMember) {
4055  return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc,
4056  InitRange.getBegin(), Init,
4057  InitRange.getEnd());
4058  } else {
4059  return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc,
4060  InitRange.getBegin(), Init,
4061  InitRange.getEnd());
4062  }
4063 }
4064 
4067  CXXRecordDecl *ClassDecl) {
4068  SourceLocation NameLoc = TInfo->getTypeLoc().getLocalSourceRange().getBegin();
4069  if (!LangOpts.CPlusPlus11)
4070  return Diag(NameLoc, diag::err_delegating_ctor)
4071  << TInfo->getTypeLoc().getLocalSourceRange();
4072  Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
4073 
4074  bool InitList = true;
4075  MultiExprArg Args = Init;
4076  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4077  InitList = false;
4078  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4079  }
4080 
4081  SourceRange InitRange = Init->getSourceRange();
4082  // Initialize the object.
4084  QualType(ClassDecl->getTypeForDecl(), 0));
4087  NameLoc, Init->getBeginLoc(), Init->getEndLoc())
4088  : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(),
4089  InitRange.getEnd());
4090  InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args);
4091  ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind,
4092  Args, nullptr);
4093  if (DelegationInit.isInvalid())
4094  return true;
4095 
4096  assert(cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() &&
4097  "Delegating constructor with no target?");
4098 
4099  // C++11 [class.base.init]p7:
4100  // The initialization of each base and member constitutes a
4101  // full-expression.
4102  DelegationInit = ActOnFinishFullExpr(DelegationInit.get(),
4103  InitRange.getBegin());
4104  if (DelegationInit.isInvalid())
4105  return true;
4106 
4107  // If we are in a dependent context, template instantiation will
4108  // perform this type-checking again. Just save the arguments that we
4109  // received in a ParenListExpr.
4110  // FIXME: This isn't quite ideal, since our ASTs don't capture all
4111  // of the information that we have about the base
4112  // initializer. However, deconstructing the ASTs is a dicey process,
4113  // and this approach is far more likely to get the corner cases right.
4114  if (CurContext->isDependentContext())
4115  DelegationInit = Init;
4116 
4117  return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(),
4118  DelegationInit.getAs<Expr>(),
4119  InitRange.getEnd());
4120 }
4121 
4124  Expr *Init, CXXRecordDecl *ClassDecl,
4125  SourceLocation EllipsisLoc) {
4126  SourceLocation BaseLoc
4127  = BaseTInfo->getTypeLoc().getLocalSourceRange().getBegin();
4128 
4129  if (!BaseType->isDependentType() && !BaseType->isRecordType())
4130  return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
4131  << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
4132 
4133  // C++ [class.base.init]p2:
4134  // [...] Unless the mem-initializer-id names a nonstatic data
4135  // member of the constructor's class or a direct or virtual base
4136  // of that class, the mem-initializer is ill-formed. A
4137  // mem-initializer-list can initialize a base class using any
4138  // name that denotes that base class type.
4139  bool Dependent = BaseType->isDependentType() || Init->isTypeDependent();
4140 
4141  SourceRange InitRange = Init->getSourceRange();
4142  if (EllipsisLoc.isValid()) {
4143  // This is a pack expansion.
4144  if (!BaseType->containsUnexpandedParameterPack()) {
4145  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
4146  << SourceRange(BaseLoc, InitRange.getEnd());
4147 
4148  EllipsisLoc = SourceLocation();
4149  }
4150  } else {
4151  // Check for any unexpanded parameter packs.
4152  if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer))
4153  return true;
4154 
4155  if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
4156  return true;
4157  }
4158 
4159  // Check for direct and virtual base classes.
4160  const CXXBaseSpecifier *DirectBaseSpec = nullptr;
4161  const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
4162  if (!Dependent) {
4163  if (Context.hasSameUnqualifiedType(QualType(ClassDecl->getTypeForDecl(),0),
4164  BaseType))
4165  return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl);
4166 
4167  FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
4168  VirtualBaseSpec);
4169 
4170  // C++ [base.class.init]p2:
4171  // Unless the mem-initializer-id names a nonstatic data member of the
4172  // constructor's class or a direct or virtual base of that class, the
4173  // mem-initializer is ill-formed.
4174  if (!DirectBaseSpec && !VirtualBaseSpec) {
4175  // If the class has any dependent bases, then it's possible that
4176  // one of those types will resolve to the same type as
4177  // BaseType. Therefore, just treat this as a dependent base
4178  // class initialization. FIXME: Should we try to check the
4179  // initialization anyway? It seems odd.
4180  if (ClassDecl->hasAnyDependentBases())
4181  Dependent = true;
4182  else
4183  return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
4184  << BaseType << Context.getTypeDeclType(ClassDecl)
4185  << BaseTInfo->getTypeLoc().getLocalSourceRange();
4186  }
4187  }
4188 
4189  if (Dependent) {
4190  DiscardCleanupsInEvaluationContext();
4191 
4192  return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4193  /*IsVirtual=*/false,
4194  InitRange.getBegin(), Init,
4195  InitRange.getEnd(), EllipsisLoc);
4196  }
4197 
4198  // C++ [base.class.init]p2:
4199  // If a mem-initializer-id is ambiguous because it designates both
4200  // a direct non-virtual base class and an inherited virtual base
4201  // class, the mem-initializer is ill-formed.
4202  if (DirectBaseSpec && VirtualBaseSpec)
4203  return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
4204  << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
4205 
4206  const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
4207  if (!BaseSpec)
4208  BaseSpec = VirtualBaseSpec;
4209 
4210  // Initialize the base.
4211  bool InitList = true;
4212  MultiExprArg Args = Init;
4213  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4214  InitList = false;
4215  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4216  }
4217 
4218  InitializedEntity BaseEntity =
4219  InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec);
4221  InitList ? InitializationKind::CreateDirectList(BaseLoc)
4222  : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(),
4223  InitRange.getEnd());
4224  InitializationSequence InitSeq(*this, BaseEntity, Kind, Args);
4225  ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind, Args, nullptr);
4226  if (BaseInit.isInvalid())
4227  return true;
4228 
4229  // C++11 [class.base.init]p7:
4230  // The initialization of each base and member constitutes a
4231  // full-expression.
4232  BaseInit = ActOnFinishFullExpr(BaseInit.get(), InitRange.getBegin());
4233  if (BaseInit.isInvalid())
4234  return true;
4235 
4236  // If we are in a dependent context, template instantiation will
4237  // perform this type-checking again. Just save the arguments that we
4238  // received in a ParenListExpr.
4239  // FIXME: This isn't quite ideal, since our ASTs don't capture all
4240  // of the information that we have about the base
4241  // initializer. However, deconstructing the ASTs is a dicey process,
4242  // and this approach is far more likely to get the corner cases right.
4243  if (CurContext->isDependentContext())
4244  BaseInit = Init;
4245 
4246  return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4247  BaseSpec->isVirtual(),
4248  InitRange.getBegin(),
4249  BaseInit.getAs<Expr>(),
4250  InitRange.getEnd(), EllipsisLoc);
4251 }
4252 
4253 // Create a static_cast<T&&>(expr).
4254 static Expr *CastForMoving(Sema &SemaRef, Expr *E, QualType T = QualType()) {
4255  if (T.isNull()) T = E->getType();
4256  QualType TargetType = SemaRef.BuildReferenceType(
4257  T, /*SpelledAsLValue*/false, SourceLocation(), DeclarationName());
4258  SourceLocation ExprLoc = E->getBeginLoc();
4259  TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo(
4260  TargetType, ExprLoc);
4261 
4262  return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
4263  SourceRange(ExprLoc, ExprLoc),
4264  E->getSourceRange()).get();
4265 }
4266 
4267 /// ImplicitInitializerKind - How an implicit base or member initializer should
4268 /// initialize its base or member.
4274 };
4275 
4276 static bool
4278  ImplicitInitializerKind ImplicitInitKind,
4279  CXXBaseSpecifier *BaseSpec,
4280  bool IsInheritedVirtualBase,
4281  CXXCtorInitializer *&CXXBaseInit) {
4282  InitializedEntity InitEntity
4283  = InitializedEntity::InitializeBase(SemaRef.Context, BaseSpec,
4284  IsInheritedVirtualBase);
4285 
4286  ExprResult BaseInit;
4287 
4288  switch (ImplicitInitKind) {
4289  case IIK_Inherit:
4290  case IIK_Default: {
4291  InitializationKind InitKind
4293  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
4294  BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
4295  break;
4296  }
4297 
4298  case IIK_Move:
4299  case IIK_Copy: {
4300  bool Moving = ImplicitInitKind == IIK_Move;
4301  ParmVarDecl *Param = Constructor->getParamDecl(0);
4302  QualType ParamType = Param->getType().getNonReferenceType();
4303 
4304  Expr *CopyCtorArg =
4306  SourceLocation(), Param, false,
4307  Constructor->getLocation(), ParamType,
4308  VK_LValue, nullptr);
4309 
4310  SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg));
4311 
4312  // Cast to the base class to avoid ambiguities.
4313  QualType ArgTy =
4314  SemaRef.Context.getQualifiedType(BaseSpec->getType().getUnqualifiedType(),
4315  ParamType.getQualifiers());
4316 
4317  if (Moving) {
4318  CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg);
4319  }
4320 
4321  CXXCastPath BasePath;
4322  BasePath.push_back(BaseSpec);
4323  CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy,
4324  CK_UncheckedDerivedToBase,
4325  Moving ? VK_XValue : VK_LValue,
4326  &BasePath).get();
4327 
4328  InitializationKind InitKind
4331  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, CopyCtorArg);
4332  BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, CopyCtorArg);
4333  break;
4334  }
4335  }
4336 
4337  BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit);
4338  if (BaseInit.isInvalid())
4339  return true;
4340 
4341  CXXBaseInit =
4342  new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4343  SemaRef.Context.getTrivialTypeSourceInfo(BaseSpec->getType(),
4344  SourceLocation()),
4345  BaseSpec->isVirtual(),
4346  SourceLocation(),
4347  BaseInit.getAs<Expr>(),
4348  SourceLocation(),
4349  SourceLocation());
4350 
4351  return false;
4352 }
4353 
4354 static bool RefersToRValueRef(Expr *MemRef) {
4355  ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
4356  return Referenced->getType()->isRValueReferenceType();
4357 }
4358 
4359 static bool
4361  ImplicitInitializerKind ImplicitInitKind,
4362  FieldDecl *Field, IndirectFieldDecl *Indirect,
4363  CXXCtorInitializer *&CXXMemberInit) {
4364  if (Field->isInvalidDecl())
4365  return true;
4366 
4367  SourceLocation Loc = Constructor->getLocation();
4368 
4369  if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) {
4370  bool Moving = ImplicitInitKind == IIK_Move;
4371  ParmVarDecl *Param = Constructor->getParamDecl(0);
4372  QualType ParamType = Param->getType().getNonReferenceType();
4373 
4374  // Suppress copying zero-width bitfields.
4375  if (Field->isZeroLengthBitField(SemaRef.Context))
4376  return false;
4377 
4378  Expr *MemberExprBase =
4380  SourceLocation(), Param, false,
4381  Loc, ParamType, VK_LValue, nullptr);
4382 
4383  SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase));
4384 
4385  if (Moving) {
4386  MemberExprBase = CastForMoving(SemaRef, MemberExprBase);
4387  }
4388 
4389  // Build a reference to this field within the parameter.
4390  CXXScopeSpec SS;
4391  LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
4393  MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect)
4394  : cast<ValueDecl>(Field), AS_public);
4395  MemberLookup.resolveKind();
4396  ExprResult CtorArg
4397  = SemaRef.BuildMemberReferenceExpr(MemberExprBase,
4398  ParamType, Loc,
4399  /*IsArrow=*/false,
4400  SS,
4401  /*TemplateKWLoc=*/SourceLocation(),
4402  /*FirstQualifierInScope=*/nullptr,
4403  MemberLookup,
4404  /*TemplateArgs=*/nullptr,
4405  /*S*/nullptr);
4406  if (CtorArg.isInvalid())
4407  return true;
4408 
4409  // C++11 [class.copy]p15:
4410  // - if a member m has rvalue reference type T&&, it is direct-initialized
4411  // with static_cast<T&&>(x.m);
4412  if (RefersToRValueRef(CtorArg.get())) {
4413  CtorArg = CastForMoving(SemaRef, CtorArg.get());
4414  }
4415 
4416  InitializedEntity Entity =
4417  Indirect ? InitializedEntity::InitializeMember(Indirect, nullptr,
4418  /*Implicit*/ true)
4419  : InitializedEntity::InitializeMember(Field, nullptr,
4420  /*Implicit*/ true);
4421 
4422  // Direct-initialize to use the copy constructor.
4423  InitializationKind InitKind =
4425 
4426  Expr *CtorArgE = CtorArg.getAs<Expr>();
4427  InitializationSequence InitSeq(SemaRef, Entity, InitKind, CtorArgE);
4428  ExprResult MemberInit =
4429  InitSeq.Perform(SemaRef, Entity, InitKind, MultiExprArg(&CtorArgE, 1));
4430  MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
4431  if (MemberInit.isInvalid())
4432  return true;
4433 
4434  if (Indirect)
4435  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
4436  SemaRef.Context, Indirect, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
4437  else
4438  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
4439  SemaRef.Context, Field, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
4440  return false;
4441  }
4442 
4443  assert((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) &&
4444  "Unhandled implicit init kind!");
4445 
4446  QualType FieldBaseElementType =
4447  SemaRef.Context.getBaseElementType(Field->getType());
4448 
4449  if (FieldBaseElementType->isRecordType()) {
4450  InitializedEntity InitEntity =
4451  Indirect ? InitializedEntity::InitializeMember(Indirect, nullptr,
4452  /*Implicit*/ true)
4453  : InitializedEntity::InitializeMember(Field, nullptr,
4454  /*Implicit*/ true);
4455  InitializationKind InitKind =
4457 
4458  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
4459  ExprResult MemberInit =
4460  InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
4461 
4462  MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
4463  if (MemberInit.isInvalid())
4464  return true;
4465 
4466  if (Indirect)
4467  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4468  Indirect, Loc,
4469  Loc,
4470  MemberInit.get(),
4471  Loc);
4472  else
4473  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4474  Field, Loc, Loc,
4475  MemberInit.get(),
4476  Loc);
4477  return false;
4478  }
4479 
4480  if (!Field->getParent()->isUnion()) {
4481  if (FieldBaseElementType->isReferenceType()) {
4482  SemaRef.Diag(Constructor->getLocation(),
4483  diag::err_uninitialized_member_in_ctor)
4484  << (int)Constructor->isImplicit()
4485  << SemaRef.Context.getTagDeclType(Constructor->getParent())
4486  << 0 << Field->getDeclName();
4487  SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
4488  return true;
4489  }
4490 
4491  if (FieldBaseElementType.isConstQualified()) {
4492  SemaRef.Diag(Constructor->getLocation(),
4493  diag::err_uninitialized_member_in_ctor)
4494  << (int)Constructor->isImplicit()
4495  << SemaRef.Context.getTagDeclType(Constructor->getParent())
4496  << 1 << Field->getDeclName();
4497  SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
4498  return true;
4499  }
4500  }
4501 
4502  if (FieldBaseElementType.hasNonTrivialObjCLifetime()) {
4503  // ARC and Weak:
4504  // Default-initialize Objective-C pointers to NULL.
4505  CXXMemberInit
4506  = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
4507  Loc, Loc,
4508  new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()),
4509  Loc);
4510  return false;
4511  }
4512 
4513  // Nothing to initialize.
4514  CXXMemberInit = nullptr;
4515  return false;
4516 }
4517 
4518 namespace {
4519 struct BaseAndFieldInfo {
4520  Sema &S;
4521  CXXConstructorDecl *Ctor;
4522  bool AnyErrorsInInits;
4524  llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
4526  llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
4527 
4528  BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits)
4529  : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
4530  bool Generated = Ctor->isImplicit() || Ctor->isDefaulted();
4531  if (Ctor->getInheritedConstructor())
4532  IIK = IIK_Inherit;
4533  else if (Generated && Ctor->isCopyConstructor())
4534  IIK = IIK_Copy;
4535  else if (Generated && Ctor->isMoveConstructor())
4536  IIK = IIK_Move;
4537  else
4538  IIK = IIK_Default;
4539  }
4540 
4541  bool isImplicitCopyOrMove() const {
4542  switch (IIK) {
4543  case IIK_Copy:
4544  case IIK_Move:
4545  return true;
4546 
4547  case IIK_Default:
4548  case IIK_Inherit:
4549  return false;
4550  }
4551 
4552  llvm_unreachable("Invalid ImplicitInitializerKind!");
4553  }
4554 
4555  bool addFieldInitializer(CXXCtorInitializer *Init) {
4556  AllToInit.push_back(Init);
4557 
4558  // Check whether this initializer makes the field "used".
4559  if (Init->getInit()->HasSideEffects(S.Context))
4560  S.UnusedPrivateFields.remove(Init->getAnyMember());
4561 
4562  return false;
4563  }
4564 
4565  bool isInactiveUnionMember(FieldDecl *Field) {
4566  RecordDecl *Record = Field->getParent();
4567  if (!Record->isUnion())
4568  return false;
4569 
4570  if (FieldDecl *Active =
4571  ActiveUnionMember.lookup(Record->getCanonicalDecl()))
4572  return Active != Field->getCanonicalDecl();
4573 
4574  // In an implicit copy or move constructor, ignore any in-class initializer.
4575  if (isImplicitCopyOrMove())
4576  return true;
4577 
4578  // If there's no explicit initialization, the field is active only if it
4579  // has an in-class initializer...
4580  if (Field->hasInClassInitializer())
4581  return false;
4582  // ... or it's an anonymous struct or union whose class has an in-class
4583  // initializer.
4584  if (!Field->isAnonymousStructOrUnion())
4585  return true;
4586  CXXRecordDecl *FieldRD = Field->getType()->getAsCXXRecordDecl();
4587  return !FieldRD->hasInClassInitializer();
4588  }
4589 
4590  /// Determine whether the given field is, or is within, a union member
4591  /// that is inactive (because there was an initializer given for a different
4592  /// member of the union, or because the union was not initialized at all).
4593  bool isWithinInactiveUnionMember(FieldDecl *Field,
4594  IndirectFieldDecl *Indirect) {
4595  if (!Indirect)
4596  return isInactiveUnionMember(Field);
4597 
4598  for (auto *C : Indirect->chain()) {
4599  FieldDecl *Field = dyn_cast<FieldDecl>(C);
4600  if (Field && isInactiveUnionMember(Field))
4601  return true;
4602  }
4603  return false;
4604  }
4605 };
4606 }
4607 
4608 /// Determine whether the given type is an incomplete or zero-lenfgth
4609 /// array type.
4611  if (T->isIncompleteArrayType())
4612  return true;
4613 
4614  while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
4615  if (!ArrayT->getSize())
4616  return true;
4617 
4618  T = ArrayT->getElementType();
4619  }
4620 
4621  return false;
4622 }
4623 
4624 static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
4625  FieldDecl *Field,
4626  IndirectFieldDecl *Indirect = nullptr) {
4627  if (Field->isInvalidDecl())
4628  return false;
4629 
4630  // Overwhelmingly common case: we have a direct initializer for this field.
4631  if (CXXCtorInitializer *Init =
4632  Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
4633  return Info.addFieldInitializer(Init);
4634 
4635  // C++11 [class.base.init]p8:
4636  // if the entity is a non-static data member that has a
4637  // brace-or-equal-initializer and either
4638  // -- the constructor's class is a union and no other variant member of that
4639  // union is designated by a mem-initializer-id or
4640  // -- the constructor's class is not a union, and, if the entity is a member
4641  // of an anonymous union, no other member of that union is designated by
4642  // a mem-initializer-id,
4643  // the entity is initialized as specified in [dcl.init].
4644  //
4645  // We also apply the same rules to handle anonymous structs within anonymous
4646  // unions.
4647  if (Info.isWithinInactiveUnionMember(Field, Indirect))
4648  return false;
4649 
4650  if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
4651  ExprResult DIE =
4652  SemaRef.BuildCXXDefaultInitExpr(Info.Ctor->getLocation(), Field);
4653  if (DIE.isInvalid())
4654  return true;
4655 
4656  auto Entity = InitializedEntity::InitializeMember(Field, nullptr, true);
4657  SemaRef.checkInitializerLifetime(Entity, DIE.get());
4658 
4659  CXXCtorInitializer *Init;
4660  if (Indirect)
4661  Init = new (SemaRef.Context)
4662  CXXCtorInitializer(SemaRef.Context, Indirect, SourceLocation(),
4663  SourceLocation(), DIE.get(), SourceLocation());
4664  else
4665  Init = new (SemaRef.Context)
4666  CXXCtorInitializer(SemaRef.Context, Field, SourceLocation(),
4667  SourceLocation(), DIE.get(), SourceLocation());
4668  return Info.addFieldInitializer(Init);
4669  }
4670 
4671  // Don't initialize incomplete or zero-length arrays.
4672  if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType()))
4673  return false;
4674 
4675  // Don't try to build an implicit initializer if there were semantic
4676  // errors in any of the initializers (and therefore we might be
4677  // missing some that the user actually wrote).
4678  if (Info.AnyErrorsInInits)
4679  return false;
4680 
4681  CXXCtorInitializer *Init = nullptr;
4682  if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field,
4683  Indirect, Init))
4684  return true;
4685 
4686  if (!Init)
4687  return false;
4688 
4689  return Info.addFieldInitializer(Init);
4690 }
4691 
4692 bool
4694  CXXCtorInitializer *Initializer) {
4695  assert(Initializer->isDelegatingInitializer());
4696  Constructor->setNumCtorInitializers(1);
4697  CXXCtorInitializer **initializer =
4698  new (Context) CXXCtorInitializer*[1];
4699  memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*));
4700  Constructor->setCtorInitializers(initializer);
4701 
4702  if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) {
4703  MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor);
4704  DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation());
4705  }
4706 
4707  DelegatingCtorDecls.push_back(Constructor);
4708 
4709  DiagnoseUninitializedFields(*this, Constructor);
4710 
4711  return false;
4712 }
4713 
4714 bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
4715  ArrayRef<CXXCtorInitializer *> Initializers) {
4716  if (Constructor->isDependentContext()) {
4717  // Just store the initializers as written, they will be checked during
4718  // instantiation.
4719  if (!Initializers.empty()) {
4720  Constructor->setNumCtorInitializers(Initializers.size());
4721  CXXCtorInitializer **baseOrMemberInitializers =
4722  new (Context) CXXCtorInitializer*[Initializers.size()];
4723  memcpy(baseOrMemberInitializers, Initializers.data(),
4724  Initializers.size() * sizeof(CXXCtorInitializer*));
4725  Constructor->setCtorInitializers(baseOrMemberInitializers);
4726  }
4727 
4728  // Let template instantiation know whether we had errors.
4729  if (AnyErrors)
4730  Constructor->setInvalidDecl();
4731 
4732  return false;
4733  }
4734 
4735  BaseAndFieldInfo Info(*this, Constructor, AnyErrors);
4736 
4737  // We need to build the initializer AST according to order of construction
4738  // and not what user specified in the Initializers list.
4739  CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
4740  if (!ClassDecl)
4741  return true;
4742 
4743  bool HadError = false;
4744 
4745  for (unsigned i = 0; i < Initializers.size(); i++) {
4746  CXXCtorInitializer *Member = Initializers[i];
4747 
4748  if (Member->isBaseInitializer())
4749  Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
4750  else {
4751  Info.AllBaseFields[Member->getAnyMember()->getCanonicalDecl()] = Member;
4752 
4753  if (IndirectFieldDecl *F = Member->getIndirectMember()) {
4754  for (auto *C : F->chain()) {
4755  FieldDecl *FD = dyn_cast<FieldDecl>(C);
4756  if (FD && FD->getParent()->isUnion())
4757  Info.ActiveUnionMember.insert(std::make_pair(
4758  FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
4759  }
4760  } else if (FieldDecl *FD = Member->getMember()) {
4761  if (FD->getParent()->isUnion())
4762  Info.ActiveUnionMember.insert(std::make_pair(
4763  FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
4764  }
4765  }
4766  }
4767 
4768  // Keep track of the direct virtual bases.
4769  llvm::SmallPtrSet<CXXBaseSpecifier *, 16> DirectVBases;
4770  for (auto &I : ClassDecl->bases()) {
4771  if (I.isVirtual())
4772  DirectVBases.insert(&I);
4773  }
4774 
4775  // Push virtual bases before others.
4776  for (auto &VBase : ClassDecl->vbases()) {
4778  = Info.AllBaseFields.lookup(VBase.getType()->getAs<RecordType>())) {
4779  // [class.base.init]p7, per DR257:
4780  // A mem-initializer where the mem-initializer-id names a virtual base
4781  // class is ignored during execution of a constructor of any class that
4782  // is not the most derived class.
4783  if (ClassDecl->isAbstract()) {
4784  // FIXME: Provide a fixit to remove the base specifier. This requires
4785  // tracking the location of the associated comma for a base specifier.
4786  Diag(Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
4787  << VBase.getType() << ClassDecl;
4788  DiagnoseAbstractType(ClassDecl);
4789  }
4790 
4791  Info.AllToInit.push_back(Value);
4792  } else if (!AnyErrors && !ClassDecl->isAbstract()) {
4793  // [class.base.init]p8, per DR257:
4794  // If a given [...] base class is not named by a mem-initializer-id
4795  // [...] and the entity is not a virtual base class of an abstract
4796  // class, then [...] the entity is default-initialized.
4797  bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
4798  CXXCtorInitializer *CXXBaseInit;
4799  if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
4800  &VBase, IsInheritedVirtualBase,
4801  CXXBaseInit)) {
4802  HadError = true;
4803  continue;
4804  }
4805 
4806  Info.AllToInit.push_back(CXXBaseInit);
4807  }
4808  }
4809 
4810  // Non-virtual bases.
4811  for (auto &Base : ClassDecl->bases()) {
4812  // Virtuals are in the virtual base list and already constructed.
4813  if (Base.isVirtual())
4814  continue;
4815 
4817  = Info.AllBaseFields.lookup(Base.getType()->getAs<RecordType>())) {
4818  Info.AllToInit.push_back(Value);
4819  } else if (!AnyErrors) {
4820  CXXCtorInitializer *CXXBaseInit;
4821  if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
4822  &Base, /*IsInheritedVirtualBase=*/false,
4823  CXXBaseInit)) {
4824  HadError = true;
4825  continue;
4826  }
4827 
4828  Info.AllToInit.push_back(CXXBaseInit);
4829  }
4830  }
4831 
4832  // Fields.
4833  for (auto *Mem : ClassDecl->decls()) {
4834  if (auto *F = dyn_cast<FieldDecl>(Mem)) {
4835  // C++ [class.bit]p2:
4836  // A declaration for a bit-field that omits the identifier declares an
4837  // unnamed bit-field. Unnamed bit-fields are not members and cannot be
4838  // initialized.
4839  if (F->isUnnamedBitfield())
4840  continue;
4841 
4842  // If we're not generating the implicit copy/move constructor, then we'll
4843  // handle anonymous struct/union fields based on their individual
4844  // indirect fields.
4845  if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
4846  continue;
4847 
4848  if (CollectFieldInitializer(*this, Info, F))
4849  HadError = true;
4850  continue;
4851  }
4852 
4853  // Beyond this point, we only consider default initialization.
4854  if (Info.isImplicitCopyOrMove())
4855  continue;
4856 
4857  if (auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
4858  if (F->getType()->isIncompleteArrayType()) {
4859  assert(ClassDecl->hasFlexibleArrayMember() &&
4860  "Incomplete array type is not valid");
4861  continue;
4862  }
4863 
4864  // Initialize each field of an anonymous struct individually.
4865  if (CollectFieldInitializer(*this, Info, F->getAnonField(), F))
4866  HadError = true;
4867 
4868  continue;
4869  }
4870  }
4871 
4872  unsigned NumInitializers = Info.AllToInit.size();
4873  if (NumInitializers > 0) {
4874  Constructor->setNumCtorInitializers(NumInitializers);
4875  CXXCtorInitializer **baseOrMemberInitializers =
4876  new (Context) CXXCtorInitializer*[NumInitializers];
4877  memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
4878  NumInitializers * sizeof(CXXCtorInitializer*));
4879  Constructor->setCtorInitializers(baseOrMemberInitializers);
4880 
4881  // Constructors implicitly reference the base and member
4882  // destructors.
4883  MarkBaseAndMemberDestructorsReferenced(Constructor->getLocation(),
4884  Constructor->getParent());
4885  }
4886 
4887  return HadError;
4888 }
4889 
4891  if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
4892  const RecordDecl *RD = RT->getDecl();
4893  if (RD->isAnonymousStructOrUnion()) {
4894  for (auto *Field : RD->fields())
4895  PopulateKeysForFields(Field, IdealInits);
4896  return;
4897  }
4898  }
4899  IdealInits.push_back(Field->getCanonicalDecl());
4900 }
4901 
4902 static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
4903  return Context.getCanonicalType(BaseType).getTypePtr();
4904 }
4905 
4906 static const void *GetKeyForMember(ASTContext &Context,
4907  CXXCtorInitializer *Member) {
4908  if (!Member->isAnyMemberInitializer())
4909  return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0));
4910 
4911  return Member->getAnyMember()->getCanonicalDecl();
4912 }
4913 
4915  Sema &SemaRef, const CXXConstructorDecl *Constructor,
4917  if (Constructor->getDeclContext()->isDependentContext())
4918  return;
4919 
4920  // Don't check initializers order unless the warning is enabled at the
4921  // location of at least one initializer.
4922  bool ShouldCheckOrder = false;
4923  for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
4924  CXXCtorInitializer *Init = Inits[InitIndex];
4925  if (!SemaRef.Diags.isIgnored(diag::warn_initializer_out_of_order,
4926  Init->getSourceLocation())) {
4927  ShouldCheckOrder = true;
4928  break;
4929  }
4930  }
4931  if (!ShouldCheckOrder)
4932  return;
4933 
4934  // Build the list of bases and members in the order that they'll
4935  // actually be initialized. The explicit initializers should be in
4936  // this same order but may be missing things.
4937  SmallVector<const void*, 32> IdealInitKeys;
4938 
4939  const CXXRecordDecl *ClassDecl = Constructor->getParent();
4940 
4941  // 1. Virtual bases.
4942  for (const auto &VBase : ClassDecl->vbases())
4943  IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase.getType()));
4944 
4945  // 2. Non-virtual bases.
4946  for (const auto &Base : ClassDecl->bases()) {
4947  if (Base.isVirtual())
4948  continue;
4949  IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base.getType()));
4950  }
4951 
4952  // 3. Direct fields.
4953  for (auto *Field : ClassDecl->fields()) {
4954  if (Field->isUnnamedBitfield())
4955  continue;
4956 
4957  PopulateKeysForFields(Field, IdealInitKeys);
4958  }
4959 
4960  unsigned NumIdealInits = IdealInitKeys.size();
4961  unsigned IdealIndex = 0;
4962 
4963  CXXCtorInitializer *PrevInit = nullptr;
4964  for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
4965  CXXCtorInitializer *Init = Inits[InitIndex];
4966  const void *InitKey = GetKeyForMember(SemaRef.Context, Init);
4967 
4968  // Scan forward to try to find this initializer in the idealized
4969  // initializers list.
4970  for (; IdealIndex != NumIdealInits; ++IdealIndex)
4971  if (InitKey == IdealInitKeys[IdealIndex])
4972  break;
4973 
4974  // If we didn't find this initializer, it must be because we
4975  // scanned past it on a previous iteration. That can only
4976  // happen if we're out of order; emit a warning.
4977  if (IdealIndex == NumIdealInits && PrevInit) {
4979  SemaRef.Diag(PrevInit->getSourceLocation(),
4980  diag::warn_initializer_out_of_order);
4981 
4982  if (PrevInit->isAnyMemberInitializer())
4983  D << 0 << PrevInit->getAnyMember()->getDeclName();
4984  else
4985  D << 1 << PrevInit->getTypeSourceInfo()->getType();
4986 
4987  if (Init->isAnyMemberInitializer())
4988  D << 0 << Init->getAnyMember()->getDeclName();
4989  else
4990  D << 1 << Init->getTypeSourceInfo()->getType();
4991 
4992  // Move back to the initializer's location in the ideal list.
4993  for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
4994  if (InitKey == IdealInitKeys[IdealIndex])
4995  break;
4996 
4997  assert(IdealIndex < NumIdealInits &&
4998  "initializer not found in initializer list");
4999  }
5000 
5001  PrevInit = Init;
5002  }
5003 }
5004 
5005 namespace {
5006 bool CheckRedundantInit(Sema &S,
5007  CXXCtorInitializer *Init,
5008  CXXCtorInitializer *&PrevInit) {
5009  if (!PrevInit) {
5010  PrevInit = Init;
5011  return false;
5012  }
5013 
5014  if (FieldDecl *Field = Init->getAnyMember())
5015  S.Diag(Init->getSourceLocation(),
5016  diag::err_multiple_mem_initialization)
5017  << Field->getDeclName()
5018  << Init->getSourceRange();
5019  else {
5020  const Type *BaseClass = Init->getBaseClass();
5021  assert(BaseClass && "neither field nor base");
5022  S.Diag(Init->getSourceLocation(),
5023  diag::err_multiple_base_initialization)
5024  << QualType(BaseClass, 0)
5025  << Init->getSourceRange();
5026  }
5027  S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer)
5028  << 0 << PrevInit->getSourceRange();
5029 
5030  return true;
5031 }
5032 
5033 typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
5034 typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
5035 
5036 bool CheckRedundantUnionInit(Sema &S,
5037  CXXCtorInitializer *Init,
5038  RedundantUnionMap &Unions) {
5039  FieldDecl *Field = Init->getAnyMember();
5040  RecordDecl *Parent = Field->getParent();
5041  NamedDecl *Child = Field;
5042 
5043  while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {
5044  if (Parent->isUnion()) {
5045  UnionEntry &En = Unions[Parent];
5046  if (En.first && En.first != Child) {
5047  S.Diag(Init->getSourceLocation(),
5048  diag::err_multiple_mem_union_initialization)
5049  << Field->getDeclName()
5050  << Init->getSourceRange();
5051  S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
5052  << 0 << En.second->getSourceRange();
5053  return true;
5054  }
5055  if (!En.first) {
5056  En.first = Child;
5057  En.second = Init;
5058  }
5059  if (!Parent->isAnonymousStructOrUnion())
5060  return false;
5061  }
5062 
5063  Child = Parent;
5064  Parent = cast<RecordDecl>(Parent->getDeclContext());
5065  }
5066 
5067  return false;
5068 }
5069 }
5070 
5071 /// ActOnMemInitializers - Handle the member initializers for a constructor.
5072 void Sema::ActOnMemInitializers(Decl *ConstructorDecl,
5075  bool AnyErrors) {
5076  if (!ConstructorDecl)
5077  return;
5078 
5079  AdjustDeclIfTemplate(ConstructorDecl);
5080 
5081  CXXConstructorDecl *Constructor
5082  = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
5083 
5084  if (!Constructor) {
5085  Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
5086  return;
5087  }
5088 
5089  // Mapping for the duplicate initializers check.
5090  // For member initializers, this is keyed with a FieldDecl*.
5091  // For base initializers, this is keyed with a Type*.
5092  llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
5093 
5094  // Mapping for the inconsistent anonymous-union initializers check.
5095  RedundantUnionMap MemberUnions;
5096 
5097  bool HadError = false;
5098  for (unsigned i = 0; i < MemInits.size(); i++) {
5099  CXXCtorInitializer *Init = MemInits[i];
5100 
5101  // Set the source order index.
5102  Init->setSourceOrder(i);
5103 
5104  if (Init->isAnyMemberInitializer()) {
5105  const void *Key = GetKeyForMember(Context, Init);
5106  if (CheckRedundantInit(*this, Init, Members[Key]) ||
5107  CheckRedundantUnionInit(*this, Init, MemberUnions))
5108  HadError = true;
5109  } else if (Init->isBaseInitializer()) {
5110  const void *Key = GetKeyForMember(Context, Init);
5111  if (CheckRedundantInit(*this, Init, Members[Key]))
5112  HadError = true;
5113  } else {
5114  assert(Init->isDelegatingInitializer());
5115  // This must be the only initializer
5116  if (MemInits.size() != 1) {
5117  Diag(Init->getSourceLocation(),
5118  diag::err_delegating_initializer_alone)
5119  << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
5120  // We will treat this as being the only initializer.
5121  }
5122  SetDelegatingInitializer(Constructor, MemInits[i]);
5123  // Return immediately as the initializer is set.
5124  return;
5125  }
5126  }
5127 
5128  if (HadError)
5129  return;
5130 
5131  DiagnoseBaseOrMemInitializerOrder(*this, Constructor, MemInits);
5132 
5133  SetCtorInitializers(Constructor, AnyErrors, MemInits);
5134 
5135  DiagnoseUninitializedFields(*this, Constructor);
5136 }
5137 
5138 void
5140  CXXRecordDecl *ClassDecl) {
5141  // Ignore dependent contexts. Also ignore unions, since their members never
5142  // have destructors implicitly called.
5143  if (ClassDecl->isDependentContext() || ClassDecl->isUnion())
5144  return;
5145 
5146  // FIXME: all the access-control diagnostics are positioned on the
5147  // field/base declaration. That's probably good; that said, the
5148  // user might reasonably want to know why the destructor is being
5149  // emitted, and we currently don't say.
5150 
5151  // Non-static data members.
5152  for (auto *Field : ClassDecl->fields()) {
5153  if (Field->isInvalidDecl())
5154  continue;
5155 
5156  // Don't destroy incomplete or zero-length arrays.
5157  if (isIncompleteOrZeroLengthArrayType(Context, Field->getType()))
5158  continue;
5159 
5160  QualType FieldType = Context.getBaseElementType(Field->getType());
5161 
5162  const RecordType* RT = FieldType->getAs<RecordType>();
5163  if (!RT)
5164  continue;
5165 
5166  CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
5167  if (FieldClassDecl->isInvalidDecl())
5168  continue;
5169  if (FieldClassDecl->hasIrrelevantDestructor())
5170  continue;
5171  // The destructor for an implicit anonymous union member is never invoked.
5172  if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
5173  continue;
5174 
5175  CXXDestructorDecl *Dtor = LookupDestructor(FieldClassDecl);
5176  assert(Dtor && "No dtor found for FieldClassDecl!");
5177  CheckDestructorAccess(Field->getLocation(), Dtor,
5178  PDiag(diag::err_access_dtor_field)
5179  << Field->getDeclName()
5180  << FieldType);
5181 
5182  MarkFunctionReferenced(Location, Dtor);
5183  DiagnoseUseOfDecl(Dtor, Location);
5184  }
5185 
5186  // We only potentially invoke the destructors of potentially constructed
5187  // subobjects.
5188  bool VisitVirtualBases = !ClassDecl->isAbstract();
5189 
5190  llvm::SmallPtrSet<const RecordType *, 8> DirectVirtualBases;
5191 
5192  // Bases.
5193  for (const auto &Base : ClassDecl->bases()) {
5194  // Bases are always records in a well-formed non-dependent class.
5195  const RecordType *RT = Base.getType()->getAs<RecordType>();
5196 
5197  // Remember direct virtual bases.
5198  if (Base.isVirtual()) {
5199  if (!VisitVirtualBases)
5200  continue;
5201  DirectVirtualBases.insert(RT);
5202  }
5203 
5204  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
5205  // If our base class is invalid, we probably can't get its dtor anyway.
5206  if (BaseClassDecl->isInvalidDecl())
5207  continue;
5208  if (BaseClassDecl->hasIrrelevantDestructor())
5209  continue;
5210 
5211  CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
5212  assert(Dtor && "No dtor found for BaseClassDecl!");
5213 
5214  // FIXME: caret should be on the start of the class name
5215  CheckDestructorAccess(Base.getBeginLoc(), Dtor,
5216  PDiag(diag::err_access_dtor_base)
5217  << Base.getType() << Base.getSourceRange(),
5218  Context.getTypeDeclType(ClassDecl));
5219 
5220  MarkFunctionReferenced(Location, Dtor);
5221  DiagnoseUseOfDecl(Dtor, Location);
5222  }
5223 
5224  if (!VisitVirtualBases)
5225  return;
5226 
5227  // Virtual bases.
5228  for (const auto &VBase : ClassDecl->vbases()) {
5229  // Bases are always records in a well-formed non-dependent class.
5230  const RecordType *RT = VBase.getType()->castAs<RecordType>();
5231 
5232  // Ignore direct virtual bases.
5233  if (DirectVirtualBases.count(RT))
5234  continue;
5235 
5236  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
5237  // If our base class is invalid, we probably can't get its dtor anyway.
5238  if (BaseClassDecl->isInvalidDecl())
5239  continue;
5240  if (BaseClassDecl->hasIrrelevantDestructor())
5241  continue;
5242 
5243  CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
5244  assert(Dtor && "No dtor found for BaseClassDecl!");
5245  if (CheckDestructorAccess(
5246  ClassDecl->getLocation(), Dtor,
5247  PDiag(diag::err_access_dtor_vbase)
5248  << Context.getTypeDeclType(ClassDecl) << VBase.getType(),
5249  Context.getTypeDeclType(ClassDecl)) ==
5250  AR_accessible) {
5251  CheckDerivedToBaseConversion(
5252  Context.getTypeDeclType(ClassDecl), VBase.getType(),
5253  diag::err_access_dtor_vbase, 0, ClassDecl->getLocation(),
5254  SourceRange(), DeclarationName(), nullptr);
5255  }
5256 
5257  MarkFunctionReferenced(Location, Dtor);
5258  DiagnoseUseOfDecl(Dtor, Location);
5259  }
5260 }
5261 
5262 void Sema::ActOnDefaultCtorInitializers(Decl *CDtorDecl) {
5263  if (!CDtorDecl)
5264  return;
5265 
5266  if (CXXConstructorDecl *Constructor
5267  = dyn_cast<CXXConstructorDecl>(CDtorDecl)) {
5268  SetCtorInitializers(Constructor, /*AnyErrors=*/false);
5269  DiagnoseUninitializedFields(*this, Constructor);
5270  }
5271 }
5272 
5274  if (!getLangOpts().CPlusPlus)
5275  return false;
5276 
5277  const auto *RD = Context.getBaseElementType(T)->getAsCXXRecordDecl();
5278  if (!RD)
5279  return false;
5280 
5281  // FIXME: Per [temp.inst]p1, we are supposed to trigger instantiation of a
5282  // class template specialization here, but doing so breaks a lot of code.
5283 
5284  // We can't answer whether something is abstract until it has a
5285  // definition. If it's currently being defined, we'll walk back
5286  // over all the declarations when we have a full definition.
5287  const CXXRecordDecl *Def = RD->getDefinition();
5288  if (!Def || Def->isBeingDefined())
5289  return false;
5290 
5291  return RD->isAbstract();
5292 }
5293 
5295  TypeDiagnoser &Diagnoser) {
5296  if (!isAbstractType(Loc, T))
5297  return false;
5298 
5299  T = Context.getBaseElementType(T);
5300  Diagnoser.diagnose(*this, Loc, T);
5301  DiagnoseAbstractType(T->getAsCXXRecordDecl());
5302  return true;
5303 }
5304 
5306  // Check if we've already emitted the list of pure virtual functions
5307  // for this class.
5308  if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
5309  return;
5310 
5311  // If the diagnostic is suppressed, don't emit the notes. We're only
5312  // going to emit them once, so try to attach them to a diagnostic we're
5313  // actually going to show.
5314  if (Diags.isLastDiagnosticIgnored())
5315  return;
5316 
5317  CXXFinalOverriderMap FinalOverriders;
5318  RD->getFinalOverriders(FinalOverriders);
5319 
5320  // Keep a set of seen pure methods so we won't diagnose the same method
5321  // more than once.
5322  llvm::SmallPtrSet<const CXXMethodDecl *, 8> SeenPureMethods;
5323 
5324  for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
5325  MEnd = FinalOverriders.end();
5326  M != MEnd;
5327  ++M) {
5328  for (OverridingMethods::iterator SO = M->second.begin(),
5329  SOEnd = M->second.end();
5330  SO != SOEnd; ++SO) {
5331  // C++ [class.abstract]p4:
5332  // A class is abstract if it contains or inherits at least one
5333  // pure virtual function for which the final overrider is pure
5334  // virtual.
5335 
5336  //
5337  if (SO->second.size() != 1)
5338  continue;
5339 
5340  if (!SO->second.front().Method->isPure())
5341  continue;
5342 
5343  if (!SeenPureMethods.insert(SO->second.front().Method).second)
5344  continue;
5345 
5346  Diag(SO->second.front().Method->getLocation(),
5347  diag::note_pure_virtual_function)
5348  << SO->second.front().Method->getDeclName() << RD->getDeclName();
5349  }
5350  }
5351 
5352  if (!PureVirtualClassDiagSet)
5353  PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
5354  PureVirtualClassDiagSet->insert(RD);
5355 }
5356 
5357 namespace {
5358 struct AbstractUsageInfo {
5359  Sema &S;
5360  CXXRecordDecl *Record;
5361  CanQualType AbstractType;
5362  bool Invalid;
5363 
5364  AbstractUsageInfo(Sema &S, CXXRecordDecl *Record)
5365  : S(S), Record(Record),
5366  AbstractType(S.Context.getCanonicalType(
5367  S.Context.getTypeDeclType(Record))),
5368  Invalid(false) {}
5369 
5370  void DiagnoseAbstractType() {
5371  if (Invalid) return;
5372  S.DiagnoseAbstractType(Record);
5373  Invalid = true;
5374  }
5375 
5376  void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
5377 };
5378 
5379 struct CheckAbstractUsage {
5380  AbstractUsageInfo &Info;
5381  const NamedDecl *Ctx;
5382 
5383  CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
5384  : Info(Info), Ctx(Ctx) {}
5385 
5386  void Visit(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
5387  switch (TL.getTypeLocClass()) {
5388 #define ABSTRACT_TYPELOC(CLASS, PARENT)
5389 #define TYPELOC(CLASS, PARENT) \
5390  case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
5391 #include "clang/AST/TypeLocNodes.def"
5392  }
5393  }
5394 
5395  void Check(FunctionProtoTypeLoc TL, Sema::AbstractDiagSelID Sel) {
5397  for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {
5398  if (!TL.getParam(I))
5399  continue;
5400 
5401  TypeSourceInfo *TSI = TL.getParam(I)->getTypeSourceInfo();
5402  if (TSI) Visit(TSI->getTypeLoc(), Sema::AbstractParamType);
5403  }
5404  }
5405 
5406  void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) {
5408  }
5409 
5411  // Visit the type parameters from a permissive context.
5412  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
5413  TemplateArgumentLoc TAL = TL.getArgLoc(I);
5415  if (TypeSourceInfo *TSI = TAL.getTypeSourceInfo())
5416  Visit(TSI->getTypeLoc(), Sema::AbstractNone);
5417  // TODO: other template argument types?
5418  }
5419  }
5420 
5421  // Visit pointee types from a permissive context.
5422 #define CheckPolymorphic(Type) \
5423  void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
5424  Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
5425  }
5431 
5432  /// Handle all the types we haven't given a more specific
5433  /// implementation for above.
5434  void Check(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
5435  // Every other kind of type that we haven't called out already
5436  // that has an inner type is either (1) sugar or (2) contains that
5437  // inner type in some way as a subobject.
5438  if (TypeLoc Next = TL.getNextTypeLoc())
5439  return Visit(Next, Sel);
5440 
5441  // If there's no inner type and we're in a permissive context,
5442  // don't diagnose.
5443  if (Sel == Sema::AbstractNone) return;
5444 
5445  // Check whether the type matches the abstract type.
5446  QualType T = TL.getType();
5447  if (T->isArrayType()) {
5449  T = Info.S.Context.getBaseElementType(T);
5450  }
5452  if (CT != Info.AbstractType) return;
5453 
5454  // It matched; do some magic.
5455  if (Sel == Sema::AbstractArrayType) {
5456  Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type)
5457  << T << TL.getSourceRange();
5458  } else {
5459  Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl)
5460  << Sel << T << TL.getSourceRange();
5461  }
5462  Info.DiagnoseAbstractType();
5463  }
5464 };
5465 
5466 void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
5468  CheckAbstractUsage(*this, D).Visit(TL, Sel);
5469 }
5470 
5471 }
5472 
5473 /// Check for invalid uses of an abstract type in a method declaration.
5474 static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
5475  CXXMethodDecl *MD) {
5476  // No need to do the check on definitions, which require that
5477  // the return/param types be complete.
5478  if (MD->doesThisDeclarationHaveABody())
5479  return;
5480 
5481  // For safety's sake, just ignore it if we don't have type source
5482  // information. This should never happen for non-implicit methods,
5483  // but...
5484  if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
5485  Info.CheckType(MD, TSI->getTypeLoc(), Sema::AbstractNone);
5486 }
5487 
5488 /// Check for invalid uses of an abstract type within a class definition.
5489 static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
5490  CXXRecordDecl *RD) {
5491  for (auto *D : RD->decls()) {
5492  if (D->isImplicit()) continue;
5493 
5494  // Methods and method templates.
5495  if (isa<CXXMethodDecl>(D)) {
5496  CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(D));
5497  } else if (isa<FunctionTemplateDecl>(D)) {
5498  FunctionDecl *FD = cast<FunctionTemplateDecl>(D)->getTemplatedDecl();
5499  CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(FD));
5500 
5501  // Fields and static variables.
5502  } else if (isa<FieldDecl>(D)) {
5503  FieldDecl *FD = cast<FieldDecl>(D);
5504  if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
5505  Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractFieldType);
5506  } else if (isa<VarDecl>(D)) {
5507  VarDecl *VD = cast<VarDecl>(D);
5508  if (TypeSourceInfo *TSI = VD->getTypeSourceInfo())
5509  Info.CheckType(VD, TSI->getTypeLoc(), Sema::AbstractVariableType);
5510 
5511  // Nested classes and class templates.
5512  } else if (isa<CXXRecordDecl>(D)) {
5513  CheckAbstractClassUsage(Info, cast<CXXRecordDecl>(D));
5514  } else if (isa<ClassTemplateDecl>(D)) {
5516  cast<ClassTemplateDecl>(D)->getTemplatedDecl());
5517  }
5518  }
5519 }
5520 
5522  Attr *ClassAttr = getDLLAttr(Class);
5523  if (!ClassAttr)
5524  return;
5525 
5526  assert(ClassAttr->getKind() == attr::DLLExport);
5527 
5529 
5531  // Don't go any further if this is just an explicit instantiation
5532  // declaration.
5533  return;
5534 
5535  if (S.Context.getTargetInfo().getTriple().isWindowsGNUEnvironment())
5536  S.MarkVTableUsed(Class->getLocation(), Class, true);
5537 
5538  for (Decl *Member : Class->decls()) {
5539  // Defined static variables that are members of an exported base
5540  // class must be marked export too.
5541  auto *VD = dyn_cast<VarDecl>(Member);
5542  if (VD && Member->getAttr<DLLExportAttr>() &&
5543  VD->getStorageClass() == SC_Static &&
5545  S.MarkVariableReferenced(VD->getLocation(), VD);
5546 
5547  auto *MD = dyn_cast<CXXMethodDecl>(Member);
5548  if (!MD)
5549  continue;
5550 
5551  if (Member->getAttr<DLLExportAttr>()) {
5552  if (MD->isUserProvided()) {
5553  // Instantiate non-default class member functions ...
5554 
5555  // .. except for certain kinds of template specializations.
5556  if (TSK == TSK_ImplicitInstantiation && !ClassAttr->isInherited())
5557  continue;
5558 
5559  S.MarkFunctionReferenced(Class->getLocation(), MD);
5560 
5561  // The function will be passed to the consumer when its definition is
5562  // encountered.
5563  } else if (!MD->isTrivial() || MD->isExplicitlyDefaulted() ||
5564  MD->isCopyAssignmentOperator() ||
5565  MD->isMoveAssignmentOperator()) {
5566  // Synthesize and instantiate non-trivial implicit methods, explicitly
5567  // defaulted methods, and the copy and move assignment operators. The
5568  // latter are exported even if they are trivial, because the address of
5569  // an operator can be taken and should compare equal across libraries.
5570  DiagnosticErrorTrap Trap(S.Diags);
5571  S.MarkFunctionReferenced(Class->getLocation(), MD);
5572  if (Trap.hasErrorOccurred()) {
5573  S.Diag(ClassAttr->getLocation(), diag::note_due_to_dllexported_class)
5574  << Class << !S.getLangOpts().CPlusPlus11;
5575  break;
5576  }
5577 
5578  // There is no later point when we will see the definition of this
5579  // function, so pass it to the consumer now.
5581  }
5582  }
5583  }
5584 }
5585 
5587  CXXRecordDecl *Class) {
5588  // Only the MS ABI has default constructor closures, so we don't need to do
5589  // this semantic checking anywhere else.
5591  return;
5592 
5593  CXXConstructorDecl *LastExportedDefaultCtor = nullptr;
5594  for (Decl *Member : Class->decls()) {
5595  // Look for exported default constructors.
5596  auto *CD = dyn_cast<CXXConstructorDecl>(Member);
5597  if (!CD || !CD->isDefaultConstructor())
5598  continue;
5599  auto *Attr = CD->getAttr<DLLExportAttr>();
5600  if (!Attr)
5601  continue;
5602 
5603  // If the class is non-dependent, mark the default arguments as ODR-used so
5604  // that we can properly codegen the constructor closure.
5605  if (!Class->isDependentContext()) {
5606  for (ParmVarDecl *PD : CD->parameters()) {
5607  (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), CD, PD);
5609  }
5610  }
5611 
5612  if (LastExportedDefaultCtor) {
5613  S.Diag(LastExportedDefaultCtor->getLocation(),
5614  diag::err_attribute_dll_ambiguous_default_ctor)
5615  << Class;
5616  S.Diag(CD->getLocation(), diag::note_entity_declared_at)
5617  << CD->getDeclName();
5618  return;
5619  }
5620  LastExportedDefaultCtor = CD;
5621  }
5622 }
5623 
5625  // Mark any compiler-generated routines with the implicit code_seg attribute.
5626  for (auto *Method : Class->methods()) {
5627  if (Method->isUserProvided())
5628  continue;
5629  if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(Method, /*IsDefinition=*/true))
5630  Method->addAttr(A);
5631  }
5632 }
5633 
5634 /// Check class-level dllimport/dllexport attribute.
5636  Attr *ClassAttr = getDLLAttr(Class);
5637 
5638  // MSVC inherits DLL attributes to partial class template specializations.
5639  if (Context.getTargetInfo().getCXXABI().isMicrosoft() && !ClassAttr) {
5640  if (auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(Class)) {
5641  if (Attr *TemplateAttr =
5642  getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
5643  auto *A = cast<InheritableAttr>(TemplateAttr->clone(getASTContext()));
5644  A->setInherited(true);
5645  ClassAttr = A;
5646  }
5647  }
5648  }
5649 
5650  if (!ClassAttr)
5651  return;
5652 
5653  if (!Class->isExternallyVisible()) {
5654  Diag(Class->getLocation(), diag::err_attribute_dll_not_extern)
5655  << Class << ClassAttr;
5656  return;
5657  }
5658 
5659  if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
5660  !ClassAttr->isInherited()) {
5661  // Diagnose dll attributes on members of class with dll attribute.
5662  for (Decl *Member : Class->decls()) {
5663  if (!isa<VarDecl>(Member) && !isa<CXXMethodDecl>(Member))
5664  continue;
5665  InheritableAttr *MemberAttr = getDLLAttr(Member);
5666  if (!MemberAttr || MemberAttr->isInherited() || Member->isInvalidDecl())
5667  continue;
5668 
5669  Diag(MemberAttr->getLocation(),
5670  diag::err_attribute_dll_member_of_dll_class)
5671  << MemberAttr << ClassAttr;
5672  Diag(ClassAttr->getLocation(), diag::note_previous_attribute);
5673  Member->setInvalidDecl();
5674  }
5675  }
5676 
5677  if (Class->getDescribedClassTemplate())
5678  // Don't inherit dll attribute until the template is instantiated.
5679  return;
5680 
5681  // The class is either imported or exported.
5682  const bool ClassExported = ClassAttr->getKind() == attr::DLLExport;
5683 
5684  // Check if this was a dllimport attribute propagated from a derived class to
5685  // a base class template specialization. We don't apply these attributes to
5686  // static data members.
5687  const bool PropagatedImport =
5688  !ClassExported &&
5689  cast<DLLImportAttr>(ClassAttr)->wasPropagatedToBaseTemplate();
5690 
5692 
5693  // Ignore explicit dllexport on explicit class template instantiation declarations.
5694  if (ClassExported && !ClassAttr->isInherited() &&
5696  Class->dropAttr<DLLExportAttr>();
5697  return;
5698  }
5699 
5700  // Force declaration of implicit members so they can inherit the attribute.
5701  ForceDeclarationOfImplicitMembers(Class);
5702 
5703  // FIXME: MSVC's docs say all bases must be exportable, but this doesn't
5704  // seem to be true in practice?
5705 
5706  for (Decl *Member : Class->decls()) {
5707  VarDecl *VD = dyn_cast<VarDecl>(Member);
5708  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Member);
5709 
5710  // Only methods and static fields inherit the attributes.
5711  if (!VD && !MD)
5712  continue;
5713 
5714  if (MD) {
5715  // Don't process deleted methods.
5716  if (MD->isDeleted())
5717  continue;
5718 
5719  if (MD->isInlined()) {
5720  // MinGW does not import or export inline methods.
5721  if (!Context.getTargetInfo().getCXXABI().isMicrosoft() &&
5722  !Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())
5723  continue;
5724 
5725  // MSVC versions before 2015 don't export the move assignment operators
5726  // and move constructor, so don't attempt to import/export them if
5727  // we have a definition.
5728  auto *Ctor = dyn_cast<CXXConstructorDecl>(MD);
5729  if ((MD->isMoveAssignmentOperator() ||
5730  (Ctor && Ctor->isMoveConstructor())) &&
5731  !getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015))
5732  continue;
5733 
5734  // MSVC2015 doesn't export trivial defaulted x-tor but copy assign
5735  // operator is exported anyway.
5736  if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
5737  (Ctor || isa<CXXDestructorDecl>(MD)) && MD->isTrivial())
5738  continue;
5739  }
5740  }
5741 
5742  // Don't apply dllimport attributes to static data members of class template
5743  // instantiations when the attribute is propagated from a derived class.
5744  if (VD && PropagatedImport)
5745  continue;
5746 
5747  if (!cast<NamedDecl>(Member)->isExternallyVisible())
5748  continue;
5749 
5750  if (!getDLLAttr(Member)) {
5751  InheritableAttr *NewAttr = nullptr;
5752 
5753  // Do not export/import inline function when -fno-dllexport-inlines is
5754  // passed. But add attribute for later local static var check.
5755  if (!getLangOpts().DllExportInlines && MD && MD->isInlined() &&
5758  if (ClassExported) {
5759  NewAttr = ::new (getASTContext())
5760  DLLExportStaticLocalAttr(ClassAttr->getRange(),
5761  getASTContext(),
5762  ClassAttr->getSpellingListIndex());
5763  } else {
5764  NewAttr = ::new (getASTContext())
5765  DLLImportStaticLocalAttr(ClassAttr->getRange(),
5766  getASTContext(),
5767  ClassAttr->getSpellingListIndex());
5768  }
5769  } else {
5770  NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
5771  }
5772 
5773  NewAttr->setInherited(true);
5774  Member->addAttr(NewAttr);
5775 
5776  if (MD) {
5777  // Propagate DLLAttr to friend re-declarations of MD that have already
5778  // been constructed.
5779  for (FunctionDecl *FD = MD->getMostRecentDecl(); FD;
5780  FD = FD->getPreviousDecl()) {
5781  if (FD->getFriendObjectKind() == Decl::FOK_None)
5782  continue;
5783  assert(!getDLLAttr(FD) &&
5784  "friend re-decl should not already have a DLLAttr");
5785  NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
5786  NewAttr->setInherited(true);
5787  FD->addAttr(NewAttr);
5788  }
5789  }
5790  }
5791  }
5792 
5793  if (ClassExported)
5794  DelayedDllExportClasses.push_back(Class);
5795 }
5796 
5797 /// Perform propagation of DLL attributes from a derived class to a
5798 /// templated base class for MS compatibility.
5800  CXXRecordDecl *Class, Attr *ClassAttr,
5801  ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc) {
5802  if (getDLLAttr(
5803  BaseTemplateSpec->getSpecializedTemplate()->getTemplatedDecl())) {
5804  // If the base class template has a DLL attribute, don't try to change it.
5805  return;
5806  }
5807 
5808  auto TSK = BaseTemplateSpec->getSpecializationKind();
5809  if (!getDLLAttr(BaseTemplateSpec) &&
5811  TSK == TSK_ImplicitInstantiation)) {
5812  // The template hasn't been instantiated yet (or it has, but only as an
5813  // explicit instantiation declaration or implicit instantiation, which means
5814  // we haven't codegenned any members yet), so propagate the attribute.
5815  auto *NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
5816  NewAttr->setInherited(true);
5817  BaseTemplateSpec->addAttr(NewAttr);
5818 
5819  // If this was an import, mark that we propagated it from a derived class to
5820  // a base class template specialization.
5821  if (auto *ImportAttr = dyn_cast<DLLImportAttr>(NewAttr))
5822  ImportAttr->setPropagatedToBaseTemplate();
5823 
5824  // If the template is already instantiated, checkDLLAttributeRedeclaration()
5825  // needs to be run again to work see the new attribute. Otherwise this will
5826  // get run whenever the template is instantiated.
5827  if (TSK != TSK_Undeclared)
5828  checkClassLevelDLLAttribute(BaseTemplateSpec);
5829 
5830  return;
5831  }
5832 
5833  if (getDLLAttr(BaseTemplateSpec)) {
5834  // The template has already been specialized or instantiated with an
5835  // attribute, explicitly or through propagation. We should not try to change
5836  // it.
5837  return;
5838  }
5839 
5840  // The template was previously instantiated or explicitly specialized without
5841  // a dll attribute, It's too late for us to add an attribute, so warn that
5842  // this is unsupported.
5843  Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)
5844  << BaseTemplateSpec->isExplicitSpecialization();
5845  Diag(ClassAttr->getLocation(), diag::note_attribute);
5846  if (BaseTemplateSpec->isExplicitSpecialization()) {
5847  Diag(BaseTemplateSpec->getLocation(),
5848  diag::note_template_class_explicit_specialization_was_here)
5849  << BaseTemplateSpec;
5850  } else {
5851  Diag(BaseTemplateSpec->getPointOfInstantiation(),
5852  diag::note_template_class_instantiation_was_here)
5853  << BaseTemplateSpec;
5854  }
5855 }
5856 
5858  SourceLocation DefaultLoc) {
5859  switch (S.getSpecialMember(MD)) {
5861  S.DefineImplicitDefaultConstructor(DefaultLoc,
5862  cast<CXXConstructorDecl>(MD));
5863  break;
5865  S.DefineImplicitCopyConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
5866  break;
5868  S.DefineImplicitCopyAssignment(DefaultLoc, MD);
5869  break;
5870  case Sema::CXXDestructor:
5871  S.DefineImplicitDestructor(DefaultLoc, cast<CXXDestructorDecl>(MD));
5872  break;
5874  S.DefineImplicitMoveConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
5875  break;
5877  S.DefineImplicitMoveAssignment(DefaultLoc, MD);
5878  break;
5879  case Sema::CXXInvalid:
5880  llvm_unreachable("Invalid special member.");
5881  }
5882 }
5883 
5884 /// Determine whether a type is permitted to be passed or returned in
5885 /// registers, per C++ [class.temporary]p3.
5888  if (D->isDependentType() || D->isInvalidDecl())
5889  return false;
5890 
5891  // Clang <= 4 used the pre-C++11 rule, which ignores move operations.
5892  // The PS4 platform ABI follows the behavior of Clang 3.2.
5893  if (CCK == TargetInfo::CCK_ClangABI4OrPS4)
5894  return !D->hasNonTrivialDestructorForCall() &&
5896 
5897  if (CCK == TargetInfo::CCK_MicrosoftWin64) {
5898  bool CopyCtorIsTrivial = false, CopyCtorIsTrivialForCall = false;
5899  bool DtorIsTrivialForCall = false;
5900 
5901  // If a class has at least one non-deleted, trivial copy constructor, it
5902  // is passed according to the C ABI. Otherwise, it is passed indirectly.
5903  //
5904  // Note: This permits classes with non-trivial copy or move ctors to be
5905  // passed in registers, so long as they *also* have a trivial copy ctor,
5906  // which is non-conforming.
5907  if (D->needsImplicitCopyConstructor()) {
5909  if (D->hasTrivialCopyConstructor())
5910  CopyCtorIsTrivial = true;
5912  CopyCtorIsTrivialForCall = true;
5913  }
5914  } else {
5915  for (const CXXConstructorDecl *CD : D->ctors()) {
5916  if (CD->isCopyConstructor() && !CD->isDeleted()) {
5917  if (CD->isTrivial())
5918  CopyCtorIsTrivial = true;
5919  if (CD->isTrivialForCall())
5920  CopyCtorIsTrivialForCall = true;
5921  }
5922  }
5923  }
5924 
5925  if (D->needsImplicitDestructor()) {
5926  if (!D->defaultedDestructorIsDeleted() &&
5928  DtorIsTrivialForCall = true;
5929  } else if (const auto *DD = D->getDestructor()) {
5930  if (!DD->isDeleted() && DD->isTrivialForCall())
5931  DtorIsTrivialForCall = true;
5932  }
5933 
5934  // If the copy ctor and dtor are both trivial-for-calls, pass direct.
5935  if (CopyCtorIsTrivialForCall && DtorIsTrivialForCall)
5936  return true;
5937 
5938  // If a class has a destructor, we'd really like to pass it indirectly
5939  // because it allows us to elide copies. Unfortunately, MSVC makes that
5940  // impossible for small types, which it will pass in a single register or
5941  // stack slot. Most objects with dtors are large-ish, so handle that early.
5942  // We can't call out all large objects as being indirect because there are
5943  // multiple x64 calling conventions and the C++ ABI code shouldn't dictate
5944  // how we pass large POD types.
5945 
5946  // Note: This permits small classes with nontrivial destructors to be
5947  // passed in registers, which is non-conforming.
5948  if (CopyCtorIsTrivial &&
5949  S.getASTContext().getTypeSize(D->getTypeForDecl()) <= 64)
5950  return true;
5951  return false;
5952  }
5953 
5954  // Per C++ [class.temporary]p3, the relevant condition is:
5955  // each copy constructor, move constructor, and destructor of X is
5956  // either trivial or deleted, and X has at least one non-deleted copy
5957  // or move constructor
5958  bool HasNonDeletedCopyOrMove = false;
5959 
5960  if (D->needsImplicitCopyConstructor() &&
5963  return false;
5964  HasNonDeletedCopyOrMove = true;
5965  }
5966 
5967  if (S.getLangOpts().CPlusPlus11 && D->needsImplicitMoveConstructor() &&
5970  return false;
5971  HasNonDeletedCopyOrMove = true;
5972  }
5973 
5976  return false;
5977 
5978  for (const CXXMethodDecl *MD : D->methods()) {
5979  if (MD->isDeleted())
5980  continue;
5981 
5982  auto *CD = dyn_cast<CXXConstructorDecl>(MD);
5983  if (CD && CD->isCopyOrMoveConstructor())
5984  HasNonDeletedCopyOrMove = true;
5985  else if (!isa<CXXDestructorDecl>(MD))
5986  continue;
5987 
5988  if (!MD->isTrivialForCall())
5989  return false;
5990  }
5991 
5992  return HasNonDeletedCopyOrMove;
5993 }
5994 
5995 /// Perform semantic checks on a class definition that has been
5996 /// completing, introducing implicitly-declared members, checking for
5997 /// abstract types, etc.
5999  if (!Record)
6000  return;
6001 
6002  if (Record->isAbstract() && !Record->isInvalidDecl()) {
6003  AbstractUsageInfo Info(*this, Record);
6004  CheckAbstractClassUsage(Info, Record);
6005  }
6006 
6007  // If this is not an aggregate type and has no user-declared constructor,
6008  // complain about any non-static data members of reference or const scalar
6009  // type, since they will never get initializers.
6010  if (!Record->isInvalidDecl() && !Record->isDependentType() &&
6011  !Record->isAggregate() && !Record->hasUserDeclaredConstructor() &&
6012  !Record->isLambda()) {
6013  bool Complained = false;
6014  for (const auto *F : Record->fields()) {
6015  if (F->hasInClassInitializer() || F->isUnnamedBitfield())
6016  continue;
6017 
6018  if (F->getType()->isReferenceType() ||
6019  (F->getType().isConstQualified() && F->getType()->isScalarType())) {
6020  if (!Complained) {
6021  Diag(Record->getLocation(), diag::warn_no_constructor_for_refconst)
6022  << Record->getTagKind() << Record;
6023  Complained = true;
6024  }
6025 
6026  Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
6027  << F->getType()->isReferenceType()
6028  << F->getDeclName();
6029  }
6030  }
6031  }
6032 
6033  if (Record->getIdentifier()) {
6034  // C++ [class.mem]p13:
6035  // If T is the name of a class, then each of the following shall have a
6036  // name different from T:
6037  // - every member of every anonymous union that is a member of class T.
6038  //
6039  // C++ [class.mem]p14:
6040  // In addition, if class T has a user-declared constructor (12.1), every
6041  // non-static data member of class T shall have a name different from T.
6042  DeclContext::lookup_result R = Record->lookup(Record->getDeclName());
6043  for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
6044  ++I) {
6045  NamedDecl *D = (*I)->getUnderlyingDecl();
6046  if (((isa<FieldDecl>(D) || isa<UnresolvedUsingValueDecl>(D)) &&
6047  Record->hasUserDeclaredConstructor()) ||
6048  isa<IndirectFieldDecl>(D)) {
6049  Diag((*I)->getLocation(), diag::err_member_name_of_class)
6050  << D->getDeclName();
6051  break;
6052  }
6053  }
6054  }
6055 
6056  // Warn if the class has virtual methods but non-virtual public destructor.
6057  if (Record->isPolymorphic() && !Record->isDependentType()) {
6058  CXXDestructorDecl *dtor = Record->getDestructor();
6059  if ((!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public)) &&
6060  !Record->hasAttr<FinalAttr>())
6061  Diag(dtor ? dtor->getLocation() : Record->getLocation(),
6062  diag::warn_non_virtual_dtor) << Context.getRecordType(Record);
6063  }
6064 
6065  if (Record->isAbstract()) {
6066  if (FinalAttr *FA = Record->getAttr<FinalAttr>()) {
6067  Diag(Record->getLocation(), diag::warn_abstract_final_class)
6068  << FA->isSpelledAsSealed();
6069  DiagnoseAbstractType(Record);
6070  }
6071  }
6072 
6073  // See if trivial_abi has to be dropped.
6074  if (Record->hasAttr<TrivialABIAttr>())
6075  checkIllFormedTrivialABIStruct(*Record);
6076 
6077  // Set HasTrivialSpecialMemberForCall if the record has attribute
6078  // "trivial_abi".
6079  bool HasTrivialABI = Record->hasAttr<TrivialABIAttr>();
6080 
6081  if (HasTrivialABI)
6083 
6084  bool HasMethodWithOverrideControl = false,
6085  HasOverridingMethodWithoutOverrideControl = false;
6086  if (!Record->isDependentType()) {
6087  for (auto *M : Record->methods()) {
6088  // See if a method overloads virtual methods in a base
6089  // class without overriding any.
6090  if (!M->isStatic())
6091  DiagnoseHiddenVirtualMethods(M);
6092  if (M->hasAttr<OverrideAttr>())
6093  HasMethodWithOverrideControl = true;
6094  else if (M->size_overridden_methods() > 0)
6095  HasOverridingMethodWithoutOverrideControl = true;
6096  // Check whether the explicitly-defaulted special members are valid.
6097  if (!M->isInvalidDecl() && M->isExplicitlyDefaulted())
6098  CheckExplicitlyDefaultedSpecialMember(M);
6099 
6100  // For an explicitly defaulted or deleted special member, we defer
6101  // determining triviality until the class is complete. That time is now!
6102  CXXSpecialMember CSM = getSpecialMember(M);
6103  if (!M->isImplicit() && !M->isUserProvided()) {
6104  if (CSM != CXXInvalid) {
6105  M->setTrivial(SpecialMemberIsTrivial(M, CSM));
6106  // Inform the class that we've finished declaring this member.
6108  M->setTrivialForCall(
6109  HasTrivialABI ||
6110  SpecialMemberIsTrivial(M, CSM, TAH_ConsiderTrivialABI));
6111  Record->setTrivialForCallFlags(M);
6112  }
6113  }
6114 
6115  // Set triviality for the purpose of calls if this is a user-provided
6116  // copy/move constructor or destructor.
6117  if ((CSM == CXXCopyConstructor || CSM == CXXMoveConstructor ||
6118  CSM == CXXDestructor) && M->isUserProvided()) {
6119  M->setTrivialForCall(HasTrivialABI);
6120  Record->setTrivialForCallFlags(M);
6121  }
6122 
6123  if (!M->isInvalidDecl() && M->isExplicitlyDefaulted() &&
6124  M->hasAttr<DLLExportAttr>()) {
6125  if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
6126  M->isTrivial() &&
6127  (CSM == CXXDefaultConstructor || CSM == CXXCopyConstructor ||
6128  CSM == CXXDestructor))
6129  M->dropAttr<DLLExportAttr>();
6130 
6131  if (M->hasAttr<DLLExportAttr>()) {
6132  DefineImplicitSpecialMember(*this, M, M->getLocation());
6133  ActOnFinishInlineFunctionDef(M);
6134  }
6135  }
6136  }
6137  }
6138 
6139  if (HasMethodWithOverrideControl &&
6140  HasOverridingMethodWithoutOverrideControl) {
6141  // At least one method has the 'override' control declared.
6142  // Diagnose all other overridden methods which do not have 'override' specified on them.
6143  for (auto *M : Record->methods())
6144  DiagnoseAbsenceOfOverrideControl(M);
6145  }
6146 
6147  // ms_struct is a request to use the same ABI rules as MSVC. Check
6148  // whether this class uses any C++ features that are implemented
6149  // completely differently in MSVC, and if so, emit a diagnostic.
6150  // That diagnostic defaults to an error, but we allow projects to
6151  // map it down to a warning (or ignore it). It's a fairly common
6152  // practice among users of the ms_struct pragma to mass-annotate
6153  // headers, sweeping up a bunch of types that the project doesn't
6154  // really rely on MSVC-compatible layout for. We must therefore
6155  // support "ms_struct except for C++ stuff" as a secondary ABI.
6156  if (Record->isMsStruct(Context) &&
6157  (Record->isPolymorphic() || Record->getNumBases())) {
6158  Diag(Record->getLocation(), diag::warn_cxx_ms_struct);
6159  }
6160 
6161  checkClassLevelDLLAttribute(Record);
6162  checkClassLevelCodeSegAttribute(Record);
6163 
6164  bool ClangABICompat4 =
6165  Context.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver4;
6167  Context.getTargetInfo().getCallingConvKind(ClangABICompat4);
6168  bool CanPass = canPassInRegisters(*this, Record, CCK);
6169 
6170  // Do not change ArgPassingRestrictions if it has already been set to
6171  // APK_CanNeverPassInRegs.
6173  Record->setArgPassingRestrictions(CanPass
6176 
6177  // If canPassInRegisters returns true despite the record having a non-trivial
6178  // destructor, the record is destructed in the callee. This happens only when
6179  // the record or one of its subobjects has a field annotated with trivial_abi
6180  // or a field qualified with ObjC __strong/__weak.
6182  Record->setParamDestroyedInCallee(true);
6183  else if (Record->hasNonTrivialDestructor())
6184  Record->setParamDestroyedInCallee(CanPass);
6185 
6186  if (getLangOpts().ForceEmitVTables) {
6187  // If we want to emit all the vtables, we need to mark it as used. This
6188  // is especially required for cases like vtable assumption loads.
6189  MarkVTableUsed(Record->getInnerLocStart(), Record);
6190  }
6191 }
6192 
6193 /// Look up the special member function that would be called by a special
6194 /// member function for a subobject of class type.
6195 ///
6196 /// \param Class The class type of the subobject.
6197 /// \param CSM The kind of special member function.
6198 /// \param FieldQuals If the subobject is a field, its cv-qualifiers.
6199 /// \param ConstRHS True if this is a copy operation with a const object
6200 /// on its RHS, that is, if the argument to the outer special member
6201 /// function is 'const' and this is not a field marked 'mutable'.
6203  Sema &S, CXXRecordDecl *Class, Sema::CXXSpecialMember CSM,
6204  unsigned FieldQuals, bool ConstRHS) {
6205  unsigned LHSQuals = 0;
6206  if (CSM == Sema::CXXCopyAssignment || CSM == Sema::CXXMoveAssignment)
6207  LHSQuals = FieldQuals;
6208 
6209  unsigned RHSQuals = FieldQuals;
6210  if (CSM == Sema::CXXDefaultConstructor || CSM == Sema::CXXDestructor)
6211  RHSQuals = 0;
6212  else if (ConstRHS)
6213  RHSQuals |= Qualifiers::Const;
6214 
6215  return S.LookupSpecialMember(Class, CSM,
6216  RHSQuals & Qualifiers::Const,
6217  RHSQuals & Qualifiers::Volatile,
6218  false,
6219  LHSQuals & Qualifiers::Const,
6220  LHSQuals & Qualifiers::Volatile);
6221 }
6222 
6224  Sema &S;
6225  SourceLocation UseLoc;
6226 
6227  /// A mapping from the base classes through which the constructor was
6228  /// inherited to the using shadow declaration in that base class (or a null
6229  /// pointer if the constructor was declared in that base class).
6230  llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
6231  InheritedFromBases;
6232 
6233 public:
6236  : S(S), UseLoc(UseLoc) {
6237  bool DiagnosedMultipleConstructedBases = false;
6238  CXXRecordDecl *ConstructedBase = nullptr;
6239  UsingDecl *ConstructedBaseUsing = nullptr;
6240 
6241  // Find the set of such base class subobjects and check that there's a
6242  // unique constructed subobject.
6243  for (auto *D : Shadow->redecls()) {
6244  auto *DShadow = cast<ConstructorUsingShadowDecl>(D);
6245  auto *DNominatedBase = DShadow->getNominatedBaseClass();
6246  auto *DConstructedBase = DShadow->getConstructedBaseClass();
6247 
6248  InheritedFromBases.insert(
6249  std::make_pair(DNominatedBase->getCanonicalDecl(),
6250  DShadow->getNominatedBaseClassShadowDecl()));
6251  if (DShadow->constructsVirtualBase())
6252  InheritedFromBases.insert(
6253  std::make_pair(DConstructedBase->getCanonicalDecl(),
6254  DShadow->getConstructedBaseClassShadowDecl()));
6255  else
6256  assert(DNominatedBase == DConstructedBase);
6257 
6258  // [class.inhctor.init]p2:
6259  // If the constructor was inherited from multiple base class subobjects
6260  // of type B, the program is ill-formed.
6261  if (!ConstructedBase) {
6262  ConstructedBase = DConstructedBase;
6263  ConstructedBaseUsing = D->getUsingDecl();
6264  } else if (ConstructedBase != DConstructedBase &&
6265  !Shadow->isInvalidDecl()) {
6266  if (!DiagnosedMultipleConstructedBases) {
6267  S.Diag(UseLoc, diag::err_ambiguous_inherited_constructor)
6268  << Shadow->getTargetDecl();
6269  S.Diag(ConstructedBaseUsing->getLocation(),
6270  diag::note_ambiguous_inherited_constructor_using)
6271  << ConstructedBase;
6272  DiagnosedMultipleConstructedBases = true;
6273  }
6274  S.Diag(D->getUsingDecl()->getLocation(),
6275  diag::note_ambiguous_inherited_constructor_using)
6276  << DConstructedBase;
6277  }
6278  }
6279 
6280  if (DiagnosedMultipleConstructedBases)
6281  Shadow->setInvalidDecl();
6282  }
6283 
6284  /// Find the constructor to use for inherited construction of a base class,
6285  /// and whether that base class constructor inherits the constructor from a
6286  /// virtual base class (in which case it won't actually invoke it).
6287  std::pair<CXXConstructorDecl *, bool>
6289  auto It = InheritedFromBases.find(Base->getCanonicalDecl());
6290  if (It == InheritedFromBases.end())
6291  return std::make_pair(nullptr, false);
6292 
6293  // This is an intermediary class.
6294  if (It->second)
6295  return std::make_pair(
6296  S.findInheritingConstructor(UseLoc, Ctor, It->second),
6297  It->second->constructsVirtualBase());
6298 
6299  // This is the base class from which the constructor was inherited.
6300  return std::make_pair(Ctor, false);
6301  }
6302 };
6303 
6304 /// Is the special member function which would be selected to perform the
6305 /// specified operation on the specified class type a constexpr constructor?
6306 static bool
6308  Sema::CXXSpecialMember CSM, unsigned Quals,
6309  bool ConstRHS,
6310  CXXConstructorDecl *InheritedCtor = nullptr,
6311  Sema::InheritedConstructorInfo *Inherited = nullptr) {
6312  // If we're inheriting a constructor, see if we need to call it for this base
6313  // class.
6314  if (InheritedCtor) {
6315  assert(CSM == Sema::CXXDefaultConstructor);
6316  auto BaseCtor =
6317  Inherited->findConstructorForBase(ClassDecl, InheritedCtor).first;
6318  if (BaseCtor)
6319  return BaseCtor->isConstexpr();
6320  }
6321 
6322  if (CSM == Sema::CXXDefaultConstructor)
6323  return ClassDecl->hasConstexprDefaultConstructor();
6324 
6326  lookupCallFromSpecialMember(S, ClassDecl, CSM, Quals, ConstRHS);
6327  if (!SMOR.getMethod())
6328  // A constructor we wouldn't select can't be "involved in initializing"
6329  // anything.
6330  return true;
6331  return SMOR.getMethod()->isConstexpr();
6332 }
6333 
6334 /// Determine whether the specified special member function would be constexpr
6335 /// if it were implicitly defined.
6337  Sema &S, CXXRecordDecl *ClassDecl, Sema::CXXSpecialMember CSM,
6338  bool ConstArg, CXXConstructorDecl *InheritedCtor = nullptr,
6339  Sema::InheritedConstructorInfo *Inherited = nullptr) {
6340  if (!S.getLangOpts().CPlusPlus11)
6341  return false;
6342 
6343  // C++11 [dcl.constexpr]p4:
6344  // In the definition of a constexpr constructor [...]
6345  bool Ctor = true;
6346  switch (CSM) {
6348  if (Inherited)
6349  break;
6350  // Since default constructor lookup is essentially trivial (and cannot
6351  // involve, for instance, template instantiation), we compute whether a
6352  // defaulted default constructor is constexpr directly within CXXRecordDecl.
6353  //
6354  // This is important for performance; we need to know whether the default
6355  // constructor is constexpr to determine whether the type is a literal type.
6356  return ClassDecl->defaultedDefaultConstructorIsConstexpr();
6357 
6360  // For copy or move constructors, we need to perform overload resolution.
6361  break;
6362 
6365  if (!S.getLangOpts().CPlusPlus14)
6366  return false;
6367  // In C++1y, we need to perform overload resolution.
6368  Ctor = false;
6369  break;
6370 
6371  case Sema::CXXDestructor:
6372  case Sema::CXXInvalid:
6373  return false;
6374  }
6375 
6376  // -- if the class is a non-empty union, or for each non-empty anonymous
6377  // union member of a non-union class, exactly one non-static data member
6378  // shall be initialized; [DR1359]
6379  //
6380  // If we squint, this is guaranteed, since exactly one non-static data member
6381  // will be initialized (if the constructor isn't deleted), we just don't know
6382  // which one.
6383  if (Ctor && ClassDecl->isUnion())
6384  return CSM == Sema::CXXDefaultConstructor
6385  ? ClassDecl->hasInClassInitializer() ||
6386  !ClassDecl->hasVariantMembers()
6387  : true;
6388 
6389  // -- the class shall not have any virtual base classes;
6390  if (Ctor && ClassDecl->getNumVBases())
6391  return false;
6392 
6393  // C++1y [class.copy]p26:
6394  // -- [the class] is a literal type, and
6395  if (!Ctor && !ClassDecl->isLiteral())
6396  return false;
6397 
6398  // -- every constructor involved in initializing [...] base class
6399  // sub-objects shall be a constexpr constructor;
6400  // -- the assignment operator selected to copy/move each direct base
6401  // class is a constexpr function, and
6402  for (const auto &B : ClassDecl->bases()) {
6403  const RecordType *BaseType = B.getType()->getAs<RecordType>();
6404  if (!BaseType) continue;
6405 
6406  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
6407  if (!specialMemberIsConstexpr(S, BaseClassDecl, CSM, 0, ConstArg,
6408  InheritedCtor, Inherited))
6409  return false;
6410  }
6411 
6412  // -- every constructor involved in initializing non-static data members
6413  // [...] shall be a constexpr constructor;
6414  // -- every non-static data member and base class sub-object shall be
6415  // initialized
6416  // -- for each non-static data member of X that is of class type (or array
6417  // thereof), the assignment operator selected to copy/move that member is
6418  // a constexpr function
6419  for (const auto *F : ClassDecl->fields()) {
6420  if (F->isInvalidDecl())
6421  continue;
6422  if (CSM == Sema::CXXDefaultConstructor && F->hasInClassInitializer())
6423  continue;
6424  QualType BaseType = S.Context.getBaseElementType(F->getType());
6425  if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
6426  CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
6427  if (!specialMemberIsConstexpr(S, FieldRecDecl, CSM,
6428  BaseType.getCVRQualifiers(),
6429  ConstArg && !F->isMutable()))
6430  return false;
6431  } else if (CSM == Sema::CXXDefaultConstructor) {
6432  return false;
6433  }
6434  }
6435 
6436  // All OK, it's constexpr!
6437  return true;
6438 }
6439 
6444 
6447  auto CSM = S.getSpecialMember(MD);
6448  if (CSM != Sema::CXXInvalid)
6449  return ComputeDefaultedSpecialMemberExceptionSpec(S, Loc, MD, CSM, nullptr);
6450 
6451  auto *CD = cast<CXXConstructorDecl>(MD);
6452  assert(CD->getInheritedConstructor() &&
6453  "only special members have implicit exception specs");
6455  S, Loc, CD->getInheritedConstructor().getShadowDecl());
6457  S, Loc, CD, Sema::CXXDefaultConstructor, &ICI);
6458 }
6459 
6461  CXXMethodDecl *MD) {
6463 
6464  // Build an exception specification pointing back at this member.
6466  EPI.ExceptionSpec.SourceDecl = MD;
6467 
6468  // Set the calling convention to the default for C++ instance methods.
6469  EPI.ExtInfo = EPI.ExtInfo.withCallingConv(
6470  S.Context.getDefaultCallingConvention(/*IsVariadic=*/false,
6471  /*IsCXXMethod=*/true));
6472  return EPI;
6473 }
6474 
6476  const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
6477  if (FPT->getExceptionSpecType() != EST_Unevaluated)
6478  return;
6479 
6480  // Evaluate the exception specification.
6481  auto IES = computeImplicitExceptionSpec(*this, Loc, MD);
6482  auto ESI = IES.getExceptionSpec();
6483 
6484  // Update the type of the special member to use it.
6485  UpdateExceptionSpec(MD, ESI);
6486 
6487  // A user-provided destructor can be defined outside the class. When that
6488  // happens, be sure to update the exception specification on both
6489  // declarations.
6490  const FunctionProtoType *CanonicalFPT =
6492  if (CanonicalFPT->getExceptionSpecType() == EST_Unevaluated)
6493  UpdateExceptionSpec(MD->getCanonicalDecl(), ESI);
6494 }
6495 
6497  CXXRecordDecl *RD = MD->getParent();
6498  CXXSpecialMember CSM = getSpecialMember(MD);
6499 
6500  assert(MD->isExplicitlyDefaulted() && CSM != CXXInvalid &&
6501  "not an explicitly-defaulted special member");
6502 
6503  // Whether this was the first-declared instance of the constructor.
6504  // This affects whether we implicitly add an exception spec and constexpr.
6505  bool First = MD == MD->getCanonicalDecl();
6506 
6507  bool HadError = false;
6508 
6509  // C++11 [dcl.fct.def.default]p1:
6510  // A function that is explicitly defaulted shall
6511  // -- be a special member function (checked elsewhere),
6512  // -- have the same type (except for ref-qualifiers, and except that a
6513  // copy operation can take a non-const reference) as an implicit
6514  // declaration, and
6515  // -- not have default arguments.
6516  // C++2a changes the second bullet to instead delete the function if it's
6517  // defaulted on its first declaration, unless it's "an assignment operator,
6518  // and its return type differs or its parameter type is not a reference".
6519  bool DeleteOnTypeMismatch = getLangOpts().CPlusPlus2a && First;
6520  bool ShouldDeleteForTypeMismatch = false;
6521  unsigned ExpectedParams = 1;
6522  if (CSM == CXXDefaultConstructor || CSM == CXXDestructor)
6523  ExpectedParams = 0;
6524  if (MD->getNumParams() != ExpectedParams) {
6525  // This checks for default arguments: a copy or move constructor with a
6526  // default argument is classified as a default constructor, and assignment
6527  // operations and destructors can't have default arguments.
6528  Diag(MD->getLocation(), diag::err_defaulted_special_member_params)
6529  << CSM << MD->getSourceRange();
6530  HadError = true;
6531  } else if (MD->isVariadic()) {
6532  if (DeleteOnTypeMismatch)
6533  ShouldDeleteForTypeMismatch = true;
6534  else {
6535  Diag(MD->getLocation(), diag::err_defaulted_special_member_variadic)
6536  << CSM << MD->getSourceRange();
6537  HadError = true;
6538  }
6539  }
6540 
6542 
6543  bool CanHaveConstParam = false;
6544  if (CSM == CXXCopyConstructor)
6545  CanHaveConstParam = RD->implicitCopyConstructorHasConstParam();
6546  else if (CSM == CXXCopyAssignment)
6547  CanHaveConstParam = RD->implicitCopyAssignmentHasConstParam();
6548 
6549  QualType ReturnType = Context.VoidTy;
6550  if (CSM == CXXCopyAssignment || CSM == CXXMoveAssignment) {
6551  // Check for return type matching.
6552  ReturnType = Type->getReturnType();
6553 
6554  QualType DeclType = Context.getTypeDeclType(RD);
6555  DeclType = Context.getAddrSpaceQualType(DeclType, MD->getTypeQualifiers().getAddressSpace());
6556  QualType ExpectedReturnType = Context.getLValueReferenceType(DeclType);
6557 
6558  if (!Context.hasSameType(ReturnType, ExpectedReturnType)) {
6559  Diag(MD->getLocation(), diag::err_defaulted_special_member_return_type)
6560  << (CSM == CXXMoveAssignment) << ExpectedReturnType;
6561  HadError = true;
6562  }
6563 
6564  // A defaulted special member cannot have cv-qualifiers.
6565  if (Type->getTypeQuals().hasConst() || Type->getTypeQuals().hasVolatile()) {
6566  if (DeleteOnTypeMismatch)
6567  ShouldDeleteForTypeMismatch = true;
6568  else {
6569  Diag(MD->getLocation(), diag::err_defaulted_special_member_quals)
6570  << (CSM == CXXMoveAssignment) << getLangOpts().CPlusPlus14;
6571  HadError = true;
6572  }
6573  }
6574  }
6575 
6576  // Check for parameter type matching.
6577  QualType ArgType = ExpectedParams ? Type->getParamType(0) : QualType();
6578  bool HasConstParam = false;
6579  if (ExpectedParams && ArgType->isReferenceType()) {
6580  // Argument must be reference to possibly-const T.
6581  QualType ReferentType = ArgType->getPointeeType();
6582  HasConstParam = ReferentType.isConstQualified();
6583 
6584  if (ReferentType.isVolatileQualified()) {
6585  if (DeleteOnTypeMismatch)
6586  ShouldDeleteForTypeMismatch = true;
6587  else {
6588  Diag(MD->getLocation(),
6589  diag::err_defaulted_special_member_volatile_param) << CSM;
6590  HadError = true;
6591  }
6592  }
6593 
6594  if (HasConstParam && !CanHaveConstParam) {
6595  if (DeleteOnTypeMismatch)
6596  ShouldDeleteForTypeMismatch = true;
6597  else if (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment) {
6598  Diag(MD->getLocation(),
6599  diag::err_defaulted_special_member_copy_const_param)
6600  << (CSM == CXXCopyAssignment);
6601  // FIXME: Explain why this special member can't be const.
6602  HadError = true;
6603  } else {
6604  Diag(MD->getLocation(),
6605  diag::err_defaulted_special_member_move_const_param)
6606  << (CSM == CXXMoveAssignment);
6607  HadError = true;
6608  }
6609  }
6610  } else if (ExpectedParams) {
6611  // A copy assignment operator can take its argument by value, but a
6612  // defaulted one cannot.
6613  assert(CSM == CXXCopyAssignment && "unexpected non-ref argument");
6614  Diag(MD->getLocation(), diag::err_defaulted_copy_assign_not_ref);
6615  HadError = true;
6616  }
6617 
6618  // C++11 [dcl.fct.def.default]p2:
6619  // An explicitly-defaulted function may be declared constexpr only if it
6620  // would have been implicitly declared as constexpr,
6621  // Do not apply this rule to members of class templates, since core issue 1358
6622  // makes such functions always instantiate to constexpr functions. For
6623  // functions which cannot be constexpr (for non-constructors in C++11 and for
6624  // destructors in C++1y), this is checked elsewhere.
6625  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
6626  HasConstParam);
6627  if ((getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD)
6628  : isa<CXXConstructorDecl>(MD)) &&
6629  MD->isConstexpr() && !Constexpr &&
6631  Diag(MD->getBeginLoc(), diag::err_incorrect_defaulted_constexpr) << CSM;
6632  // FIXME: Explain why the special member can't be constexpr.
6633  HadError = true;
6634  }
6635 
6636  // and may have an explicit exception-specification only if it is compatible
6637  // with the exception-specification on the implicit declaration.
6638  if (Type->hasExceptionSpec()) {
6639  // Delay the check if this is the first declaration of the special member,
6640  // since we may not have parsed some necessary in-class initializers yet.
6641  if (First) {
6642  // If the exception specification needs to be instantiated, do so now,
6643  // before we clobber it with an EST_Unevaluated specification below.
6644  if (Type->getExceptionSpecType() == EST_Uninstantiated) {
6645  InstantiateExceptionSpec(MD->getBeginLoc(), MD);
6646  Type = MD->getType()->getAs<FunctionProtoType>();
6647  }
6648  DelayedDefaultedMemberExceptionSpecs.push_back(std::make_pair(MD, Type));
6649  } else
6650  CheckExplicitlyDefaultedMemberExceptionSpec(MD, Type);
6651  }
6652 
6653  // If a function is explicitly defaulted on its first declaration,
6654  if (First) {
6655  // -- it is implicitly considered to be constexpr if the implicit
6656  // definition would be,
6657  MD->setConstexpr(Constexpr);
6658 
6659  // -- it is implicitly considered to have the same exception-specification
6660  // as if it had been implicitly declared,
6663  EPI.ExceptionSpec.SourceDecl = MD;
6664  MD->setType(Context.getFunctionType(ReturnType,
6665  llvm::makeArrayRef(&ArgType,
6666  ExpectedParams),
6667  EPI));
6668  }
6669 
6670  if (ShouldDeleteForTypeMismatch || ShouldDeleteSpecialMember(MD, CSM)) {
6671  if (First) {
6672  SetDeclDeleted(MD, MD->getLocation());
6673  if (!inTemplateInstantiation() && !HadError) {
6674  Diag(MD->getLocation(), diag::warn_defaulted_method_deleted) << CSM;
6675  if (ShouldDeleteForTypeMismatch) {
6676  Diag(MD->getLocation(), diag::note_deleted_type_mismatch) << CSM;
6677  } else {
6678  ShouldDeleteSpecialMember(MD, CSM, nullptr, /*Diagnose*/true);
6679  }
6680  }
6681  if (ShouldDeleteForTypeMismatch && !HadError) {
6682  Diag(MD->getLocation(),
6683  diag::warn_cxx17_compat_defaulted_method_type_mismatch) << CSM;
6684  }
6685  } else {
6686  // C++11 [dcl.fct.def.default]p4:
6687  // [For a] user-provided explicitly-defaulted function [...] if such a
6688  // function is implicitly defined as deleted, the program is ill-formed.
6689  Diag(MD->getLocation(), diag::err_out_of_line_default_deletes) << CSM;
6690  assert(!ShouldDeleteForTypeMismatch && "deleted non-first decl");
6691  ShouldDeleteSpecialMember(MD, CSM, nullptr, /*Diagnose*/true);
6692  HadError = true;
6693  }
6694  }
6695 
6696  if (HadError)
6697  MD->setInvalidDecl();
6698 }
6699 
6700 /// Check whether the exception specification provided for an
6701 /// explicitly-defaulted special member matches the exception specification
6702 /// that would have been generated for an implicit special member, per
6703 /// C++11 [dcl.fct.def.default]p2.
6705  CXXMethodDecl *MD, const FunctionProtoType *SpecifiedType) {
6706  // If the exception specification was explicitly specified but hadn't been
6707  // parsed when the method was defaulted, grab it now.
6708  if (SpecifiedType->getExceptionSpecType() == EST_Unparsed)
6709  SpecifiedType =
6711 
6712  // Compute the implicit exception specification.
6713  CallingConv CC = Context.getDefaultCallingConvention(/*IsVariadic=*/false,
6714  /*IsCXXMethod=*/true);
6716  auto IES = computeImplicitExceptionSpec(*this, MD->getLocation(), MD);
6717  EPI.ExceptionSpec = IES.getExceptionSpec();
6718  const FunctionProtoType *ImplicitType = cast<FunctionProtoType>(
6719  Context.getFunctionType(Context.VoidTy, None, EPI));
6720 
6721  // Ensure that it matches.
6722  CheckEquivalentExceptionSpec(
6723  PDiag(diag::err_incorrect_defaulted_exception_spec)
6724  << getSpecialMember(MD), PDiag(),
6725  ImplicitType, SourceLocation(),
6726  SpecifiedType, MD->getLocation());
6727 }
6728 
6730  decltype(DelayedOverridingExceptionSpecChecks) Overriding;
6731  decltype(DelayedEquivalentExceptionSpecChecks) Equivalent;
6732  decltype(DelayedDefaultedMemberExceptionSpecs) Defaulted;
6733 
6734  std::swap(Overriding, DelayedOverridingExceptionSpecChecks);
6735  std::swap(Equivalent, DelayedEquivalentExceptionSpecChecks);
6736  std::swap(Defaulted, DelayedDefaultedMemberExceptionSpecs);
6737 
6738  // Perform any deferred checking of exception specifications for virtual
6739  // destructors.
6740  for (auto &Check : Overriding)
6741  CheckOverridingFunctionExceptionSpec(Check.first, Check.second);
6742 
6743  // Perform any deferred checking of exception specifications for befriended
6744  // special members.
6745  for (auto &Check : Equivalent)
6746  CheckEquivalentExceptionSpec(Check.second, Check.first);
6747 
6748  // Check that any explicitly-defaulted methods have exception specifications
6749  // compatible with their implicit exception specifications.
6750  for (auto &Spec : Defaulted)
6751  CheckExplicitlyDefaultedMemberExceptionSpec(Spec.first, Spec.second);
6752 }
6753 
6754 namespace {
6755 /// CRTP base class for visiting operations performed by a special member
6756 /// function (or inherited constructor).
6757 template<typename Derived>
6758 struct SpecialMemberVisitor {
6759  Sema &S;
6760  CXXMethodDecl *MD;
6763 
6764  // Properties of the special member, computed for convenience.
6765  bool IsConstructor = false, IsAssignment = false, ConstArg = false;
6766 
6767  SpecialMemberVisitor(Sema &S, CXXMethodDecl *MD, Sema::CXXSpecialMember CSM,
6769  : S(S), MD(MD), CSM(CSM), ICI(ICI) {
6770  switch (CSM) {
6774  IsConstructor = true;
6775  break;
6778  IsAssignment = true;
6779  break;
6780  case Sema::CXXDestructor:
6781  break;
6782  case Sema::CXXInvalid:
6783  llvm_unreachable("invalid special member kind");
6784  }
6785 
6786  if (MD->getNumParams()) {
6787  if (const ReferenceType *RT =
6788  MD->getParamDecl(0)->getType()->getAs<ReferenceType>())
6789  ConstArg = RT->getPointeeType().isConstQualified();
6790  }
6791  }
6792 
6793  Derived &getDerived() { return static_cast<Derived&>(*this); }
6794 
6795  /// Is this a "move" special member?
6796  bool isMove() const {
6797  return CSM == Sema::CXXMoveConstructor || CSM == Sema::CXXMoveAssignment;
6798  }
6799 
6800  /// Look up the corresponding special member in the given class.
6802  unsigned Quals, bool IsMutable) {
6803  return lookupCallFromSpecialMember(S, Class, CSM, Quals,
6804  ConstArg && !IsMutable);
6805  }
6806 
6807  /// Look up the constructor for the specified base class to see if it's
6808  /// overridden due to this being an inherited constructor.
6809  Sema::SpecialMemberOverloadResult lookupInheritedCtor(CXXRecordDecl *Class) {
6810  if (!ICI)
6811  return {};
6812  assert(CSM == Sema::CXXDefaultConstructor);
6813  auto *BaseCtor =
6814  cast<CXXConstructorDecl>(MD)->getInheritedConstructor().getConstructor();
6815  if (auto *MD = ICI->findConstructorForBase(Class, BaseCtor).first)
6816  return MD;
6817  return {};
6818  }
6819 
6820  /// A base or member subobject.
6821  typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
6822 
6823  /// Get the location to use for a subobject in diagnostics.
6824  static SourceLocation getSubobjectLoc(Subobject Subobj) {
6825  // FIXME: For an indirect virtual base, the direct base leading to
6826  // the indirect virtual base would be a more useful choice.
6827  if (auto *B = Subobj.dyn_cast<CXXBaseSpecifier*>())
6828  return B->getBaseTypeLoc();
6829  else
6830  return Subobj.get<FieldDecl*>()->getLocation();
6831  }
6832 
6833  enum BasesToVisit {
6834  /// Visit all non-virtual (direct) bases.
6835  VisitNonVirtualBases,
6836  /// Visit all direct bases, virtual or not.
6837  VisitDirectBases,
6838  /// Visit all non-virtual bases, and all virtual bases if the class
6839  /// is not abstract.
6840  VisitPotentiallyConstructedBases,
6841  /// Visit all direct or virtual bases.
6842  VisitAllBases
6843  };
6844 
6845  // Visit the bases and members of the class.
6846  bool visit(BasesToVisit Bases) {
6847  CXXRecordDecl *RD = MD->getParent();
6848 
6849  if (Bases == VisitPotentiallyConstructedBases)
6850  Bases = RD->isAbstract() ? VisitNonVirtualBases : VisitAllBases;
6851 
6852  for (auto &B : RD->bases())
6853  if ((Bases == VisitDirectBases || !B.isVirtual()) &&
6854  getDerived().visitBase(&B))
6855  return true;
6856 
6857  if (Bases == VisitAllBases)
6858  for (auto &B : RD->vbases())
6859  if (getDerived().visitBase(&B))
6860  return true;
6861 
6862  for (auto *F : RD->fields())
6863  if (!F->isInvalidDecl() && !F->isUnnamedBitfield() &&
6864  getDerived().visitField(F))
6865  return true;
6866 
6867  return false;
6868  }
6869 };
6870 }
6871 
6872 namespace {
6873 struct SpecialMemberDeletionInfo
6874  : SpecialMemberVisitor<SpecialMemberDeletionInfo> {
6875  bool Diagnose;
6876 
6877  SourceLocation Loc;
6878 
6879  bool AllFieldsAreConst;
6880 
6881  SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD,
6883  Sema::InheritedConstructorInfo *ICI, bool Diagnose)
6884  : SpecialMemberVisitor(S, MD, CSM, ICI), Diagnose(Diagnose),
6885  Loc(MD->getLocation()), AllFieldsAreConst(true) {}
6886 
6887  bool inUnion() const { return MD->getParent()->isUnion(); }
6888 
6889  Sema::CXXSpecialMember getEffectiveCSM() {
6890  return ICI ? Sema::CXXInvalid : CSM;
6891  }
6892 
6893  bool visitBase(CXXBaseSpecifier *Base) { return shouldDeleteForBase(Base); }
6894  bool visitField(FieldDecl *Field) { return shouldDeleteForField(Field); }
6895 
6896  bool shouldDeleteForBase(CXXBaseSpecifier *Base);
6897  bool shouldDeleteForField(FieldDecl *FD);
6898  bool shouldDeleteForAllConstMembers();
6899 
6900  bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
6901  unsigned Quals);
6902  bool shouldDeleteForSubobjectCall(Subobject Subobj,
6904  bool IsDtorCallInCtor);
6905 
6906  bool isAccessible(Subobject Subobj, CXXMethodDecl *D);
6907 };
6908 }
6909 
6910 /// Is the given special member inaccessible when used on the given
6911 /// sub-object.
6912 bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
6913  CXXMethodDecl *target) {
6914  /// If we're operating on a base class, the object type is the
6915  /// type of this special member.
6916  QualType objectTy;
6917  AccessSpecifier access = target->getAccess();
6918  if (CXXBaseSpecifier *base = Subobj.dyn_cast<CXXBaseSpecifier*>()) {
6919  objectTy = S.Context.getTypeDeclType(MD->getParent());
6920  access = CXXRecordDecl::MergeAccess(base->getAccessSpecifier(), access);
6921 
6922  // If we're operating on a field, the object type is the type of the field.
6923  } else {
6924  objectTy = S.Context.getTypeDeclType(target->getParent());
6925  }
6926 
6927  return S.isSpecialMemberAccessibleForDeletion(target, access, objectTy);
6928 }
6929 
6930 /// Check whether we should delete a special member due to the implicit
6931 /// definition containing a call to a special member of a subobject.
6932 bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
6933  Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR,
6934  bool IsDtorCallInCtor) {
6935  CXXMethodDecl *Decl = SMOR.getMethod();
6936  FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
6937 
6938  int DiagKind = -1;
6939 
6941  DiagKind = !Decl ? 0 : 1;
6943  DiagKind = 2;
6944  else if (!isAccessible(Subobj, Decl))
6945  DiagKind = 3;
6946  else if (!IsDtorCallInCtor && Field && Field->getParent()->isUnion() &&
6947  !Decl->isTrivial()) {
6948  // A member of a union must have a trivial corresponding special member.
6949  // As a weird special case, a destructor call from a union's constructor
6950  // must be accessible and non-deleted, but need not be trivial. Such a
6951  // destructor is never actually called, but is semantically checked as
6952  // if it were.
6953  DiagKind = 4;
6954  }
6955 
6956  if (DiagKind == -1)
6957  return false;
6958 
6959  if (Diagnose) {
6960  if (Field) {
6961  S.Diag(Field->getLocation(),
6962  diag::note_deleted_special_member_class_subobject)
6963  << getEffectiveCSM() << MD->getParent() << /*IsField*/true
6964  << Field << DiagKind << IsDtorCallInCtor;
6965  } else {
6966  CXXBaseSpecifier *Base = Subobj.get<CXXBaseSpecifier*>();
6967  S.Diag(Base->getBeginLoc(),
6968  diag::note_deleted_special_member_class_subobject)
6969  << getEffectiveCSM() << MD->getParent() << /*IsField*/ false
6970  << Base->getType() << DiagKind << IsDtorCallInCtor;
6971  }
6972 
6973  if (DiagKind == 1)
6974  S.NoteDeletedFunction(Decl);
6975  // FIXME: Explain inaccessibility if DiagKind == 3.
6976  }
6977 
6978  return true;
6979 }
6980 
6981 /// Check whether we should delete a special member function due to having a
6982 /// direct or virtual base class or non-static data member of class type M.
6983 bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
6984  CXXRecordDecl *Class, Subobject Subobj, unsigned Quals) {
6985  FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
6986  bool IsMutable = Field && Field->isMutable();
6987 
6988  // C++11 [class.ctor]p5:
6989  // -- any direct or virtual base class, or non-static data member with no
6990  // brace-or-equal-initializer, has class type M (or array thereof) and
6991  // either M has no default constructor or overload resolution as applied
6992  // to M's default constructor results in an ambiguity or in a function
6993  // that is deleted or inaccessible
6994  // C++11 [class.copy]p11, C++11 [class.copy]p23:
6995  // -- a direct or virtual base class B that cannot be copied/moved because
6996  // overload resolution, as applied to B's corresponding special member,
6997  // results in an ambiguity or a function that is deleted or inaccessible
6998  // from the defaulted special member
6999  // C++11 [class.dtor]p5:
7000  // -- any direct or virtual base class [...] has a type with a destructor
7001  // that is deleted or inaccessible
7002  if (!(CSM == Sema::CXXDefaultConstructor &&
7003  Field && Field->hasInClassInitializer()) &&
7004  shouldDeleteForSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable),
7005  false))
7006  return true;
7007 
7008  // C++11 [class.ctor]p5, C++11 [class.copy]p11:
7009  // -- any direct or virtual base class or non-static data member has a
7010  // type with a destructor that is deleted or inaccessible
7011  if (IsConstructor) {
7014  false, false, false, false, false);
7015  if (shouldDeleteForSubobjectCall(Subobj, SMOR, true))
7016  return true;
7017  }
7018 
7019  return false;
7020 }
7021 
7022 /// Check whether we should delete a special member function due to the class
7023 /// having a particular direct or virtual base class.
7024 bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
7025  CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
7026  // If program is correct, BaseClass cannot be null, but if it is, the error
7027  // must be reported elsewhere.
7028  if (!BaseClass)
7029  return false;
7030  // If we have an inheriting constructor, check whether we're calling an
7031  // inherited constructor instead of a default constructor.
7032  Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
7033  if (auto *BaseCtor = SMOR.getMethod()) {
7034  // Note that we do not check access along this path; other than that,
7035  // this is the same as shouldDeleteForSubobjectCall(Base, BaseCtor, false);
7036  // FIXME: Check that the base has a usable destructor! Sink this into
7037  // shouldDeleteForClassSubobject.
7038  if (BaseCtor->isDeleted() && Diagnose) {
7039  S.Diag(Base->getBeginLoc(),
7040  diag::note_deleted_special_member_class_subobject)
7041  << getEffectiveCSM() << MD->getParent() << /*IsField*/ false
7042  << Base->getType() << /*Deleted*/ 1 << /*IsDtorCallInCtor*/ false;
7043  S.NoteDeletedFunction(BaseCtor);
7044  }
7045  return BaseCtor->isDeleted();
7046  }
7047  return shouldDeleteForClassSubobject(BaseClass, Base, 0);
7048 }
7049 
7050 /// Check whether we should delete a special member function due to the class
7051 /// having a particular non-static data member.
7052 bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) {
7053  QualType FieldType = S.Context.getBaseElementType(FD->getType());
7054  CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl();
7055 
7056  if (CSM == Sema::CXXDefaultConstructor) {
7057  // For a default constructor, all references must be initialized in-class
7058  // and, if a union, it must have a non-const member.
7059  if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) {
7060  if (Diagnose)
7061  S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
7062  << !!ICI << MD->getParent() << FD << FieldType << /*Reference*/0;
7063  return true;
7064  }
7065  // C++11 [class.ctor]p5: any non-variant non-static data member of
7066  // const-qualified type (or array thereof) with no
7067  // brace-or-equal-initializer does not have a user-provided default
7068  // constructor.
7069  if (!inUnion() && FieldType.isConstQualified() &&
7070  !FD->hasInClassInitializer() &&
7071  (!FieldRecord || !FieldRecord->hasUserProvidedDefaultConstructor())) {
7072  if (Diagnose)
7073  S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
7074  << !!ICI << MD->getParent() << FD << FD->getType() << /*Const*/1;
7075  return true;
7076  }
7077 
7078  if (inUnion() && !FieldType.isConstQualified())
7079  AllFieldsAreConst = false;
7080  } else if (CSM == Sema::CXXCopyConstructor) {
7081  // For a copy constructor, data members must not be of rvalue reference
7082  // type.
7083  if (FieldType->isRValueReferenceType()) {
7084  if (Diagnose)
7085  S.Diag(FD->getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
7086  << MD->getParent() << FD << FieldType;
7087  return true;
7088  }
7089  } else if (IsAssignment) {
7090  // For an assignment operator, data members must not be of reference type.
7091  if (FieldType->isReferenceType()) {
7092  if (Diagnose)
7093  S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
7094  << isMove() << MD->getParent() << FD << FieldType << /*Reference*/0;
7095  return true;
7096  }
7097  if (!FieldRecord && FieldType.isConstQualified()) {
7098  // C++11 [class.copy]p23:
7099  // -- a non-static data member of const non-class type (or array thereof)
7100  if (Diagnose)
7101  S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
7102  << isMove() << MD->getParent() << FD << FD->getType() << /*Const*/1;
7103  return true;
7104  }
7105  }
7106 
7107  if (FieldRecord) {
7108  // Some additional restrictions exist on the variant members.
7109  if (!inUnion() && FieldRecord->isUnion() &&
7110  FieldRecord->isAnonymousStructOrUnion()) {
7111  bool AllVariantFieldsAreConst = true;
7112 
7113  // FIXME: Handle anonymous unions declared within anonymous unions.
7114  for (auto *UI : FieldRecord->fields()) {
7115  QualType UnionFieldType = S.Context.getBaseElementType(UI->getType());
7116 
7117  if (!UnionFieldType.isConstQualified())
7118  AllVariantFieldsAreConst = false;
7119 
7120  CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl();
7121  if (UnionFieldRecord &&
7122  shouldDeleteForClassSubobject(UnionFieldRecord, UI,
7123  UnionFieldType.getCVRQualifiers()))
7124  return true;
7125  }
7126 
7127  // At least one member in each anonymous union must be non-const
7128  if (CSM == Sema::CXXDefaultConstructor && AllVariantFieldsAreConst &&
7129  !FieldRecord->field_empty()) {
7130  if (Diagnose)
7131  S.Diag(FieldRecord->getLocation(),
7132  diag::note_deleted_default_ctor_all_const)
7133  << !!ICI << MD->getParent() << /*anonymous union*/1;
7134  return true;
7135  }
7136 
7137  // Don't check the implicit member of the anonymous union type.
7138  // This is technically non-conformant, but sanity demands it.
7139  return false;
7140  }
7141 
7142  if (shouldDeleteForClassSubobject(FieldRecord, FD,
7143  FieldType.getCVRQualifiers()))
7144  return true;
7145  }
7146 
7147  return false;
7148 }
7149 
7150 /// C++11 [class.ctor] p5:
7151 /// A defaulted default constructor for a class X is defined as deleted if
7152 /// X is a union and all of its variant members are of const-qualified type.
7153 bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
7154  // This is a silly definition, because it gives an empty union a deleted
7155  // default constructor. Don't do that.
7156  if (CSM == Sema::CXXDefaultConstructor && inUnion() && AllFieldsAreConst) {
7157  bool AnyFields = false;
7158  for (auto *F : MD->getParent()->fields())
7159  if ((AnyFields = !F->isUnnamedBitfield()))
7160  break;
7161  if (!AnyFields)
7162  return false;
7163  if (Diagnose)
7164  S.Diag(MD->getParent()->getLocation(),
7165  diag::note_deleted_default_ctor_all_const)
7166  << !!ICI << MD->getParent() << /*not anonymous union*/0;
7167  return true;
7168  }
7169  return false;
7170 }
7171 
7172 /// Determine whether a defaulted special member function should be defined as
7173 /// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11,
7174 /// C++11 [class.copy]p23, and C++11 [class.dtor]p5.
7177  bool Diagnose) {
7178  if (MD->isInvalidDecl())
7179  return false;
7180  CXXRecordDecl *RD = MD->getParent();
7181  assert(!RD->isDependentType() && "do deletion after instantiation");
7182  if (!LangOpts.CPlusPlus11 || RD->isInvalidDecl())
7183  return false;
7184 
7185  // C++11 [expr.lambda.prim]p19:
7186  // The closure type associated with a lambda-expression has a
7187  // deleted (8.4.3) default constructor and a deleted copy
7188  // assignment operator.
7189  // C++2a adds back these operators if the lambda has no capture-default.
7191  (CSM == CXXDefaultConstructor || CSM == CXXCopyAssignment)) {
7192  if (Diagnose)
7193  Diag(RD->getLocation(), diag::note_lambda_decl);
7194  return true;
7195  }
7196 
7197  // For an anonymous struct or union, the copy and assignment special members
7198  // will never be used, so skip the check. For an anonymous union declared at
7199  // namespace scope, the constructor and destructor are used.
7200  if (CSM != CXXDefaultConstructor && CSM != CXXDestructor &&
7202  return false;
7203 
7204  // C++11 [class.copy]p7, p18:
7205  // If the class definition declares a move constructor or move assignment
7206  // operator, an implicitly declared copy constructor or copy assignment
7207  // operator is defined as deleted.
7208  if (MD->isImplicit() &&
7209  (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment)) {
7210  CXXMethodDecl *UserDeclaredMove = nullptr;
7211 
7212  // In Microsoft mode up to MSVC 2013, a user-declared move only causes the
7213  // deletion of the corresponding copy operation, not both copy operations.
7214  // MSVC 2015 has adopted the standards conforming behavior.
7215  bool DeletesOnlyMatchingCopy =
7216  getLangOpts().MSVCCompat &&
7217  !getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015);
7218 
7219  if (RD->hasUserDeclaredMoveConstructor() &&
7220  (!DeletesOnlyMatchingCopy || CSM == CXXCopyConstructor)) {
7221  if (!Diagnose) return true;
7222 
7223  // Find any user-declared move constructor.
7224  for (auto *I : RD->ctors()) {
7225  if (I->isMoveConstructor()) {
7226  UserDeclaredMove = I;
7227  break;
7228  }
7229  }
7230  assert(UserDeclaredMove);
7231  } else if (RD->hasUserDeclaredMoveAssignment() &&
7232  (!DeletesOnlyMatchingCopy || CSM == CXXCopyAssignment)) {
7233  if (!Diagnose) return true;
7234 
7235  // Find any user-declared move assignment operator.
7236  for (auto *I : RD->methods()) {
7237  if (I->isMoveAssignmentOperator()) {
7238  UserDeclaredMove = I;
7239  break;
7240  }
7241  }
7242  assert(UserDeclaredMove);
7243  }
7244 
7245  if (UserDeclaredMove) {
7246  Diag(UserDeclaredMove->getLocation(),
7247  diag::note_deleted_copy_user_declared_move)
7248  << (CSM == CXXCopyAssignment) << RD
7249  << UserDeclaredMove->isMoveAssignmentOperator();
7250  return true;
7251  }
7252  }
7253 
7254  // Do access control from the special member function
7255  ContextRAII MethodContext(*this, MD);
7256 
7257  // C++11 [class.dtor]p5:
7258  // -- for a virtual destructor, lookup of the non-array deallocation function
7259  // results in an ambiguity or in a function that is deleted or inaccessible
7260  if (CSM == CXXDestructor && MD->isVirtual()) {
7261  FunctionDecl *OperatorDelete = nullptr;
7262  DeclarationName Name =
7263  Context.DeclarationNames.getCXXOperatorName(OO_Delete);
7264  if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name,
7265  OperatorDelete, /*Diagnose*/false)) {
7266  if (Diagnose)
7267  Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete);
7268  return true;
7269  }
7270  }
7271 
7272  SpecialMemberDeletionInfo SMI(*this, MD, CSM, ICI, Diagnose);
7273 
7274  // Per DR1611, do not consider virtual bases of constructors of abstract
7275  // classes, since we are not going to construct them.
7276  // Per DR1658, do not consider virtual bases of destructors of abstract
7277  // classes either.
7278  // Per DR2180, for assignment operators we only assign (and thus only
7279  // consider) direct bases.
7280  if (SMI.visit(SMI.IsAssignment ? SMI.VisitDirectBases
7281  : SMI.VisitPotentiallyConstructedBases))
7282  return true;
7283 
7284  if (SMI.shouldDeleteForAllConstMembers())
7285  return true;
7286 
7287  if (getLangOpts().CUDA) {
7288  // We should delete the special member in CUDA mode if target inference
7289  // failed.
7290  // For inherited constructors (non-null ICI), CSM may be passed so that MD
7291  // is treated as certain special member, which may not reflect what special
7292  // member MD really is. However inferCUDATargetForImplicitSpecialMember
7293  // expects CSM to match MD, therefore recalculate CSM.
7294  assert(ICI || CSM == getSpecialMember(MD));
7295  auto RealCSM = CSM;
7296  if (ICI)
7297  RealCSM = getSpecialMember(MD);
7298 
7299  return inferCUDATargetForImplicitSpecialMember(RD, RealCSM, MD,
7300  SMI.ConstArg, Diagnose);
7301  }
7302 
7303  return false;
7304 }
7305 
7306 /// Perform lookup for a special member of the specified kind, and determine
7307 /// whether it is trivial. If the triviality can be determined without the
7308 /// lookup, skip it. This is intended for use when determining whether a
7309 /// special member of a containing object is trivial, and thus does not ever
7310 /// perform overload resolution for default constructors.
7311 ///
7312 /// If \p Selected is not \c NULL, \c *Selected will be filled in with the
7313 /// member that was most likely to be intended to be trivial, if any.
7314 ///
7315 /// If \p ForCall is true, look at CXXRecord::HasTrivialSpecialMembersForCall to
7316 /// determine whether the special member is trivial.
7318  Sema::CXXSpecialMember CSM, unsigned Quals,
7319  bool ConstRHS,
7321  CXXMethodDecl **Selected) {
7322  if (Selected)
7323  *Selected = nullptr;
7324 
7325  switch (CSM) {
7326  case Sema::CXXInvalid:
7327  llvm_unreachable("not a special member");
7328 
7330  // C++11 [class.ctor]p5:
7331  // A default constructor is trivial if:
7332  // - all the [direct subobjects] have trivial default constructors
7333  //
7334  // Note, no overload resolution is performed in this case.
7335  if (RD->hasTrivialDefaultConstructor())
7336  return true;
7337 
7338  if (Selected) {
7339  // If there's a default constructor which could have been trivial, dig it
7340  // out. Otherwise, if there's any user-provided default constructor, point
7341  // to that as an example of why there's not a trivial one.
7342  CXXConstructorDecl *DefCtor = nullptr;
7345  for (auto *CI : RD->ctors()) {
7346  if (!CI->isDefaultConstructor())
7347  continue;
7348  DefCtor = CI;
7349  if (!DefCtor->isUserProvided())
7350  break;
7351  }
7352 
7353  *Selected = DefCtor;
7354  }
7355 
7356  return false;
7357 
7358  case Sema::CXXDestructor:
7359  // C++11 [class.dtor]p5:
7360  // A destructor is trivial if:
7361  // - all the direct [subobjects] have trivial destructors
7362  if (RD->hasTrivialDestructor() ||
7363  (TAH == Sema::TAH_ConsiderTrivialABI &&
7365  return true;
7366 
7367  if (Selected) {
7368  if (RD->needsImplicitDestructor())
7370  *Selected = RD->getDestructor();
7371  }
7372 
7373  return false;
7374 
7376  // C++11 [class.copy]p12:
7377  // A copy constructor is trivial if:
7378  // - the constructor selected to copy each direct [subobject] is trivial
7379  if (RD->hasTrivialCopyConstructor() ||
7380  (TAH == Sema::TAH_ConsiderTrivialABI &&
7382  if (Quals == Qualifiers::Const)
7383  // We must either select the trivial copy constructor or reach an
7384  // ambiguity; no need to actually perform overload resolution.
7385  return true;
7386  } else if (!Selected) {
7387  return false;
7388  }
7389  // In C++98, we are not supposed to perform overload resolution here, but we
7390  // treat that as a language defect, as suggested on cxx-abi-dev, to treat
7391  // cases like B as having a non-trivial copy constructor:
7392  // struct A { template<typename T> A(T&); };
7393  // struct B { mutable A a; };
7394  goto NeedOverloadResolution;
7395 
7397  // C++11 [class.copy]p25:
7398  // A copy assignment operator is trivial if:
7399  // - the assignment operator selected to copy each direct [subobject] is
7400  // trivial
7401  if (RD->hasTrivialCopyAssignment()) {
7402  if (Quals == Qualifiers::Const)
7403  return true;
7404  } else if (!Selected) {
7405  return false;
7406  }
7407  // In C++98, we are not supposed to perform overload resolution here, but we
7408  // treat that as a language defect.
7409  goto NeedOverloadResolution;
7410 
7413  NeedOverloadResolution:
7415  lookupCallFromSpecialMember(S, RD, CSM, Quals, ConstRHS);
7416 
7417  // The standard doesn't describe how to behave if the lookup is ambiguous.
7418  // We treat it as not making the member non-trivial, just like the standard
7419  // mandates for the default constructor. This should rarely matter, because
7420  // the member will also be deleted.
7422  return true;
7423 
7424  if (!SMOR.getMethod()) {
7425  assert(SMOR.getKind() ==
7427  return false;
7428  }
7429 
7430  // We deliberately don't check if we found a deleted special member. We're
7431  // not supposed to!
7432  if (Selected)
7433  *Selected = SMOR.getMethod();
7434 
7435  if (TAH == Sema::TAH_ConsiderTrivialABI &&
7437  return SMOR.getMethod()->isTrivialForCall();
7438  return SMOR.getMethod()->isTrivial();
7439  }
7440 
7441  llvm_unreachable("unknown special method kind");
7442 }
7443 
7445  for (auto *CI : RD->ctors())
7446  if (!CI->isImplicit())
7447  return CI;
7448 
7449  // Look for constructor templates.
7450  typedef CXXRecordDecl::specific_decl_iterator<FunctionTemplateDecl> tmpl_iter;
7451  for (tmpl_iter TI(RD->decls_begin()), TE(RD->decls_end()); TI != TE; ++TI) {
7452  if (CXXConstructorDecl *CD =
7453  dyn_cast<CXXConstructorDecl>(TI->getTemplatedDecl()))
7454  return CD;
7455  }
7456 
7457  return nullptr;
7458 }
7459 
7460 /// The kind of subobject we are checking for triviality. The values of this
7461 /// enumeration are used in diagnostics.
7463  /// The subobject is a base class.
7465  /// The subobject is a non-static data member.
7467  /// The object is actually the complete object.
7469 };
7470 
7471 /// Check whether the special member selected for a given type would be trivial.
7473  QualType SubType, bool ConstRHS,
7476  Sema::TrivialABIHandling TAH, bool Diagnose) {
7477  CXXRecordDecl *SubRD = SubType->getAsCXXRecordDecl();
7478  if (!SubRD)
7479  return true;
7480 
7481  CXXMethodDecl *Selected;
7482  if (findTrivialSpecialMember(S, SubRD, CSM, SubType.getCVRQualifiers(),
7483  ConstRHS, TAH, Diagnose ? &Selected : nullptr))
7484  return true;
7485 
7486  if (Diagnose) {
7487  if (ConstRHS)
7488  SubType.addConst();
7489 
7490  if (!Selected && CSM == Sema::CXXDefaultConstructor) {
7491  S.Diag(SubobjLoc, diag::note_nontrivial_no_def_ctor)
7492  << Kind << SubType.getUnqualifiedType();
7493  if (CXXConstructorDecl *CD = findUserDeclaredCtor(SubRD))
7494  S.Diag(CD->getLocation(), diag::note_user_declared_ctor);
7495  } else if (!Selected)
7496  S.Diag(SubobjLoc, diag::note_nontrivial_no_copy)
7497  << Kind << SubType.getUnqualifiedType() << CSM << SubType;
7498  else if (Selected->isUserProvided()) {
7499  if (Kind == TSK_CompleteObject)
7500  S.Diag(Selected->getLocation(), diag::note_nontrivial_user_provided)
7501  << Kind << SubType.getUnqualifiedType() << CSM;
7502  else {
7503  S.Diag(SubobjLoc, diag::note_nontrivial_user_provided)
7504  << Kind << SubType.getUnqualifiedType() << CSM;
7505  S.Diag(Selected->getLocation(), diag::note_declared_at);
7506  }
7507  } else {
7508  if (Kind != TSK_CompleteObject)
7509  S.Diag(SubobjLoc, diag::note_nontrivial_subobject)
7510  << Kind << SubType.getUnqualifiedType() << CSM;
7511 
7512  // Explain why the defaulted or deleted special member isn't trivial.
7514  Diagnose);
7515  }
7516  }
7517 
7518  return false;
7519 }
7520 
7521 /// Check whether the members of a class type allow a special member to be
7522 /// trivial.
7525  bool ConstArg,
7527  bool Diagnose) {
7528  for (const auto *FI : RD->fields()) {
7529  if (FI->isInvalidDecl() || FI->isUnnamedBitfield())
7530  continue;
7531 
7532  QualType FieldType = S.Context.getBaseElementType(FI->getType());
7533 
7534  // Pretend anonymous struct or union members are members of this class.
7535  if (FI->isAnonymousStructOrUnion()) {
7536  if (!checkTrivialClassMembers(S, FieldType->getAsCXXRecordDecl(),
7537  CSM, ConstArg, TAH, Diagnose))
7538  return false;
7539  continue;
7540  }
7541 
7542  // C++11 [class.ctor]p5:
7543  // A default constructor is trivial if [...]
7544  // -- no non-static data member of its class has a
7545  // brace-or-equal-initializer
7546  if (CSM == Sema::CXXDefaultConstructor && FI->hasInClassInitializer()) {
7547  if (Diagnose)
7548  S.Diag(FI->getLocation(), diag::note_nontrivial_in_class_init) << FI;
7549  return false;
7550  }
7551 
7552  // Objective C ARC 4.3.5:
7553  // [...] nontrivally ownership-qualified types are [...] not trivially
7554  // default constructible, copy constructible, move constructible, copy
7555  // assignable, move assignable, or destructible [...]
7556  if (FieldType.hasNonTrivialObjCLifetime()) {
7557  if (Diagnose)
7558  S.Diag(FI->getLocation(), diag::note_nontrivial_objc_ownership)
7559  << RD << FieldType.getObjCLifetime();
7560  return false;
7561  }
7562 
7563  bool ConstRHS = ConstArg && !FI->isMutable();
7564  if (!checkTrivialSubobjectCall(S, FI->getLocation(), FieldType, ConstRHS,
7565  CSM, TSK_Field, TAH, Diagnose))
7566  return false;
7567  }
7568 
7569  return true;
7570 }
7571 
7572 /// Diagnose why the specified class does not have a trivial special member of
7573 /// the given kind.
7575  QualType Ty = Context.getRecordType(RD);
7576 
7577  bool ConstArg = (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment);
7578  checkTrivialSubobjectCall(*this, RD->getLocation(), Ty, ConstArg, CSM,
7579  TSK_CompleteObject, TAH_IgnoreTrivialABI,
7580  /*Diagnose*/true);
7581 }
7582 
7583 /// Determine whether a defaulted or deleted special member function is trivial,
7584 /// as specified in C++11 [class.ctor]p5, C++11 [class.copy]p12,
7585 /// C++11 [class.copy]p25, and C++11 [class.dtor]p5.
7587  TrivialABIHandling TAH, bool Diagnose) {
7588  assert(!MD->isUserProvided() && CSM != CXXInvalid && "not special enough");
7589 
7590  CXXRecordDecl *RD = MD->getParent();
7591 
7592  bool ConstArg = false;
7593 
7594  // C++11 [class.copy]p12, p25: [DR1593]
7595  // A [special member] is trivial if [...] its parameter-type-list is
7596  // equivalent to the parameter-type-list of an implicit declaration [...]
7597  switch (CSM) {
7598  case CXXDefaultConstructor:
7599  case CXXDestructor:
7600  // Trivial default constructors and destructors cannot have parameters.
7601  break;
7602 
7603  case CXXCopyConstructor:
7604  case CXXCopyAssignment: {
7605  // Trivial copy operations always have const, non-volatile parameter types.
7606  ConstArg = true;
7607  const ParmVarDecl *Param0 = MD->getParamDecl(0);
7608  const ReferenceType *RT = Param0->getType()->getAs<ReferenceType>();
7609  if (!RT || RT->getPointeeType().getCVRQualifiers() != Qualifiers::Const) {
7610  if (Diagnose)
7611  Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
7612  << Param0->getSourceRange() << Param0->getType()
7613  << Context.getLValueReferenceType(
7614  Context.getRecordType(RD).withConst());
7615  return false;
7616  }
7617  break;
7618  }
7619 
7620  case CXXMoveConstructor:
7621  case CXXMoveAssignment: {
7622  // Trivial move operations always have non-cv-qualified parameters.
7623  const ParmVarDecl *Param0 = MD->getParamDecl(0);
7624  const RValueReferenceType *RT =
7625  Param0->getType()->getAs<RValueReferenceType>();
7626  if (!RT || RT->getPointeeType().getCVRQualifiers()) {
7627  if (Diagnose)
7628  Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
7629  << Param0->getSourceRange() << Param0->getType()
7630  << Context.getRValueReferenceType(Context.getRecordType(RD));
7631  return false;
7632  }
7633  break;
7634  }
7635 
7636  case CXXInvalid:
7637  llvm_unreachable("not a special member");
7638  }
7639 
7640  if (MD->getMinRequiredArguments() < MD->getNumParams()) {
7641  if (Diagnose)
7642  Diag(MD->getParamDecl(MD->getMinRequiredArguments())->getLocation(),
7643  diag::note_nontrivial_default_arg)
7645  return false;
7646  }
7647  if (MD->isVariadic()) {
7648  if (Diagnose)
7649  Diag(MD->getLocation(), diag::note_nontrivial_variadic);
7650  return false;
7651  }
7652 
7653  // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
7654  // A copy/move [constructor or assignment operator] is trivial if
7655  // -- the [member] selected to copy/move each direct base class subobject
7656  // is trivial
7657  //
7658  // C++11 [class.copy]p12, C++11 [class.copy]p25:
7659  // A [default constructor or destructor] is trivial if
7660  // -- all the direct base classes have trivial [default constructors or
7661  // destructors]
7662  for (const auto &BI : RD->bases())
7663  if (!checkTrivialSubobjectCall(*this, BI.getBeginLoc(), BI.getType(),
7664  ConstArg, CSM, TSK_BaseClass, TAH, Diagnose))
7665  return false;
7666 
7667  // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
7668  // A copy/move [constructor or assignment operator] for a class X is
7669  // trivial if
7670  // -- for each non-static data member of X that is of class type (or array
7671  // thereof), the constructor selected to copy/move that member is
7672  // trivial
7673  //
7674  // C++11 [class.copy]p12, C++11 [class.copy]p25:
7675  // A [default constructor or destructor] is trivial if
7676  // -- for all of the non-static data members of its class that are of class
7677  // type (or array thereof), each such class has a trivial [default
7678  // constructor or destructor]
7679  if (!checkTrivialClassMembers(*this, RD, CSM, ConstArg, TAH, Diagnose))
7680  return false;
7681 
7682  // C++11 [class.dtor]p5:
7683  // A destructor is trivial if [...]
7684  // -- the destructor is not virtual
7685  if (CSM == CXXDestructor && MD->isVirtual()) {
7686  if (Diagnose)
7687  Diag(MD->getLocation(), diag::note_nontrivial_virtual_dtor) << RD;
7688  return false;
7689  }
7690 
7691  // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
7692  // A [special member] for class X is trivial if [...]
7693  // -- class X has no virtual functions and no virtual base classes
7694  if (CSM != CXXDestructor && MD->getParent()->isDynamicClass()) {
7695  if (!Diagnose)
7696  return false;
7697 
7698  if (RD->getNumVBases()) {
7699  // Check for virtual bases. We already know that the corresponding
7700  // member in all bases is trivial, so vbases must all be direct.
7701  CXXBaseSpecifier &BS = *RD->vbases_begin();
7702  assert(BS.isVirtual());
7703  Diag(BS.getBeginLoc(), diag::note_nontrivial_has_virtual) << RD << 1;
7704  return false;
7705  }
7706 
7707  // Must have a virtual method.
7708  for (const auto *MI : RD->methods()) {
7709  if (MI->isVirtual()) {
7710  SourceLocation MLoc = MI->getBeginLoc();
7711  Diag(MLoc, diag::note_nontrivial_has_virtual) << RD << 0;
7712  return false;
7713  }
7714  }
7715 
7716  llvm_unreachable("dynamic class with no vbases and no virtual functions");
7717  }
7718 
7719  // Looks like it's trivial!
7720  return true;
7721 }
7722 
7723 namespace {
7724 struct FindHiddenVirtualMethod {
7725  Sema *S;
7726  CXXMethodDecl *Method;
7727  llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
7728  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
7729 
7730 private:
7731  /// Check whether any most overridden method from MD in Methods
7732  static bool CheckMostOverridenMethods(
7733  const CXXMethodDecl *MD,
7734  const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
7735  if (MD->size_overridden_methods() == 0)
7736  return Methods.count(MD->getCanonicalDecl());
7737  for (const CXXMethodDecl *O : MD->overridden_methods())
7738  if (CheckMostOverridenMethods(O, Methods))
7739  return true;
7740  return false;
7741  }
7742 
7743 public:
7744  /// Member lookup function that determines whether a given C++
7745  /// method overloads virtual methods in a base class without overriding any,
7746  /// to be used with CXXRecordDecl::lookupInBases().
7747  bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
7748  RecordDecl *BaseRecord =
7749  Specifier->getType()->getAs<RecordType>()->getDecl();
7750 
7751  DeclarationName Name = Method->getDeclName();
7752  assert(Name.getNameKind() == DeclarationName::Identifier);
7753 
7754  bool foundSameNameMethod = false;
7755  SmallVector<CXXMethodDecl *, 8> overloadedMethods;
7756  for (Path.Decls = BaseRecord->lookup(Name); !Path.Decls.empty();
7757  Path.Decls = Path.Decls.slice(1)) {
7758  NamedDecl *D = Path.Decls.front();
7759  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
7760  MD = MD->getCanonicalDecl();
7761  foundSameNameMethod = true;
7762  // Interested only in hidden virtual methods.
7763  if (!MD->isVirtual())
7764  continue;
7765  // If the method we are checking overrides a method from its base
7766  // don't warn about the other overloaded methods. Clang deviates from
7767  // GCC by only diagnosing overloads of inherited virtual functions that
7768  // do not override any other virtual functions in the base. GCC's
7769  // -Woverloaded-virtual diagnoses any derived function hiding a virtual
7770  // function from a base class. These cases may be better served by a
7771  // warning (not specific to virtual functions) on call sites when the
7772  // call would select a different function from the base class, were it
7773  // visible.
7774  // See FIXME in test/SemaCXX/warn-overload-virtual.cpp for an example.
7775  if (!S->IsOverload(Method, MD, false))
7776  return true;
7777  // Collect the overload only if its hidden.
7778  if (!CheckMostOverridenMethods(MD, OverridenAndUsingBaseMethods))
7779  overloadedMethods.push_back(MD);
7780  }
7781  }
7782 
7783  if (foundSameNameMethod)
7784  OverloadedMethods.append(overloadedMethods.begin(),
7785  overloadedMethods.end());
7786  return foundSameNameMethod;
7787  }
7788 };
7789 } // end anonymous namespace
7790 
7791 /// Add the most overriden methods from MD to Methods
7793  llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
7794  if (MD->size_overridden_methods() == 0)
7795  Methods.insert(MD->getCanonicalDecl());
7796  else
7797  for (const CXXMethodDecl *O : MD->overridden_methods())
7798  AddMostOverridenMethods(O, Methods);
7799 }
7800 
7801 /// Check if a method overloads virtual methods in a base class without
7802 /// overriding any.
7804  SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
7805  if (!MD->getDeclName().isIdentifier())
7806  return;
7807 
7808  CXXBasePaths Paths(/*FindAmbiguities=*/true, // true to look in all bases.
7809  /*bool RecordPaths=*/false,
7810  /*bool DetectVirtual=*/false);
7811  FindHiddenVirtualMethod FHVM;
7812  FHVM.Method = MD;
7813  FHVM.S = this;
7814 
7815  // Keep the base methods that were overridden or introduced in the subclass
7816  // by 'using' in a set. A base method not in this set is hidden.
7817  CXXRecordDecl *DC = MD->getParent();
7819  for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
7820  NamedDecl *ND = *I;
7821  if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*I))
7822  ND = shad->getTargetDecl();
7823  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND))
7824  AddMostOverridenMethods(MD, FHVM.OverridenAndUsingBaseMethods);
7825  }
7826 
7827  if (DC->lookupInBases(FHVM, Paths))
7828  OverloadedMethods = FHVM.OverloadedMethods;
7829 }
7830 
7832  SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
7833  for (unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) {
7834  CXXMethodDecl *overloadedMD = OverloadedMethods[i];
7835  PartialDiagnostic PD = PDiag(
7836  diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
7837  HandleFunctionTypeMismatch(PD, MD->getType(), overloadedMD->getType());
7838  Diag(overloadedMD->getLocation(), PD);
7839  }
7840 }
7841 
7842 /// Diagnose methods which overload virtual methods in a base class
7843 /// without overriding any.
7845  if (MD->isInvalidDecl())
7846  return;
7847 
7848  if (Diags.isIgnored(diag::warn_overloaded_virtual, MD->getLocation()))
7849  return;
7850 
7851  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
7852  FindHiddenVirtualMethods(MD, OverloadedMethods);
7853  if (!OverloadedMethods.empty()) {
7854  Diag(MD->getLocation(), diag::warn_overloaded_virtual)
7855  << MD << (OverloadedMethods.size() > 1);
7856 
7857  NoteHiddenVirtualMethods(MD, OverloadedMethods);
7858  }
7859 }
7860 
7862  auto PrintDiagAndRemoveAttr = [&]() {
7863  // No diagnostics if this is a template instantiation.
7865  Diag(RD.getAttr<TrivialABIAttr>()->getLocation(),
7866  diag::ext_cannot_use_trivial_abi) << &RD;
7867  RD.dropAttr<TrivialABIAttr>();
7868  };
7869 
7870  // Ill-formed if the struct has virtual functions.
7871  if (RD.isPolymorphic()) {
7872  PrintDiagAndRemoveAttr();
7873  return;
7874  }
7875 
7876  for (const auto &B : RD.bases()) {
7877  // Ill-formed if the base class is non-trivial for the purpose of calls or a
7878  // virtual base.
7879  if ((!B.getType()->isDependentType() &&
7880  !B.getType()->getAsCXXRecordDecl()->canPassInRegisters()) ||
7881  B.isVirtual()) {
7882  PrintDiagAndRemoveAttr();
7883  return;
7884  }
7885  }
7886 
7887  for (const auto *FD : RD.fields()) {
7888  // Ill-formed if the field is an ObjectiveC pointer or of a type that is
7889  // non-trivial for the purpose of calls.
7890  QualType FT = FD->getType();
7891  if (FT.getObjCLifetime() == Qualifiers::OCL_Weak) {
7892  PrintDiagAndRemoveAttr();
7893  return;
7894  }
7895 
7896  if (const auto *RT = FT->getBaseElementTypeUnsafe()->getAs<RecordType>())
7897  if (!RT->isDependentType() &&
7898  !cast<CXXRecordDecl>(RT->getDecl())->canPassInRegisters()) {
7899  PrintDiagAndRemoveAttr();
7900  return;
7901  }
7902  }
7903 }
7904 
7906  Scope *S, SourceLocation RLoc, Decl *TagDecl, SourceLocation LBrac,
7907  SourceLocation RBrac, const ParsedAttributesView &AttrList) {
7908  if (!TagDecl)
7909  return;
7910 
7911  AdjustDeclIfTemplate(TagDecl);
7912 
7913  for (const ParsedAttr &AL : AttrList) {
7914  if (AL.getKind() != ParsedAttr::AT_Visibility)
7915  continue;
7916  AL.setInvalid();
7917  Diag(AL.getLoc(), diag::warn_attribute_after_definition_ignored)
7918  << AL.getName();
7919  }
7920 
7921  ActOnFields(S, RLoc, TagDecl, llvm::makeArrayRef(
7922  // strict aliasing violation!
7923  reinterpret_cast<Decl**>(FieldCollector->getCurFields()),
7924  FieldCollector->getCurNumFields()), LBrac, RBrac, AttrList);
7925 
7926  CheckCompletedCXXClass(cast<CXXRecordDecl>(TagDecl));
7927 }
7928 
7929 /// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
7930 /// special functions, such as the default constructor, copy
7931 /// constructor, or destructor, to the given C++ class (C++
7932 /// [special]p1). This routine can only be executed just before the
7933 /// definition of the class is complete.
7935  if (ClassDecl->needsImplicitDefaultConstructor()) {
7937 
7938  if (ClassDecl->hasInheritedConstructor())
7939  DeclareImplicitDefaultConstructor(ClassDecl);
7940  }
7941 
7942  if (ClassDecl->needsImplicitCopyConstructor()) {
7944 
7945  // If the properties or semantics of the copy constructor couldn't be
7946  // determined while the class was being declared, force a declaration
7947  // of it now.
7948  if (ClassDecl->needsOverloadResolutionForCopyConstructor() ||
7949  ClassDecl->hasInheritedConstructor())
7950  DeclareImplicitCopyConstructor(ClassDecl);
7951  // For the MS ABI we need to know whether the copy ctor is deleted. A
7952  // prerequisite for deleting the implicit copy ctor is that the class has a
7953  // move ctor or move assignment that is either user-declared or whose
7954  // semantics are inherited from a subobject. FIXME: We should provide a more
7955  // direct way for CodeGen to ask whether the constructor was deleted.
7956  else if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
7957  (ClassDecl->hasUserDeclaredMoveConstructor() ||
7959  ClassDecl->hasUserDeclaredMoveAssignment() ||
7961  DeclareImplicitCopyConstructor(ClassDecl);
7962  }
7963 
7964  if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveConstructor()) {
7966 
7967  if (ClassDecl->needsOverloadResolutionForMoveConstructor() ||
7968  ClassDecl->hasInheritedConstructor())
7969  DeclareImplicitMoveConstructor(ClassDecl);
7970  }
7971 
7972  if (ClassDecl->needsImplicitCopyAssignment()) {
7974 
7975  // If we have a dynamic class, then the copy assignment operator may be
7976  // virtual, so we have to declare it immediately. This ensures that, e.g.,
7977  // it shows up in the right place in the vtable and that we diagnose
7978  // problems with the implicit exception specification.
7979  if (ClassDecl->isDynamicClass() ||
7981  ClassDecl->hasInheritedAssignment())
7982  DeclareImplicitCopyAssignment(ClassDecl);
7983  }
7984 
7985  if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveAssignment()) {
7987 
7988  // Likewise for the move assignment operator.
7989  if (ClassDecl->isDynamicClass() ||
7991  ClassDecl->hasInheritedAssignment())
7992  DeclareImplicitMoveAssignment(ClassDecl);
7993  }
7994 
7995  if (ClassDecl->needsImplicitDestructor()) {
7997 
7998  // If we have a dynamic class, then the destructor may be virtual, so we
7999  // have to declare the destructor immediately. This ensures that, e.g., it
8000  // shows up in the right place in the vtable and that we diagnose problems
8001  // with the implicit exception specification.
8002  if (ClassDecl->isDynamicClass() ||
8004  DeclareImplicitDestructor(ClassDecl);
8005  }
8006 }
8007 
8009  if (!D)
8010  return 0;
8011 
8012  // The order of template parameters is not important here. All names
8013  // get added to the same scope.
8015 
8016  if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
8017  D = TD->getTemplatedDecl();
8018 
8019  if (auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
8020  ParameterLists.push_back(PSD->getTemplateParameters());
8021 
8022  if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
8023  for (unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
8024  ParameterLists.push_back(DD->getTemplateParameterList(i));
8025 
8026  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
8027  if (FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
8028  ParameterLists.push_back(FTD->getTemplateParameters());
8029  }
8030  }
8031 
8032  if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
8033  for (unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
8034  ParameterLists.push_back(TD->getTemplateParameterList(i));
8035 
8036  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD)) {
8038  ParameterLists.push_back(CTD->getTemplateParameters());
8039  }
8040  }
8041 
8042  unsigned Count = 0;
8043  for (TemplateParameterList *Params : ParameterLists) {
8044  if (Params->size() > 0)
8045  // Ignore explicit specializations; they don't contribute to the template
8046  // depth.
8047  ++Count;
8048  for (NamedDecl *Param : *Params) {
8049  if (Param->getDeclName()) {
8050  S->AddDecl(Param);
8051  IdResolver.AddDecl(Param);
8052  }
8053  }
8054  }
8055 
8056  return Count;
8057 }
8058 
8060  if (!RecordD) return;
8061  AdjustDeclIfTemplate(RecordD);
8062  CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD);
8063  PushDeclContext(S, Record);
8064 }
8065 
8067  if (!RecordD) return;
8068  PopDeclContext();
8069 }
8070 
8071 /// This is used to implement the constant expression evaluation part of the
8072 /// attribute enable_if extension. There is nothing in standard C++ which would
8073 /// require reentering parameters.
8075  if (!Param)
8076  return;
8077 
8078  S->AddDecl(Param);
8079  if (Param->getDeclName())
8080  IdResolver.AddDecl(Param);
8081 }
8082 
8083 /// ActOnStartDelayedCXXMethodDeclaration - We have completed
8084 /// parsing a top-level (non-nested) C++ class, and we are now
8085 /// parsing those parts of the given Method declaration that could
8086 /// not be parsed earlier (C++ [class.mem]p2), such as default
8087 /// arguments. This action should enter the scope of the given
8088 /// Method declaration as if we had just parsed the qualified method
8089 /// name. However, it should not bring the parameters into scope;
8090 /// that will be performed by ActOnDelayedCXXMethodParameter.
8092 }
8093 
8094 /// ActOnDelayedCXXMethodParameter - We've already started a delayed
8095 /// C++ method declaration. We're (re-)introducing the given
8096 /// function parameter into scope for use in parsing later parts of
8097 /// the method declaration. For example, we could see an
8098 /// ActOnParamDefaultArgument event for this parameter.
8100  if (!ParamD)
8101  return;
8102 
8103  ParmVarDecl *Param = cast<ParmVarDecl>(ParamD);
8104 
8105  // If this parameter has an unparsed default argument, clear it out
8106  // to make way for the parsed default argument.
8107  if (Param->hasUnparsedDefaultArg())
8108  Param->setDefaultArg(nullptr);
8109 
8110  S->AddDecl(Param);
8111  if (Param->getDeclName())
8112  IdResolver.AddDecl(Param);
8113 }
8114 
8115 /// ActOnFinishDelayedCXXMethodDeclaration - We have finished
8116 /// processing the delayed method declaration for Method. The method
8117 /// declaration is now considered finished. There may be a separate
8118 /// ActOnStartOfFunctionDef action later (not necessarily
8119 /// immediately!) for this method, if it was also defined inside the
8120 /// class body.
8122  if (!MethodD)
8123  return;
8124 
8125  AdjustDeclIfTemplate(MethodD);
8126 
8127  FunctionDecl *Method = cast<FunctionDecl>(MethodD);
8128 
8129  // Now that we have our default arguments, check the constructor
8130  // again. It could produce additional diagnostics or affect whether
8131  // the class has implicitly-declared destructors, among other
8132  // things.
8133  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
8134  CheckConstructor(Constructor);
8135 
8136  // Check the default arguments, which we may have added.
8137  if (!Method->isInvalidDecl())
8138  CheckCXXDefaultArguments(Method);
8139 }
8140 
8141 /// CheckConstructorDeclarator - Called by ActOnDeclarator to check
8142 /// the well-formedness of the constructor declarator @p D with type @p
8143 /// R. If there are any errors in the declarator, this routine will
8144 /// emit diagnostics and set the invalid bit to true. In any case, the type
8145 /// will be updated to reflect a well-formed type for the constructor and
8146 /// returned.
8148  StorageClass &SC) {
8149  bool isVirtual = D.getDeclSpec().isVirtualSpecified();
8150 
8151  // C++ [class.ctor]p3:
8152  // A constructor shall not be virtual (10.3) or static (9.4). A
8153  // constructor can be invoked for a const, volatile or const
8154  // volatile object. A constructor shall not be declared const,
8155  // volatile, or const volatile (9.3.2).
8156  if (isVirtual) {
8157  if (!D.isInvalidType())
8158  Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
8159  << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
8160  << SourceRange(D.getIdentifierLoc());
8161  D.setInvalidType();
8162  }
8163  if (SC == SC_Static) {
8164  if (!D.isInvalidType())
8165  Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
8166  << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
8167  << SourceRange(D.getIdentifierLoc());
8168  D.setInvalidType();
8169  SC = SC_None;
8170  }
8171 
8172  if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
8173  diagnoseIgnoredQualifiers(
8174  diag::err_constructor_return_type, TypeQuals, SourceLocation(),
8178  D.setInvalidType();
8179  }
8180 
8182  if (FTI.hasMethodTypeQualifiers()) {
8184  [&](DeclSpec::TQ TypeQual, StringRef QualName, SourceLocation SL) {
8185  Diag(SL, diag::err_invalid_qualified_constructor)
8186  << QualName << SourceRange(SL);
8187  });
8188  D.setInvalidType();
8189  }
8190 
8191  // C++0x [class.ctor]p4:
8192  // A constructor shall not be declared with a ref-qualifier.
8193  if (FTI.hasRefQualifier()) {
8194  Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_constructor)
8197  D.setInvalidType();
8198  }
8199 
8200  // Rebuild the function type "R" without any type qualifiers (in
8201  // case any of the errors above fired) and with "void" as the
8202  // return type, since constructors don't have return types.
8203  const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
8204  if (Proto->getReturnType() == Context.VoidTy && !D.isInvalidType())
8205  return R;
8206 
8208  EPI.TypeQuals = Qualifiers();
8209  EPI.RefQualifier = RQ_None;
8210 
8211  return Context.getFunctionType(Context.VoidTy, Proto->getParamTypes(), EPI);
8212 }
8213 
8214 /// CheckConstructor - Checks a fully-formed constructor for
8215 /// well-formedness, issuing any diagnostics required. Returns true if
8216 /// the constructor declarator is invalid.
8218  CXXRecordDecl *ClassDecl
8219  = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
8220  if (!ClassDecl)
8221  return Constructor->setInvalidDecl();
8222 
8223  // C++ [class.copy]p3:
8224  // A declaration of a constructor for a class X is ill-formed if
8225  // its first parameter is of type (optionally cv-qualified) X and
8226  // either there are no other parameters or else all other
8227  // parameters have default arguments.
8228  if (!Constructor->isInvalidDecl() &&
8229  ((Constructor->getNumParams() == 1) ||
8230  (Constructor->getNumParams() > 1 &&
8231  Constructor->getParamDecl(1)->hasDefaultArg())) &&
8232  Constructor->getTemplateSpecializationKind()
8234  QualType ParamType = Constructor->getParamDecl(0)->getType();
8235  QualType ClassTy = Context.getTagDeclType(ClassDecl);
8236  if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
8237  SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
8238  const char *ConstRef
8239  = Constructor->getParamDecl(0)->getIdentifier() ? "const &"
8240  : " const &";
8241  Diag(ParamLoc, diag::err_constructor_byvalue_arg)
8242  << FixItHint::CreateInsertion(ParamLoc, ConstRef);
8243 
8244  // FIXME: Rather that making the constructor invalid, we should endeavor
8245  // to fix the type.
8246  Constructor->setInvalidDecl();
8247  }
8248  }
8249 }
8250 
8251 /// CheckDestructor - Checks a fully-formed destructor definition for
8252 /// well-formedness, issuing any diagnostics required. Returns true
8253 /// on error.
8255  CXXRecordDecl *RD = Destructor->getParent();
8256 
8257  if (!Destructor->getOperatorDelete() && Destructor->isVirtual()) {
8258  SourceLocation Loc;
8259 
8260  if (!Destructor->isImplicit())
8261  Loc = Destructor->getLocation();
8262  else
8263  Loc = RD->getLocation();
8264 
8265  // If we have a virtual destructor, look up the deallocation function
8266  if (FunctionDecl *OperatorDelete =
8267  FindDeallocationFunctionForDestructor(Loc, RD)) {
8268  Expr *ThisArg = nullptr;
8269 
8270  // If the notional 'delete this' expression requires a non-trivial
8271  // conversion from 'this' to the type of a destroying operator delete's
8272  // first parameter, perform that conversion now.
8273  if (OperatorDelete->isDestroyingOperatorDelete()) {
8274  QualType ParamType = OperatorDelete->getParamDecl(0)->getType();
8275  if (!declaresSameEntity(ParamType->getAsCXXRecordDecl(), RD)) {
8276  // C++ [class.dtor]p13:
8277  // ... as if for the expression 'delete this' appearing in a
8278  // non-virtual destructor of the destructor's class.
8279  ContextRAII SwitchContext(*this, Destructor);
8280  ExprResult This =
8281  ActOnCXXThis(OperatorDelete->getParamDecl(0)->getLocation());
8282  assert(!This.isInvalid() && "couldn't form 'this' expr in dtor?");
8283  This = PerformImplicitConversion(This.get(), ParamType, AA_Passing);
8284  if (This.isInvalid()) {
8285  // FIXME: Register this as a context note so that it comes out
8286  // in the right order.
8287  Diag(Loc, diag::note_implicit_delete_this_in_destructor_here);
8288  return true;
8289  }
8290  ThisArg = This.get();
8291  }
8292  }
8293 
8294  DiagnoseUseOfDecl(OperatorDelete, Loc);
8295  MarkFunctionReferenced(Loc, OperatorDelete);
8296  Destructor->setOperatorDelete(OperatorDelete, ThisArg);
8297  }
8298  }
8299 
8300  return false;
8301 }
8302 
8303 /// CheckDestructorDeclarator - Called by ActOnDeclarator to check
8304 /// the well-formednes of the destructor declarator @p D with type @p
8305 /// R. If there are any errors in the declarator, this routine will
8306 /// emit diagnostics and set the declarator to invalid. Even if this happens,
8307 /// will be updated to reflect a well-formed type for the destructor and
8308 /// returned.
8310  StorageClass& SC) {
8311  // C++ [class.dtor]p1:
8312  // [...] A typedef-name that names a class is a class-name
8313  // (7.1.3); however, a typedef-name that names a class shall not
8314  // be used as the identifier in the declarator for a destructor
8315  // declaration.
8316  QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
8317  if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
8318  Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
8319  << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
8320  else if (const TemplateSpecializationType *TST =
8321  DeclaratorType->getAs<TemplateSpecializationType>())
8322  if (TST->isTypeAlias())
8323  Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
8324  << DeclaratorType << 1;
8325 
8326  // C++ [class.dtor]p2:
8327  // A destructor is used to destroy objects of its class type. A
8328  // destructor takes no parameters, and no return type can be
8329  // specified for it (not even void). The address of a destructor
8330  // shall not be taken. A destructor shall not be static. A
8331  // destructor can be invoked for a const, volatile or const
8332  // volatile object. A destructor shall not be declared const,
8333  // volatile or const volatile (9.3.2).
8334  if (SC == SC_Static) {
8335  if (!D.isInvalidType())
8336  Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
8337  << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
8340 
8341  SC = SC_None;
8342  }
8343  if (!D.isInvalidType()) {
8344  // Destructors don't have return types, but the parser will
8345  // happily parse something like:
8346  //
8347  // class X {
8348  // float ~X();
8349  // };
8350  //
8351  // The return type will be eliminated later.
8352  if (D.getDeclSpec().hasTypeSpecifier())
8353  Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
8355  << SourceRange(D.getIdentifierLoc());
8356  else if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
8357  diagnoseIgnoredQualifiers(diag::err_destructor_return_type, TypeQuals,
8358  SourceLocation(),
8363  D.setInvalidType();
8364  }
8365  }
8366 
8368  if (FTI.hasMethodTypeQualifiers() && !D.isInvalidType()) {
8370  [&](DeclSpec::TQ TypeQual, StringRef QualName, SourceLocation SL) {
8371  Diag(SL, diag::err_invalid_qualified_destructor)
8372  << QualName << SourceRange(SL);
8373  });
8374  D.setInvalidType();
8375  }
8376 
8377  // C++0x [class.dtor]p2:
8378  // A destructor shall not be declared with a ref-qualifier.
8379  if (FTI.hasRefQualifier()) {
8380  Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_destructor)
8383  D.setInvalidType();
8384  }
8385 
8386  // Make sure we don't have any parameters.
8387  if (FTIHasNonVoidParameters(FTI)) {
8388  Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
8389 
8390  // Delete the parameters.
8391  FTI.freeParams();
8392  D.setInvalidType();
8393  }
8394 
8395  // Make sure the destructor isn't variadic.
8396  if (FTI.isVariadic) {
8397  Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
8398  D.setInvalidType();
8399  }
8400 
8401  // Rebuild the function type "R" without any type qualifiers or
8402  // parameters (in case any of the errors above fired) and with
8403  // "void" as the return type, since destructors don't have return
8404  // types.
8405  if (!D.isInvalidType())
8406  return R;
8407 
8408  const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
8410  EPI.Variadic = false;
8411  EPI.TypeQuals = Qualifiers();
8412  EPI.RefQualifier = RQ_None;
8413  return Context.getFunctionType(Context.VoidTy, None, EPI);
8414 }
8415 
8416 static void extendLeft(SourceRange &R, SourceRange Before) {
8417  if (Before.isInvalid())
8418  return;
8419  R.setBegin(Before.getBegin());
8420  if (R.getEnd().isInvalid())
8421  R.setEnd(Before.getEnd());
8422 }
8423 
8425  if (After.isInvalid())
8426  return;
8427  if (R.getBegin().isInvalid())
8428  R.setBegin(After.getBegin());
8429  R.setEnd(After.getEnd());
8430 }
8431 
8432 /// CheckConversionDeclarator - Called by ActOnDeclarator to check the
8433 /// well-formednes of the conversion function declarator @p D with
8434 /// type @p R. If there are any errors in the declarator, this routine
8435 /// will emit diagnostics and return true. Otherwise, it will return
8436 /// false. Either way, the type @p R will be updated to reflect a
8437 /// well-formed type for the conversion operator.
8439  StorageClass& SC) {
8440  // C++ [class.conv.fct]p1:
8441  // Neither parameter types nor return type can be specified. The
8442  // type of a conversion function (8.3.5) is "function taking no
8443  // parameter returning conversion-type-id."
8444  if (SC == SC_Static) {
8445  if (!D.isInvalidType())
8446  Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
8448  << D.getName().getSourceRange();
8449  D.setInvalidType();
8450  SC = SC_None;
8451  }
8452 
8453  TypeSourceInfo *ConvTSI = nullptr;
8454  QualType ConvType =
8455  GetTypeFromParser(D.getName().ConversionFunctionId, &ConvTSI);
8456 
8457  const DeclSpec &DS = D.getDeclSpec();
8458  if (DS.hasTypeSpecifier() && !D.isInvalidType()) {
8459  // Conversion functions don't have return types, but the parser will
8460  // happily parse something like:
8461  //
8462  // class X {
8463  // float operator bool();
8464  // };
8465  //
8466  // The return type will be changed later anyway.
8467  Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
8468  << SourceRange(DS.getTypeSpecTypeLoc())
8469  << SourceRange(D.getIdentifierLoc());
8470  D.setInvalidType();
8471  } else if (DS.getTypeQualifiers() && !D.isInvalidType()) {
8472  // It's also plausible that the user writes type qualifiers in the wrong
8473  // place, such as:
8474  // struct S { const operator int(); };
8475  // FIXME: we could provide a fixit to move the qualifiers onto the
8476  // conversion type.
8477  Diag(D.getIdentifierLoc(), diag::err_conv_function_with_complex_decl)
8478  << SourceRange(D.getIdentifierLoc()) << 0;
8479  D.setInvalidType();
8480  }
8481 
8482  const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
8483 
8484  // Make sure we don't have any parameters.
8485  if (Proto->getNumParams() > 0) {
8486  Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
8487 
8488  // Delete the parameters.
8490  D.setInvalidType();
8491  } else if (Proto->isVariadic()) {
8492  Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
8493  D.setInvalidType();
8494  }
8495 
8496  // Diagnose "&operator bool()" and other such nonsense. This
8497  // is actually a gcc extension which we don't support.
8498  if (Proto->getReturnType() != ConvType) {
8499  bool NeedsTypedef = false;
8500  SourceRange Before, After;
8501 
8502  // Walk the chunks and extract information on them for our diagnostic.
8503  bool PastFunctionChunk = false;
8504  for (auto &Chunk : D.type_objects()) {
8505  switch (Chunk.Kind) {
8507  if (!PastFunctionChunk) {
8508  if (Chunk.Fun.HasTrailingReturnType) {
8509  TypeSourceInfo *TRT = nullptr;
8510  GetTypeFromParser(Chunk.Fun.getTrailingReturnType(), &TRT);
8511  if (TRT) extendRight(After, TRT->getTypeLoc().getSourceRange());
8512  }
8513  PastFunctionChunk = true;
8514  break;
8515  }
8516  LLVM_FALLTHROUGH;
8518  NeedsTypedef = true;
8519  extendRight(After, Chunk.getSourceRange());
8520  break;
8521 
8526  case DeclaratorChunk::Pipe:
8527  extendLeft(Before, Chunk.getSourceRange());
8528  break;
8529 
8531  extendLeft(Before, Chunk.Loc);
8532  extendRight(After, Chunk.EndLoc);
8533  break;
8534  }
8535  }
8536 
8537  SourceLocation Loc = Before.isValid() ? Before.getBegin() :
8538  After.isValid() ? After.getBegin() :
8539  D.getIdentifierLoc();
8540  auto &&DB = Diag(Loc, diag::err_conv_function_with_complex_decl);
8541  DB << Before << After;
8542 
8543  if (!NeedsTypedef) {
8544  DB << /*don't need a typedef*/0;
8545 
8546  // If we can provide a correct fix-it hint, do so.
8547  if (After.isInvalid() && ConvTSI) {
8548  SourceLocation InsertLoc =
8549  getLocForEndOfToken(ConvTSI->getTypeLoc().getEndLoc());
8550  DB << FixItHint::CreateInsertion(InsertLoc, " ")
8552  InsertLoc, CharSourceRange::getTokenRange(Before))
8553  << FixItHint::CreateRemoval(Before);
8554  }
8555  } else if (!Proto->getReturnType()->isDependentType()) {
8556  DB << /*typedef*/1 << Proto->getReturnType();
8557  } else if (getLangOpts().CPlusPlus11) {
8558  DB << /*alias template*/2 << Proto->getReturnType();
8559  } else {
8560  DB << /*might not be fixable*/3;
8561  }
8562 
8563  // Recover by incorporating the other type chunks into the result type.
8564  // Note, this does *not* change the name of the function. This is compatible
8565  // with the GCC extension:
8566  // struct S { &operator int(); } s;
8567  // int &r = s.operator int(); // ok in GCC
8568  // S::operator int&() {} // error in GCC, function name is 'operator int'.
8569  ConvType = Proto->getReturnType();
8570  }
8571 
8572  // C++ [class.conv.fct]p4:
8573  // The conversion-type-id shall not represent a function type nor
8574  // an array type.
8575  if (ConvType->isArrayType()) {
8576  Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
8577  ConvType = Context.getPointerType(ConvType);
8578  D.setInvalidType();
8579  } else if (ConvType->isFunctionType()) {
8580  Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
8581  ConvType = Context.getPointerType(ConvType);
8582  D.setInvalidType();
8583  }
8584 
8585  // Rebuild the function type "R" without any parameters (in case any
8586  // of the errors above fired) and with the conversion type as the
8587  // return type.
8588  if (D.isInvalidType())
8589  R = Context.getFunctionType(ConvType, None, Proto->getExtProtoInfo());
8590 
8591  // C++0x explicit conversion operators.
8592  if (DS.isExplicitSpecified())
8593  Diag(DS.getExplicitSpecLoc(),
8594  getLangOpts().CPlusPlus11
8595  ? diag::warn_cxx98_compat_explicit_conversion_functions
8596  : diag::ext_explicit_conversion_functions)
8597  << SourceRange(DS.getExplicitSpecLoc());
8598 }
8599 
8600 /// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
8601 /// the declaration of the given C++ conversion function. This routine
8602 /// is responsible for recording the conversion function in the C++
8603 /// class, if possible.
8605  assert(Conversion && "Expected to receive a conversion function declaration");
8606 
8607  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
8608 
8609  // Make sure we aren't redeclaring the conversion function.
8610  QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
8611 
8612  // C++ [class.conv.fct]p1:
8613  // [...] A conversion function is never used to convert a
8614  // (possibly cv-qualified) object to the (possibly cv-qualified)
8615  // same object type (or a reference to it), to a (possibly
8616  // cv-qualified) base class of that type (or a reference to it),
8617  // or to (possibly cv-qualified) void.
8618  // FIXME: Suppress this warning if the conversion function ends up being a
8619  // virtual function that overrides a virtual function in a base class.
8620  QualType ClassType
8621  = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
8622  if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
8623  ConvType = ConvTypeRef->getPointeeType();
8624  if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared &&
8626  /* Suppress diagnostics for instantiations. */;
8627  else if (ConvType->isRecordType()) {
8628  ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
8629  if (ConvType == ClassType)
8630  Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
8631  << ClassType;
8632  else if (IsDerivedFrom(Conversion->getLocation(), ClassType, ConvType))
8633  Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
8634  << ClassType << ConvType;
8635  } else if (ConvType->isVoidType()) {
8636  Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
8637  << ClassType << ConvType;
8638  }
8639 
8640  if (FunctionTemplateDecl *ConversionTemplate
8641  = Conversion->getDescribedFunctionTemplate())
8642  return ConversionTemplate;
8643 
8644  return Conversion;
8645 }
8646 
8647 namespace {
8648 /// Utility class to accumulate and print a diagnostic listing the invalid
8649 /// specifier(s) on a declaration.
8650 struct BadSpecifierDiagnoser {
8651  BadSpecifierDiagnoser(Sema &S, SourceLocation Loc, unsigned DiagID)
8652  : S(S), Diagnostic(S.Diag(Loc, DiagID)) {}
8653  ~BadSpecifierDiagnoser() {
8654  Diagnostic << Specifiers;
8655  }
8656 
8657  template<typename T> void check(SourceLocation SpecLoc, T Spec) {
8658  return check(SpecLoc, DeclSpec::getSpecifierName(Spec));
8659  }
8660  void check(SourceLocation SpecLoc, DeclSpec::TST Spec) {
8661  return check(SpecLoc,
8663  }
8664  void check(SourceLocation SpecLoc, const char *Spec) {
8665  if (SpecLoc.isInvalid()) return;
8666  Diagnostic << SourceRange(SpecLoc, SpecLoc);
8667  if (!Specifiers.empty()) Specifiers += " ";
8668  Specifiers += Spec;
8669  }
8670 
8671  Sema &S;
8673  std::string Specifiers;
8674 };
8675 }
8676 
8677 /// Check the validity of a declarator that we parsed for a deduction-guide.
8678 /// These aren't actually declarators in the grammar, so we need to check that
8679 /// the user didn't specify any pieces that are not part of the deduction-guide
8680 /// grammar.
8682  StorageClass &SC) {
8683  TemplateName GuidedTemplate = D.getName().TemplateName.get().get();
8684  TemplateDecl *GuidedTemplateDecl = GuidedTemplate.getAsTemplateDecl();
8685  assert(GuidedTemplateDecl && "missing template decl for deduction guide");
8686 
8687  // C++ [temp.deduct.guide]p3:
8688  // A deduction-gide shall be declared in the same scope as the
8689  // corresponding class template.
8690  if (!CurContext->getRedeclContext()->Equals(
8691  GuidedTemplateDecl->getDeclContext()->getRedeclContext())) {
8692  Diag(D.getIdentifierLoc(), diag::err_deduction_guide_wrong_scope)
8693  << GuidedTemplateDecl;
8694  Diag(GuidedTemplateDecl->getLocation(), diag::note_template_decl_here);
8695  }
8696 
8697  auto &DS = D.getMutableDeclSpec();
8698  // We leave 'friend' and 'virtual' to be rejected in the normal way.
8699  if (DS.hasTypeSpecifier() || DS.getTypeQualifiers() ||
8700  DS.getStorageClassSpecLoc().isValid() || DS.isInlineSpecified() ||
8701  DS.isNoreturnSpecified() || DS.isConstexprSpecified()) {
8702  BadSpecifierDiagnoser Diagnoser(
8703  *this, D.getIdentifierLoc(),
8704  diag::err_deduction_guide_invalid_specifier);
8705 
8706  Diagnoser.check(DS.getStorageClassSpecLoc(), DS.getStorageClassSpec());
8708  SC = SC_None;
8709 
8710  // 'explicit' is permitted.
8711  Diagnoser.check(DS.getInlineSpecLoc(), "inline");
8712  Diagnoser.check(DS.getNoreturnSpecLoc(), "_Noreturn");
8713  Diagnoser.check(DS.getConstexprSpecLoc(), "constexpr");
8714  DS.ClearConstexprSpec();
8715 
8716  Diagnoser.check(DS.getConstSpecLoc(), "const");
8717  Diagnoser.check(DS.getRestrictSpecLoc(), "__restrict");
8718  Diagnoser.check(DS.getVolatileSpecLoc(), "volatile");
8719  Diagnoser.check(DS.getAtomicSpecLoc(), "_Atomic");
8720  Diagnoser.check(DS.getUnalignedSpecLoc(), "__unaligned");
8721  DS.ClearTypeQualifiers();
8722 
8723  Diagnoser.check(DS.getTypeSpecComplexLoc(), DS.getTypeSpecComplex());
8724  Diagnoser.check(DS.getTypeSpecSignLoc(), DS.getTypeSpecSign());
8725  Diagnoser.check(DS.getTypeSpecWidthLoc(), DS.getTypeSpecWidth());
8726  Diagnoser.check(DS.getTypeSpecTypeLoc(), DS.getTypeSpecType());
8727  DS.ClearTypeSpecType();
8728  }
8729 
8730  if (D.isInvalidType())
8731  return;
8732 
8733  // Check the declarator is simple enough.
8734  bool FoundFunction = false;
8735  for (const DeclaratorChunk &Chunk : llvm::reverse(D.type_objects())) {
8736  if (Chunk.Kind == DeclaratorChunk::Paren)
8737  continue;
8738  if (Chunk.Kind != DeclaratorChunk::Function || FoundFunction) {
8740  diag::err_deduction_guide_with_complex_decl)
8741  << D.getSourceRange();
8742  break;
8743  }
8744  if (!Chunk.Fun.hasTrailingReturnType()) {
8745  Diag(D.getName().getBeginLoc(),
8746  diag::err_deduction_guide_no_trailing_return_type);
8747  break;
8748  }
8749 
8750  // Check that the return type is written as a specialization of
8751  // the template specified as the deduction-guide's name.
8752  ParsedType TrailingReturnType = Chunk.Fun.getTrailingReturnType();
8753  TypeSourceInfo *TSI = nullptr;
8754  QualType RetTy = GetTypeFromParser(TrailingReturnType, &TSI);
8755  assert(TSI && "deduction guide has valid type but invalid return type?");
8756  bool AcceptableReturnType = false;
8757  bool MightInstantiateToSpecialization = false;
8758  if (auto RetTST =
8760  TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
8761  bool TemplateMatches =
8762  Context.hasSameTemplateName(SpecifiedName, GuidedTemplate);
8763  if (SpecifiedName.getKind() == TemplateName::Template && TemplateMatches)
8764  AcceptableReturnType = true;
8765  else {
8766  // This could still instantiate to the right type, unless we know it
8767  // names the wrong class template.
8768  auto *TD = SpecifiedName.getAsTemplateDecl();
8769  MightInstantiateToSpecialization = !(TD && isa<ClassTemplateDecl>(TD) &&
8770  !TemplateMatches);
8771  }
8772  } else if (!RetTy.hasQualifiers() && RetTy->isDependentType()) {
8773  MightInstantiateToSpecialization = true;
8774  }
8775 
8776  if (!AcceptableReturnType) {
8777  Diag(TSI->getTypeLoc().getBeginLoc(),
8778  diag::err_deduction_guide_bad_trailing_return_type)
8779  << GuidedTemplate << TSI->getType()
8780  << MightInstantiateToSpecialization
8781  << TSI->getTypeLoc().getSourceRange();
8782  }
8783 
8784  // Keep going to check that we don't have any inner declarator pieces (we
8785  // could still have a function returning a pointer to a function).
8786  FoundFunction = true;
8787  }
8788 
8789  if (D.isFunctionDefinition())
8790  Diag(D.getIdentifierLoc(), diag::err_deduction_guide_defines_function);
8791 }
8792 
8793 //===----------------------------------------------------------------------===//
8794 // Namespace Handling
8795 //===----------------------------------------------------------------------===//
8796 
8797 /// Diagnose a mismatch in 'inline' qualifiers when a namespace is
8798 /// reopened.
8800  SourceLocation Loc,
8801  IdentifierInfo *II, bool *IsInline,
8802  NamespaceDecl *PrevNS) {
8803  assert(*IsInline != PrevNS->isInline());
8804 
8805  // HACK: Work around a bug in libstdc++4.6's <atomic>, where
8806  // std::__atomic[0,1,2] are defined as non-inline namespaces, then reopened as
8807  // inline namespaces, with the intention of bringing names into namespace std.
8808  //
8809  // We support this just well enough to get that case working; this is not
8810  // sufficient to support reopening namespaces as inline in general.
8811  if (*IsInline && II && II->getName().startswith("__atomic") &&
8813  // Mark all prior declarations of the namespace as inline.
8814  for (NamespaceDecl *NS = PrevNS->getMostRecentDecl(); NS;
8815  NS = NS->getPreviousDecl())
8816  NS->setInline(*IsInline);
8817  // Patch up the lookup table for the containing namespace. This isn't really
8818  // correct, but it's good enough for this particular case.
8819  for (auto *I : PrevNS->decls())
8820  if (auto *ND = dyn_cast<NamedDecl>(I))
8821  PrevNS->getParent()->makeDeclVisibleInContext(ND);
8822  return;
8823  }
8824 
8825  if (PrevNS->isInline())
8826  // The user probably just forgot the 'inline', so suggest that it
8827  // be added back.
8828  S.Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
8829  << FixItHint::CreateInsertion(KeywordLoc, "inline ");
8830  else
8831  S.Diag(Loc, diag::err_inline_namespace_mismatch);
8832 
8833  S.Diag(PrevNS->getLocation(), diag::note_previous_definition);
8834  *IsInline = PrevNS->isInline();
8835 }
8836 
8837 /// ActOnStartNamespaceDef - This is called at the start of a namespace
8838 /// definition.
8840  Scope *NamespcScope, SourceLocation InlineLoc, SourceLocation NamespaceLoc,
8841  SourceLocation IdentLoc, IdentifierInfo *II, SourceLocation LBrace,
8842  const ParsedAttributesView &AttrList, UsingDirectiveDecl *&UD) {
8843  SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc;
8844  // For anonymous namespace, take the location of the left brace.
8845  SourceLocation Loc = II ? IdentLoc : LBrace;
8846  bool IsInline = InlineLoc.isValid();
8847  bool IsInvalid = false;
8848  bool IsStd = false;
8849  bool AddToKnown = false;
8850  Scope *DeclRegionScope = NamespcScope->getParent();
8851 
8852  NamespaceDecl *PrevNS = nullptr;
8853  if (II) {
8854  // C++ [namespace.def]p2:
8855  // The identifier in an original-namespace-definition shall not
8856  // have been previously defined in the declarative region in
8857  // which the original-namespace-definition appears. The
8858  // identifier in an original-namespace-definition is the name of
8859  // the namespace. Subsequently in that declarative region, it is
8860  // treated as an original-namespace-name.
8861  //
8862  // Since namespace names are unique in their scope, and we don't
8863  // look through using directives, just look for any ordinary names
8864  // as if by qualified name lookup.
8865  LookupResult R(*this, II, IdentLoc, LookupOrdinaryName,
8866  ForExternalRedeclaration);
8867  LookupQualifiedName(R, CurContext->getRedeclContext());
8868  NamedDecl *PrevDecl =
8869  R.isSingleResult() ? R.getRepresentativeDecl() : nullptr;
8870  PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
8871 
8872  if (PrevNS) {
8873  // This is an extended namespace definition.
8874  if (IsInline != PrevNS->isInline())
8875  DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, Loc, II,
8876  &IsInline, PrevNS);
8877  } else if (PrevDecl) {
8878  // This is an invalid name redefinition.
8879  Diag(Loc, diag::err_redefinition_different_kind)
8880  << II;
8881  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
8882  IsInvalid = true;
8883  // Continue on to push Namespc as current DeclContext and return it.
8884  } else if (II->isStr("std") &&
8885  CurContext->getRedeclContext()->isTranslationUnit()) {
8886  // This is the first "real" definition of the namespace "std", so update
8887  // our cache of the "std" namespace to point at this definition.
8888  PrevNS = getStdNamespace();
8889  IsStd = true;
8890  AddToKnown = !IsInline;
8891  } else {
8892  // We've seen this namespace for the first time.
8893  AddToKnown = !IsInline;
8894  }
8895  } else {
8896  // Anonymous namespaces.
8897 
8898  // Determine whether the parent already has an anonymous namespace.
8899  DeclContext *Parent = CurContext->getRedeclContext();
8900  if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
8901  PrevNS = TU->getAnonymousNamespace();
8902  } else {
8903  NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
8904  PrevNS = ND->getAnonymousNamespace();
8905  }
8906 
8907  if (PrevNS && IsInline != PrevNS->isInline())
8908  DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, NamespaceLoc, II,
8909  &IsInline, PrevNS);
8910  }
8911 
8912  NamespaceDecl *Namespc = NamespaceDecl::Create(Context, CurContext, IsInline,
8913  StartLoc, Loc, II, PrevNS);
8914  if (IsInvalid)
8915  Namespc->setInvalidDecl();
8916 
8917  ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
8918  AddPragmaAttributes(DeclRegionScope, Namespc);
8919 
8920  // FIXME: Should we be merging attributes?
8921  if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
8922  PushNamespaceVisibilityAttr(Attr, Loc);
8923 
8924  if (IsStd)
8925  StdNamespace = Namespc;
8926  if (AddToKnown)
8927  KnownNamespaces[Namespc] = false;
8928 
8929  if (II) {
8930  PushOnScopeChains(Namespc, DeclRegionScope);
8931  } else {
8932  // Link the anonymous namespace into its parent.
8933  DeclContext *Parent = CurContext->getRedeclContext();
8934  if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
8935  TU->setAnonymousNamespace(Namespc);
8936  } else {
8937  cast<NamespaceDecl>(Parent)->setAnonymousNamespace(Namespc);
8938  }
8939 
8940  CurContext->addDecl(Namespc);
8941 
8942  // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
8943  // behaves as if it were replaced by
8944  // namespace unique { /* empty body */ }
8945  // using namespace unique;
8946  // namespace unique { namespace-body }
8947  // where all occurrences of 'unique' in a translation unit are
8948  // replaced by the same identifier and this identifier differs
8949  // from all other identifiers in the entire program.
8950 
8951  // We just create the namespace with an empty name and then add an
8952  // implicit using declaration, just like the standard suggests.
8953  //
8954  // CodeGen enforces the "universally unique" aspect by giving all
8955  // declarations semantically contained within an anonymous
8956  // namespace internal linkage.
8957 
8958  if (!PrevNS) {
8959  UD = UsingDirectiveDecl::Create(Context, Parent,
8960  /* 'using' */ LBrace,
8961  /* 'namespace' */ SourceLocation(),
8962  /* qualifier */ NestedNameSpecifierLoc(),
8963  /* identifier */ SourceLocation(),
8964  Namespc,
8965  /* Ancestor */ Parent);
8966  UD->setImplicit();
8967  Parent->addDecl(UD);
8968  }
8969  }
8970 
8971  ActOnDocumentableDecl(Namespc);
8972 
8973  // Although we could have an invalid decl (i.e. the namespace name is a
8974  // redefinition), push it as current DeclContext and try to continue parsing.
8975  // FIXME: We should be able to push Namespc here, so that the each DeclContext
8976  // for the namespace has the declarations that showed up in that particular
8977  // namespace definition.
8978  PushDeclContext(NamespcScope, Namespc);
8979  return Namespc;
8980 }
8981 
8982 /// getNamespaceDecl - Returns the namespace a decl represents. If the decl
8983 /// is a namespace alias, returns the namespace it points to.
8985  if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
8986  return AD->getNamespace();
8987  return dyn_cast_or_null<NamespaceDecl>(D);
8988 }
8989 
8990 /// ActOnFinishNamespaceDef - This callback is called after a namespace is
8991 /// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
8993  NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
8994  assert(Namespc && "Invalid parameter, expected NamespaceDecl");
8995  Namespc->setRBraceLoc(RBrace);
8996  PopDeclContext();
8997  if (Namespc->hasAttr<VisibilityAttr>())
8998  PopPragmaVisibility(true, RBrace);
8999 }
9000 
9002  return cast_or_null<CXXRecordDecl>(
9003  StdBadAlloc.get(Context.getExternalSource()));
9004 }
9005 
9007  return cast_or_null<EnumDecl>(StdAlignValT.get(Context.getExternalSource()));
9008 }
9009 
9011  return cast_or_null<NamespaceDecl>(
9012  StdNamespace.get(Context.getExternalSource()));
9013 }
9014 
9016  if (!StdExperimentalNamespaceCache) {
9017  if (auto Std = getStdNamespace()) {
9018  LookupResult Result(*this, &PP.getIdentifierTable().get("experimental"),
9019  SourceLocation(), LookupNamespaceName);
9020  if (!LookupQualifiedName(Result, Std) ||
9021  !(StdExperimentalNamespaceCache =
9022  Result.getAsSingle<NamespaceDecl>()))
9023  Result.suppressDiagnostics();
9024  }
9025  }
9026  return StdExperimentalNamespaceCache;
9027 }
9028 
9029 namespace {
9030 
9032  USS_InvalidMember,
9033  USS_MissingMember,
9034  USS_NonTrivial,
9035  USS_Other
9036 };
9037 
9038 struct InvalidSTLDiagnoser {
9039  Sema &S;
9040  SourceLocation Loc;
9041  QualType TyForDiags;
9042 
9043  QualType operator()(UnsupportedSTLSelect Sel = USS_Other, StringRef Name = "",
9044  const VarDecl *VD = nullptr) {
9045  {
9046  auto D = S.Diag(Loc, diag::err_std_compare_type_not_supported)
9047  << TyForDiags << ((int)Sel);
9048  if (Sel == USS_InvalidMember || Sel == USS_MissingMember) {
9049  assert(!Name.empty());
9050  D << Name;
9051  }
9052  }
9053  if (Sel == USS_InvalidMember) {
9054  S.Diag(VD->getLocation(), diag::note_var_declared_here)
9055  << VD << VD->getSourceRange();
9056  }
9057  return QualType();
9058  }
9059 };
9060 } // namespace
9061 
9063  SourceLocation Loc) {
9064  assert(getLangOpts().CPlusPlus &&
9065  "Looking for comparison category type outside of C++.");
9066 
9067  // Check if we've already successfully checked the comparison category type
9068  // before. If so, skip checking it again.
9069  ComparisonCategoryInfo *Info = Context.CompCategories.lookupInfo(Kind);
9070  if (Info && FullyCheckedComparisonCategories[static_cast<unsigned>(Kind)])
9071  return Info->getType();
9072 
9073  // If lookup failed
9074  if (!Info) {
9075  std::string NameForDiags = "std::";
9076  NameForDiags += ComparisonCategories::getCategoryString(Kind);
9077  Diag(Loc, diag::err_implied_comparison_category_type_not_found)
9078  << NameForDiags;
9079  return QualType();
9080  }
9081 
9082  assert(Info->Kind == Kind);
9083  assert(Info->Record);
9084 
9085  // Update the Record decl in case we encountered a forward declaration on our
9086  // first pass. FIXME: This is a bit of a hack.
9087  if (Info->Record->hasDefinition())
9088  Info->Record = Info->Record->getDefinition();
9089 
9090  // Use an elaborated type for diagnostics which has a name containing the
9091  // prepended 'std' namespace but not any inline namespace names.
9092  QualType TyForDiags = [&]() {
9093  auto *NNS =
9094  NestedNameSpecifier::Create(Context, nullptr, getStdNamespace());
9095  return Context.getElaboratedType(ETK_None, NNS, Info->getType());
9096  }();
9097 
9098  if (RequireCompleteType(Loc, TyForDiags, diag::err_incomplete_type))
9099  return QualType();
9100 
9101  InvalidSTLDiagnoser UnsupportedSTLError{*this, Loc, TyForDiags};
9102 
9103  if (!Info->Record->isTriviallyCopyable())
9104  return UnsupportedSTLError(USS_NonTrivial);
9105 
9106  for (const CXXBaseSpecifier &BaseSpec : Info->Record->bases()) {
9107  CXXRecordDecl *Base = BaseSpec.getType()->getAsCXXRecordDecl();
9108  // Tolerate empty base classes.
9109  if (Base->isEmpty())
9110  continue;
9111  // Reject STL implementations which have at least one non-empty base.
9112  return UnsupportedSTLError();
9113  }
9114 
9115  // Check that the STL has implemented the types using a single integer field.
9116  // This expectation allows better codegen for builtin operators. We require:
9117  // (1) The class has exactly one field.
9118  // (2) The field is an integral or enumeration type.
9119  auto FIt = Info->Record->field_begin(), FEnd = Info->Record->field_end();
9120  if (std::distance(FIt, FEnd) != 1 ||
9121  !FIt->getType()->isIntegralOrEnumerationType()) {
9122  return UnsupportedSTLError();
9123  }
9124 
9125  // Build each of the require values and store them in Info.
9126  for (ComparisonCategoryResult CCR :
9128  StringRef MemName = ComparisonCategories::getResultString(CCR);
9129  ComparisonCategoryInfo::ValueInfo *ValInfo = Info->lookupValueInfo(CCR);
9130 
9131  if (!ValInfo)
9132  return UnsupportedSTLError(USS_MissingMember, MemName);
9133 
9134  VarDecl *VD = ValInfo->VD;
9135  assert(VD && "should not be null!");
9136 
9137  // Attempt to diagnose reasons why the STL definition of this type
9138  // might be foobar, including it failing to be a constant expression.
9139  // TODO Handle more ways the lookup or result can be invalid.
9140  if (!VD->isStaticDataMember() || !VD->isConstexpr() || !VD->hasInit() ||
9141  !VD->checkInitIsICE())
9142  return UnsupportedSTLError(USS_InvalidMember, MemName, VD);
9143 
9144  // Attempt to evaluate the var decl as a constant expression and extract
9145  // the value of its first field as a ICE. If this fails, the STL
9146  // implementation is not supported.
9147  if (!ValInfo->hasValidIntValue())
9148  return UnsupportedSTLError();
9149 
9150  MarkVariableReferenced(Loc, VD);
9151  }
9152 
9153  // We've successfully built the required types and expressions. Update
9154  // the cache and return the newly cached value.
9155  FullyCheckedComparisonCategories[static_cast<unsigned>(Kind)] = true;
9156  return Info->getType();
9157 }
9158 
9159 /// Retrieve the special "std" namespace, which may require us to
9160 /// implicitly define the namespace.
9162  if (!StdNamespace) {
9163  // The "std" namespace has not yet been defined, so build one implicitly.
9164  StdNamespace = NamespaceDecl::Create(Context,
9165  Context.getTranslationUnitDecl(),
9166  /*Inline=*/false,
9168  &PP.getIdentifierTable().get("std"),
9169  /*PrevDecl=*/nullptr);
9170  getStdNamespace()->setImplicit(true);
9171  }
9172 
9173  return getStdNamespace();
9174 }
9175 
9177  assert(getLangOpts().CPlusPlus &&
9178  "Looking for std::initializer_list outside of C++.");
9179 
9180  // We're looking for implicit instantiations of
9181  // template <typename E> class std::initializer_list.
9182 
9183  if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it.
9184  return false;
9185 
9186  ClassTemplateDecl *Template = nullptr;
9187  const TemplateArgument *Arguments = nullptr;
9188 
9189  if (const RecordType *RT = Ty->getAs<RecordType>()) {
9190 
9191  ClassTemplateSpecializationDecl *Specialization =
9192  dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
9193  if (!Specialization)
9194  return false;
9195 
9196  Template = Specialization->getSpecializedTemplate();
9197  Arguments = Specialization->getTemplateArgs().data();
9198  } else if (const TemplateSpecializationType *TST =
9200  Template = dyn_cast_or_null<ClassTemplateDecl>(
9201  TST->getTemplateName().getAsTemplateDecl());
9202  Arguments = TST->getArgs();
9203  }
9204  if (!Template)
9205  return false;
9206 
9207  if (!StdInitializerList) {
9208  // Haven't recognized std::initializer_list yet, maybe this is it.
9209  CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
9210  if (TemplateClass->getIdentifier() !=
9211  &PP.getIdentifierTable().get("initializer_list") ||
9212  !getStdNamespace()->InEnclosingNamespaceSetOf(
9213  TemplateClass->getDeclContext()))
9214  return false;
9215  // This is a template called std::initializer_list, but is it the right
9216  // template?
9217  TemplateParameterList *Params = Template->getTemplateParameters();
9218  if (Params->getMinRequiredArguments() != 1)
9219  return false;
9220  if (!isa<TemplateTypeParmDecl>(Params->getParam(0)))
9221  return false;
9222 
9223  // It's the right template.
9224  StdInitializerList = Template;
9225  }
9226 
9227  if (Template->getCanonicalDecl() != StdInitializerList->getCanonicalDecl())
9228  return false;
9229 
9230  // This is an instance of std::initializer_list. Find the argument type.
9231  if (Element)
9232  *Element = Arguments[0].getAsType();
9233  return true;
9234 }
9235 
9238  if (!Std) {
9239  S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
9240  return nullptr;
9241  }
9242 
9243  LookupResult Result(S, &S.PP.getIdentifierTable().get("initializer_list"),
9245  if (!S.LookupQualifiedName(Result, Std)) {
9246  S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
9247  return nullptr;
9248  }
9249  ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>();
9250  if (!Template) {
9251  Result.suppressDiagnostics();
9252  // We found something weird. Complain about the first thing we found.
9253  NamedDecl *Found = *Result.begin();
9254  S.Diag(Found->getLocation(), diag::err_malformed_std_initializer_list);
9255  return nullptr;
9256  }
9257 
9258  // We found some template called std::initializer_list. Now verify that it's
9259  // correct.
9260  TemplateParameterList *Params = Template->getTemplateParameters();
9261  if (Params->getMinRequiredArguments() != 1 ||
9262  !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
9263  S.Diag(Template->getLocation(), diag::err_malformed_std_initializer_list);
9264  return nullptr;
9265  }
9266 
9267  return Template;
9268 }
9269 
9271  if (!StdInitializerList) {
9272  StdInitializerList = LookupStdInitializerList(*this, Loc);
9273  if (!StdInitializerList)
9274  return QualType();
9275  }
9276 
9277  TemplateArgumentListInfo Args(Loc, Loc);
9279  Context.getTrivialTypeSourceInfo(Element,
9280  Loc)));
9281  return Context.getCanonicalType(
9282  CheckTemplateIdType(TemplateName(StdInitializerList), Loc, Args));
9283 }
9284 
9286  // C++ [dcl.init.list]p2:
9287  // A constructor is an initializer-list constructor if its first parameter
9288  // is of type std::initializer_list<E> or reference to possibly cv-qualified
9289  // std::initializer_list<E> for some type E, and either there are no other
9290  // parameters or else all other parameters have default arguments.
9291  if (Ctor->getNumParams() < 1 ||
9292  (Ctor->getNumParams() > 1 && !Ctor->getParamDecl(1)->hasDefaultArg()))
9293  return false;
9294 
9295  QualType ArgType = Ctor->getParamDecl(0)->getType();
9296  if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
9297  ArgType = RT->getPointeeType().getUnqualifiedType();
9298 
9299  return isStdInitializerList(ArgType, nullptr);
9300 }
9301 
9302 /// Determine whether a using statement is in a context where it will be
9303 /// apply in all contexts.
9305  switch (CurContext->getDeclKind()) {
9306  case Decl::TranslationUnit:
9307  return true;
9308  case Decl::LinkageSpec:
9309  return IsUsingDirectiveInToplevelContext(CurContext->getParent());
9310  default:
9311  return false;
9312  }
9313 }
9314 
9315 namespace {
9316 
9317 // Callback to only accept typo corrections that are namespaces.
9318 class NamespaceValidatorCCC : public CorrectionCandidateCallback {
9319 public:
9320  bool ValidateCandidate(const TypoCorrection &candidate) override {
9321  if (NamedDecl *ND = candidate.getCorrectionDecl())
9322  return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
9323  return false;
9324  }
9325 };
9326 
9327 }
9328 
9330  CXXScopeSpec &SS,
9331  SourceLocation IdentLoc,
9332  IdentifierInfo *Ident) {
9333  R.clear();
9334  if (TypoCorrection Corrected =
9335  S.CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), Sc, &SS,
9336  llvm::make_unique<NamespaceValidatorCCC>(),
9338  if (DeclContext *DC = S.computeDeclContext(SS, false)) {
9339  std::string CorrectedStr(Corrected.getAsString(S.getLangOpts()));
9340  bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
9341  Ident->getName().equals(CorrectedStr);
9342  S.diagnoseTypo(Corrected,
9343  S.PDiag(diag::err_using_directive_member_suggest)
9344  << Ident << DC << DroppedSpecifier << SS.getRange(),
9345  S.PDiag(diag::note_namespace_defined_here));
9346  } else {
9347  S.diagnoseTypo(Corrected,
9348  S.PDiag(diag::err_using_directive_suggest) << Ident,
9349  S.PDiag(diag::note_namespace_defined_here));
9350  }
9351  R.addDecl(Corrected.getFoundDecl());
9352  return true;
9353  }
9354  return false;
9355 }
9356 
9358  SourceLocation NamespcLoc, CXXScopeSpec &SS,
9359  SourceLocation IdentLoc,
9360  IdentifierInfo *NamespcName,
9361  const ParsedAttributesView &AttrList) {
9362  assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
9363  assert(NamespcName && "Invalid NamespcName.");
9364  assert(IdentLoc.isValid() && "Invalid NamespceName location.");
9365 
9366  // This can only happen along a recovery path.
9367  while (S->isTemplateParamScope())
9368  S = S->getParent();
9369  assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
9370 
9371  UsingDirectiveDecl *UDir = nullptr;
9372  NestedNameSpecifier *Qualifier = nullptr;
9373  if (SS.isSet())
9374  Qualifier = SS.getScopeRep();
9375 
9376  // Lookup namespace name.
9377  LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
9378  LookupParsedName(R, S, &SS);
9379  if (R.isAmbiguous())
9380  return nullptr;
9381 
9382  if (R.empty()) {
9383  R.clear();
9384  // Allow "using namespace std;" or "using namespace ::std;" even if
9385  // "std" hasn't been defined yet, for GCC compatibility.
9386  if ((!Qualifier || Qualifier->getKind() == NestedNameSpecifier::Global) &&
9387  NamespcName->isStr("std")) {
9388  Diag(IdentLoc, diag::ext_using_undefined_std);
9389  R.addDecl(getOrCreateStdNamespace());
9390  R.resolveKind();
9391  }
9392  // Otherwise, attempt typo correction.
9393  else TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, NamespcName);
9394  }
9395 
9396  if (!R.empty()) {
9397  NamedDecl *Named = R.getRepresentativeDecl();
9399  assert(NS && "expected namespace decl");
9400 
9401  // The use of a nested name specifier may trigger deprecation warnings.
9402  DiagnoseUseOfDecl(Named, IdentLoc);
9403 
9404  // C++ [namespace.udir]p1:
9405  // A using-directive specifies that the names in the nominated
9406  // namespace can be used in the scope in which the
9407  // using-directive appears after the using-directive. During
9408  // unqualified name lookup (3.4.1), the names appear as if they
9409  // were declared in the nearest enclosing namespace which
9410  // contains both the using-directive and the nominated
9411  // namespace. [Note: in this context, "contains" means "contains
9412  // directly or indirectly". ]
9413 
9414  // Find enclosing context containing both using-directive and
9415  // nominated namespace.
9416  DeclContext *CommonAncestor = NS;
9417  while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
9418  CommonAncestor = CommonAncestor->getParent();
9419 
9420  UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
9421  SS.getWithLocInContext(Context),
9422  IdentLoc, Named, CommonAncestor);
9423 
9424  if (IsUsingDirectiveInToplevelContext(CurContext) &&
9425  !SourceMgr.isInMainFile(SourceMgr.getExpansionLoc(IdentLoc))) {
9426  Diag(IdentLoc, diag::warn_using_directive_in_header);
9427  }
9428 
9429  PushUsingDirective(S, UDir);
9430  } else {
9431  Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
9432  }
9433 
9434  if (UDir)
9435  ProcessDeclAttributeList(S, UDir, AttrList);
9436 
9437  return UDir;
9438 }
9439 
9441  // If the scope has an associated entity and the using directive is at
9442  // namespace or translation unit scope, add the UsingDirectiveDecl into
9443  // its lookup structure so qualified name lookup can find it.
9444  DeclContext *Ctx = S->getEntity();
9445  if (Ctx && !Ctx->isFunctionOrMethod())
9446  Ctx->addDecl(UDir);
9447  else
9448  // Otherwise, it is at block scope. The using-directives will affect lookup
9449  // only to the end of the scope.
9450  S->PushUsingDirective(UDir);
9451 }
9452 
9454  SourceLocation UsingLoc,
9455  SourceLocation TypenameLoc, CXXScopeSpec &SS,
9456  UnqualifiedId &Name,
9457  SourceLocation EllipsisLoc,
9458  const ParsedAttributesView &AttrList) {
9459  assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
9460 
9461  if (SS.isEmpty()) {
9462  Diag(Name.getBeginLoc(), diag::err_using_requires_qualname);
9463  return nullptr;
9464  }
9465 
9466  switch (Name.getKind()) {
9472  break;
9473 
9476  // C++11 inheriting constructors.
9477  Diag(Name.getBeginLoc(),
9478  getLangOpts().CPlusPlus11
9479  ? diag::warn_cxx98_compat_using_decl_constructor
9480  : diag::err_using_decl_constructor)
9481  << SS.getRange();
9482 
9483  if (getLangOpts().CPlusPlus11) break;
9484 
9485  return nullptr;
9486 
9488  Diag(Name.getBeginLoc(), diag::err_using_decl_destructor) << SS.getRange();
9489  return nullptr;
9490 
9492  Diag(Name.getBeginLoc(), diag::err_using_decl_template_id)
9494  return nullptr;
9495 
9497  llvm_unreachable("cannot parse qualified deduction guide name");
9498  }
9499 
9500  DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
9501  DeclarationName TargetName = TargetNameInfo.getName();
9502  if (!TargetName)
9503  return nullptr;
9504 
9505  // Warn about access declarations.
9506  if (UsingLoc.isInvalid()) {
9507  Diag(Name.getBeginLoc(), getLangOpts().CPlusPlus11
9508  ? diag::err_access_decl
9509  : diag::warn_access_decl_deprecated)
9510  << FixItHint::CreateInsertion(SS.getRange().getBegin(), "using ");
9511  }
9512 
9513  if (EllipsisLoc.isInvalid()) {
9514  if (DiagnoseUnexpandedParameterPack(SS, UPPC_UsingDeclaration) ||
9515  DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC_UsingDeclaration))
9516  return nullptr;
9517  } else {
9519  !TargetNameInfo.containsUnexpandedParameterPack()) {
9520  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
9521  << SourceRange(SS.getBeginLoc(), TargetNameInfo.getEndLoc());
9522  EllipsisLoc = SourceLocation();
9523  }
9524  }
9525 
9526  NamedDecl *UD =
9527  BuildUsingDeclaration(S, AS, UsingLoc, TypenameLoc.isValid(), TypenameLoc,
9528  SS, TargetNameInfo, EllipsisLoc, AttrList,
9529  /*IsInstantiation*/false);
9530  if (UD)
9531  PushOnScopeChains(UD, S, /*AddToContext*/ false);
9532 
9533  return UD;
9534 }
9535 
9536 /// Determine whether a using declaration considers the given
9537 /// declarations as "equivalent", e.g., if they are redeclarations of
9538 /// the same entity or are both typedefs of the same type.
9539 static bool
9541  if (D1->getCanonicalDecl() == D2->getCanonicalDecl())
9542  return true;
9543 
9544  if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(D1))
9545  if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2))
9546  return Context.hasSameType(TD1->getUnderlyingType(),
9547  TD2->getUnderlyingType());
9548 
9549  return false;
9550 }
9551 
9552 
9553 /// Determines whether to create a using shadow decl for a particular
9554 /// decl, given the set of decls existing prior to this using lookup.
9556  const LookupResult &Previous,
9557  UsingShadowDecl *&PrevShadow) {
9558  // Diagnose finding a decl which is not from a base class of the
9559  // current class. We do this now because there are cases where this
9560  // function will silently decide not to build a shadow decl, which
9561  // will pre-empt further diagnostics.
9562  //
9563  // We don't need to do this in C++11 because we do the check once on
9564  // the qualifier.
9565  //
9566  // FIXME: diagnose the following if we care enough:
9567  // struct A { int foo; };
9568  // struct B : A { using A::foo; };
9569  // template <class T> struct C : A {};
9570  // template <class T> struct D : C<T> { using B::foo; } // <---
9571  // This is invalid (during instantiation) in C++03 because B::foo
9572  // resolves to the using decl in B, which is not a base class of D<T>.
9573  // We can't diagnose it immediately because C<T> is an unknown
9574  // specialization. The UsingShadowDecl in D<T> then points directly
9575  // to A::foo, which will look well-formed when we instantiate.
9576  // The right solution is to not collapse the shadow-decl chain.
9577  if (!getLangOpts().CPlusPlus11 && CurContext->isRecord()) {
9578  DeclContext *OrigDC = Orig->getDeclContext();
9579 
9580  // Handle enums and anonymous structs.
9581  if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
9582  CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
9583  while (OrigRec->isAnonymousStructOrUnion())
9584  OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
9585 
9586  if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
9587  if (OrigDC == CurContext) {
9588  Diag(Using->getLocation(),
9589  diag::err_using_decl_nested_name_specifier_is_current_class)
9590  << Using->getQualifierLoc().getSourceRange();
9591  Diag(Orig->getLocation(), diag::note_using_decl_target);
9592  Using->setInvalidDecl();
9593  return true;
9594  }
9595 
9596  Diag(Using->getQualifierLoc().getBeginLoc(),
9597  diag::err_using_decl_nested_name_specifier_is_not_base_class)
9598  << Using->getQualifier()
9599  << cast<CXXRecordDecl>(CurContext)
9600  << Using->getQualifierLoc().getSourceRange();
9601  Diag(Orig->getLocation(), diag::note_using_decl_target);
9602  Using->setInvalidDecl();
9603  return true;
9604  }
9605  }
9606 
9607  if (Previous.empty()) return false;
9608 
9609  NamedDecl *Target = Orig;
9610  if (isa<UsingShadowDecl>(Target))
9611  Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
9612 
9613  // If the target happens to be one of the previous declarations, we
9614  // don't have a conflict.
9615  //
9616  // FIXME: but we might be increasing its access, in which case we
9617  // should redeclare it.
9618  NamedDecl *NonTag = nullptr, *Tag = nullptr;
9619  bool FoundEquivalentDecl = false;
9620  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
9621  I != E; ++I) {
9622  NamedDecl *D = (*I)->getUnderlyingDecl();
9623  // We can have UsingDecls in our Previous results because we use the same
9624  // LookupResult for checking whether the UsingDecl itself is a valid
9625  // redeclaration.
9626  if (isa<UsingDecl>(D) || isa<UsingPackDecl>(D))
9627  continue;
9628 
9629  if (auto *RD = dyn_cast<CXXRecordDecl>(D)) {
9630  // C++ [class.mem]p19:
9631  // If T is the name of a class, then [every named member other than
9632  // a non-static data member] shall have a name different from T
9633  if (RD->isInjectedClassName() && !isa<FieldDecl>(Target) &&
9634  !isa<IndirectFieldDecl>(Target) &&
9635  !isa<UnresolvedUsingValueDecl>(Target) &&
9636  DiagnoseClassNameShadow(
9637  CurContext,
9638  DeclarationNameInfo(Using->getDeclName(), Using->getLocation())))
9639  return true;
9640  }
9641 
9642  if (IsEquivalentForUsingDecl(Context, D, Target)) {
9643  if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(*I))
9644  PrevShadow = Shadow;
9645  FoundEquivalentDecl = true;
9646  } else if (isEquivalentInternalLinkageDeclaration(D, Target)) {
9647  // We don't conflict with an existing using shadow decl of an equivalent
9648  // declaration, but we're not a redeclaration of it.
9649  FoundEquivalentDecl = true;
9650  }
9651 
9652  if (isVisible(D))
9653  (isa<TagDecl>(D) ? Tag : NonTag) = D;
9654  }
9655 
9656  if (FoundEquivalentDecl)
9657  return false;
9658 
9659  if (FunctionDecl *FD = Target->getAsFunction()) {
9660  NamedDecl *OldDecl = nullptr;
9661  switch (CheckOverload(nullptr, FD, Previous, OldDecl,
9662  /*IsForUsingDecl*/ true)) {
9663  case Ovl_Overload:
9664  return false;
9665 
9666  case Ovl_NonFunction:
9667  Diag(Using->getLocation(), diag::err_using_decl_conflict);
9668  break;
9669 
9670  // We found a decl with the exact signature.
9671  case Ovl_Match:
9672  // If we're in a record, we want to hide the target, so we
9673  // return true (without a diagnostic) to tell the caller not to
9674  // build a shadow decl.
9675  if (CurContext->isRecord())
9676  return true;
9677 
9678  // If we're not in a record, this is an error.
9679  Diag(Using->getLocation(), diag::err_using_decl_conflict);
9680  break;
9681  }
9682 
9683  Diag(Target->getLocation(), diag::note_using_decl_target);
9684  Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
9685  Using->setInvalidDecl();
9686  return true;
9687  }
9688 
9689  // Target is not a function.
9690 
9691  if (isa<TagDecl>(Target)) {
9692  // No conflict between a tag and a non-tag.
9693  if (!Tag) return false;
9694 
9695  Diag(Using->getLocation(), diag::err_using_decl_conflict);
9696  Diag(Target->getLocation(), diag::note_using_decl_target);
9697  Diag(Tag->getLocation(), diag::note_using_decl_conflict);
9698  Using->setInvalidDecl();
9699  return true;
9700  }
9701 
9702  // No conflict between a tag and a non-tag.
9703  if (!NonTag) return false;
9704 
9705  Diag(Using->getLocation(), diag::err_using_decl_conflict);
9706  Diag(Target->getLocation(), diag::note_using_decl_target);
9707  Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
9708  Using->setInvalidDecl();
9709  return true;
9710 }
9711 
9712 /// Determine whether a direct base class is a virtual base class.
9713 static bool isVirtualDirectBase(CXXRecordDecl *Derived, CXXRecordDecl *Base) {
9714  if (!Derived->getNumVBases())
9715  return false;
9716  for (auto &B : Derived->bases())
9717  if (B.getType()->getAsCXXRecordDecl() == Base)
9718  return B.isVirtual();
9719  llvm_unreachable("not a direct base class");
9720 }
9721 
9722 /// Builds a shadow declaration corresponding to a 'using' declaration.
9724  UsingDecl *UD,
9725  NamedDecl *Orig,
9726  UsingShadowDecl *PrevDecl) {
9727  // If we resolved to another shadow declaration, just coalesce them.
9728  NamedDecl *Target = Orig;
9729  if (isa<UsingShadowDecl>(Target)) {
9730  Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
9731  assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
9732  }
9733 
9734  NamedDecl *NonTemplateTarget = Target;
9735  if (auto *TargetTD = dyn_cast<TemplateDecl>(Target))
9736  NonTemplateTarget = TargetTD->getTemplatedDecl();
9737 
9738  UsingShadowDecl *Shadow;
9739  if (isa<CXXConstructorDecl>(NonTemplateTarget)) {
9740  bool IsVirtualBase =
9741  isVirtualDirectBase(cast<CXXRecordDecl>(CurContext),
9742  UD->getQualifier()->getAsRecordDecl());
9744  Context, CurContext, UD->getLocation(), UD, Orig, IsVirtualBase);
9745  } else {
9746  Shadow = UsingShadowDecl::Create(Context, CurContext, UD->getLocation(), UD,
9747  Target);
9748  }
9749  UD->addShadowDecl(Shadow);
9750 
9751  Shadow->setAccess(UD->getAccess());
9752  if (Orig->isInvalidDecl() || UD->isInvalidDecl())
9753  Shadow->setInvalidDecl();
9754 
9755  Shadow->setPreviousDecl(PrevDecl);
9756 
9757  if (S)
9758  PushOnScopeChains(Shadow, S);
9759  else
9760  CurContext->addDecl(Shadow);
9761 
9762 
9763  return Shadow;
9764 }
9765 
9766 /// Hides a using shadow declaration. This is required by the current
9767 /// using-decl implementation when a resolvable using declaration in a
9768 /// class is followed by a declaration which would hide or override
9769 /// one or more of the using decl's targets; for example:
9770 ///
9771 /// struct Base { void foo(int); };
9772 /// struct Derived : Base {
9773 /// using Base::foo;
9774 /// void foo(int);
9775 /// };
9776 ///
9777 /// The governing language is C++03 [namespace.udecl]p12:
9778 ///
9779 /// When a using-declaration brings names from a base class into a
9780 /// derived class scope, member functions in the derived class
9781 /// override and/or hide member functions with the same name and
9782 /// parameter types in a base class (rather than conflicting).
9783 ///
9784 /// There are two ways to implement this:
9785 /// (1) optimistically create shadow decls when they're not hidden
9786 /// by existing declarations, or
9787 /// (2) don't create any shadow decls (or at least don't make them
9788 /// visible) until we've fully parsed/instantiated the class.
9789 /// The problem with (1) is that we might have to retroactively remove
9790 /// a shadow decl, which requires several O(n) operations because the
9791 /// decl structures are (very reasonably) not designed for removal.
9792 /// (2) avoids this but is very fiddly and phase-dependent.
9794  if (Shadow->getDeclName().getNameKind() ==
9796  cast<CXXRecordDecl>(Shadow->getDeclContext())->removeConversion(Shadow);
9797 
9798  // Remove it from the DeclContext...
9799  Shadow->getDeclContext()->removeDecl(Shadow);
9800 
9801  // ...and the scope, if applicable...
9802  if (S) {
9803  S->RemoveDecl(Shadow);
9804  IdResolver.RemoveDecl(Shadow);
9805  }
9806 
9807  // ...and the using decl.
9808  Shadow->getUsingDecl()->removeShadowDecl(Shadow);
9809 
9810  // TODO: complain somehow if Shadow was used. It shouldn't
9811  // be possible for this to happen, because...?
9812 }
9813 
9814 /// Find the base specifier for a base class with the given type.
9816  QualType DesiredBase,
9817  bool &AnyDependentBases) {
9818  // Check whether the named type is a direct base class.
9819  CanQualType CanonicalDesiredBase = DesiredBase->getCanonicalTypeUnqualified();
9820  for (auto &Base : Derived->bases()) {
9821  CanQualType BaseType = Base.getType()->getCanonicalTypeUnqualified();
9822  if (CanonicalDesiredBase == BaseType)
9823  return &Base;
9824  if (BaseType->isDependentType())
9825  AnyDependentBases = true;
9826  }
9827  return nullptr;
9828 }
9829 
9830 namespace {
9831 class UsingValidatorCCC : public CorrectionCandidateCallback {
9832 public:
9833  UsingValidatorCCC(bool HasTypenameKeyword, bool IsInstantiation,
9834  NestedNameSpecifier *NNS, CXXRecordDecl *RequireMemberOf)
9835  : HasTypenameKeyword(HasTypenameKeyword),
9836  IsInstantiation(IsInstantiation), OldNNS(NNS),
9837  RequireMemberOf(RequireMemberOf) {}
9838 
9839  bool ValidateCandidate(const TypoCorrection &Candidate) override {
9840  NamedDecl *ND = Candidate.getCorrectionDecl();
9841 
9842  // Keywords are not valid here.
9843  if (!ND || isa<NamespaceDecl>(ND))
9844  return false;
9845 
9846  // Completely unqualified names are invalid for a 'using' declaration.
9847  if (Candidate.WillReplaceSpecifier() && !Candidate.getCorrectionSpecifier())
9848  return false;
9849 
9850  // FIXME: Don't correct to a name that CheckUsingDeclRedeclaration would
9851  // reject.
9852 
9853  if (RequireMemberOf) {
9854  auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
9855  if (FoundRecord && FoundRecord->isInjectedClassName()) {
9856  // No-one ever wants a using-declaration to name an injected-class-name
9857  // of a base class, unless they're declaring an inheriting constructor.
9858  ASTContext &Ctx = ND->getASTContext();
9859  if (!Ctx.getLangOpts().CPlusPlus11)
9860  return false;
9861  QualType FoundType = Ctx.getRecordType(FoundRecord);
9862 
9863  // Check that the injected-class-name is named as a member of its own
9864  // type; we don't want to suggest 'using Derived::Base;', since that
9865  // means something else.
9867  Candidate.WillReplaceSpecifier()
9868  ? Candidate.getCorrectionSpecifier()
9869  : OldNNS;
9870  if (!Specifier->getAsType() ||
9871  !Ctx.hasSameType(QualType(Specifier->getAsType(), 0), FoundType))
9872  return false;
9873 
9874  // Check that this inheriting constructor declaration actually names a
9875  // direct base class of the current class.
9876  bool AnyDependentBases = false;
9877  if (!findDirectBaseWithType(RequireMemberOf,
9878  Ctx.getRecordType(FoundRecord),
9879  AnyDependentBases) &&
9880  !AnyDependentBases)
9881  return false;
9882  } else {
9883  auto *RD = dyn_cast<CXXRecordDecl>(ND->getDeclContext());
9884  if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(RD))
9885  return false;
9886 
9887  // FIXME: Check that the base class member is accessible?
9888  }
9889  } else {
9890  auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
9891  if (FoundRecord && FoundRecord->isInjectedClassName())
9892  return false;
9893  }
9894 
9895  if (isa<TypeDecl>(ND))
9896  return HasTypenameKeyword || !IsInstantiation;
9897 
9898  return !HasTypenameKeyword;
9899  }
9900 
9901 private:
9902  bool HasTypenameKeyword;
9903  bool IsInstantiation;
9904  NestedNameSpecifier *OldNNS;
9905  CXXRecordDecl *RequireMemberOf;
9906 };
9907 } // end anonymous namespace
9908 
9909 /// Builds a using declaration.
9910 ///
9911 /// \param IsInstantiation - Whether this call arises from an
9912 /// instantiation of an unresolved using declaration. We treat
9913 /// the lookup differently for these declarations.
9915  Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,
9916  bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,
9917  DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,
9918  const ParsedAttributesView &AttrList, bool IsInstantiation) {
9919  assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
9920  SourceLocation IdentLoc = NameInfo.getLoc();
9921  assert(IdentLoc.isValid() && "Invalid TargetName location.");
9922 
9923  // FIXME: We ignore attributes for now.
9924 
9925  // For an inheriting constructor declaration, the name of the using
9926  // declaration is the name of a constructor in this class, not in the
9927  // base class.
9928  DeclarationNameInfo UsingName = NameInfo;
9929  if (UsingName.getName().getNameKind() == DeclarationName::CXXConstructorName)
9930  if (auto *RD = dyn_cast<CXXRecordDecl>(CurContext))
9932  Context.getCanonicalType(Context.getRecordType(RD))));
9933 
9934  // Do the redeclaration lookup in the current scope.
9935  LookupResult Previous(*this, UsingName, LookupUsingDeclName,
9936  ForVisibleRedeclaration);
9937  Previous.setHideTags(false);
9938  if (S) {
9939  LookupName(Previous, S);
9940 
9941  // It is really dumb that we have to do this.
9942  LookupResult::Filter F = Previous.makeFilter();
9943  while (F.hasNext()) {
9944  NamedDecl *D = F.next();
9945  if (!isDeclInScope(D, CurContext, S))
9946  F.erase();
9947  // If we found a local extern declaration that's not ordinarily visible,
9948  // and this declaration is being added to a non-block scope, ignore it.
9949  // We're only checking for scope conflicts here, not also for violations
9950  // of the linkage rules.
9951  else if (!CurContext->isFunctionOrMethod() && D->isLocalExternDecl() &&
9953  F.erase();
9954  }
9955  F.done();
9956  } else {
9957  assert(IsInstantiation && "no scope in non-instantiation");
9958  if (CurContext->isRecord())
9959  LookupQualifiedName(Previous, CurContext);
9960  else {
9961  // No redeclaration check is needed here; in non-member contexts we
9962  // diagnosed all possible conflicts with other using-declarations when
9963  // building the template:
9964  //
9965  // For a dependent non-type using declaration, the only valid case is
9966  // if we instantiate to a single enumerator. We check for conflicts
9967  // between shadow declarations we introduce, and we check in the template
9968  // definition for conflicts between a non-type using declaration and any
9969  // other declaration, which together covers all cases.
9970  //
9971  // A dependent typename using declaration will never successfully
9972  // instantiate, since it will always name a class member, so we reject
9973  // that in the template definition.
9974  }
9975  }
9976 
9977  // Check for invalid redeclarations.
9978  if (CheckUsingDeclRedeclaration(UsingLoc, HasTypenameKeyword,
9979  SS, IdentLoc, Previous))
9980  return nullptr;
9981 
9982  // Check for bad qualifiers.
9983  if (CheckUsingDeclQualifier(UsingLoc, HasTypenameKeyword, SS, NameInfo,
9984  IdentLoc))
9985  return nullptr;
9986 
9987  DeclContext *LookupContext = computeDeclContext(SS);
9988  NamedDecl *D;
9989  NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
9990  if (!LookupContext || EllipsisLoc.isValid()) {
9991  if (HasTypenameKeyword) {
9992  // FIXME: not all declaration name kinds are legal here
9993  D = UnresolvedUsingTypenameDecl::Create(Context, CurContext,
9994  UsingLoc, TypenameLoc,
9995  QualifierLoc,
9996  IdentLoc, NameInfo.getName(),
9997  EllipsisLoc);
9998  } else {
9999  D = UnresolvedUsingValueDecl::Create(Context, CurContext, UsingLoc,
10000  QualifierLoc, NameInfo, EllipsisLoc);
10001  }
10002  D->setAccess(AS);
10003  CurContext->addDecl(D);
10004  return D;
10005  }
10006 
10007  auto Build = [&](bool Invalid) {
10008  UsingDecl *UD =
10009  UsingDecl::Create(Context, CurContext, UsingLoc, QualifierLoc,
10010  UsingName, HasTypenameKeyword);
10011  UD->setAccess(AS);
10012  CurContext->addDecl(UD);
10013  UD->setInvalidDecl(Invalid);
10014  return UD;
10015  };
10016  auto BuildInvalid = [&]{ return Build(true); };
10017  auto BuildValid = [&]{ return Build(false); };
10018 
10019  if (RequireCompleteDeclContext(SS, LookupContext))
10020  return BuildInvalid();
10021 
10022  // Look up the target name.
10023  LookupResult R(*this, NameInfo, LookupOrdinaryName);
10024 
10025  // Unlike most lookups, we don't always want to hide tag
10026  // declarations: tag names are visible through the using declaration
10027  // even if hidden by ordinary names, *except* in a dependent context
10028  // where it's important for the sanity of two-phase lookup.
10029  if (!IsInstantiation)
10030  R.setHideTags(false);
10031 
10032  // For the purposes of this lookup, we have a base object type
10033  // equal to that of the current context.
10034  if (CurContext->isRecord()) {
10036  Context.getTypeDeclType(cast<CXXRecordDecl>(CurContext)));
10037  }
10038 
10039  LookupQualifiedName(R, LookupContext);
10040 
10041  // Try to correct typos if possible. If constructor name lookup finds no
10042  // results, that means the named class has no explicit constructors, and we
10043  // suppressed declaring implicit ones (probably because it's dependent or
10044  // invalid).
10045  if (R.empty() &&
10047  // HACK: Work around a bug in libstdc++'s detection of ::gets. Sometimes
10048  // it will believe that glibc provides a ::gets in cases where it does not,
10049  // and will try to pull it into namespace std with a using-declaration.
10050  // Just ignore the using-declaration in that case.
10051  auto *II = NameInfo.getName().getAsIdentifierInfo();
10052  if (getLangOpts().CPlusPlus14 && II && II->isStr("gets") &&
10053  CurContext->isStdNamespace() &&
10054  isa<TranslationUnitDecl>(LookupContext) &&
10055  getSourceManager().isInSystemHeader(UsingLoc))
10056  return nullptr;
10057  if (TypoCorrection Corrected = CorrectTypo(
10058  R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
10059  llvm::make_unique<UsingValidatorCCC>(
10060  HasTypenameKeyword, IsInstantiation, SS.getScopeRep(),
10061  dyn_cast<CXXRecordDecl>(CurContext)),
10062  CTK_ErrorRecovery)) {
10063  // We reject candidates where DroppedSpecifier == true, hence the
10064  // literal '0' below.
10065  diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
10066  << NameInfo.getName() << LookupContext << 0
10067  << SS.getRange());
10068 
10069  // If we picked a correction with no attached Decl we can't do anything
10070  // useful with it, bail out.
10071  NamedDecl *ND = Corrected.getCorrectionDecl();
10072  if (!ND)
10073  return BuildInvalid();
10074 
10075  // If we corrected to an inheriting constructor, handle it as one.
10076  auto *RD = dyn_cast<CXXRecordDecl>(ND);
10077  if (RD && RD->isInjectedClassName()) {
10078  // The parent of the injected class name is the class itself.
10079  RD = cast<CXXRecordDecl>(RD->getParent());
10080 
10081  // Fix up the information we'll use to build the using declaration.
10082  if (Corrected.WillReplaceSpecifier()) {
10084  Builder.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
10085  QualifierLoc.getSourceRange());
10086  QualifierLoc = Builder.getWithLocInContext(Context);
10087  }
10088 
10089  // In this case, the name we introduce is the name of a derived class
10090  // constructor.
10091  auto *CurClass = cast<CXXRecordDecl>(CurContext);
10092  UsingName.setName(Context.DeclarationNames.getCXXConstructorName(
10093  Context.getCanonicalType(Context.getRecordType(CurClass))));
10094  UsingName.setNamedTypeInfo(nullptr);
10095  for (auto *Ctor : LookupConstructors(RD))
10096  R.addDecl(Ctor);
10097  R.resolveKind();
10098  } else {
10099  // FIXME: Pick up all the declarations if we found an overloaded
10100  // function.
10101  UsingName.setName(ND->getDeclName());
10102  R.addDecl(ND);
10103  }
10104  } else {
10105  Diag(IdentLoc, diag::err_no_member)
10106  << NameInfo.getName() << LookupContext << SS.getRange();
10107  return BuildInvalid();
10108  }
10109  }
10110 
10111  if (R.isAmbiguous())
10112  return BuildInvalid();
10113 
10114  if (HasTypenameKeyword) {
10115  // If we asked for a typename and got a non-type decl, error out.
10116  if (!R.getAsSingle<TypeDecl>()) {
10117  Diag(IdentLoc, diag::err_using_typename_non_type);
10118  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
10119  Diag((*I)->getUnderlyingDecl()->getLocation(),
10120  diag::note_using_decl_target);
10121  return BuildInvalid();
10122  }
10123  } else {
10124  // If we asked for a non-typename and we got a type, error out,
10125  // but only if this is an instantiation of an unresolved using
10126  // decl. Otherwise just silently find the type name.
10127  if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
10128  Diag(IdentLoc, diag::err_using_dependent_value_is_type);
10129  Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
10130  return BuildInvalid();
10131  }
10132  }
10133 
10134  // C++14 [namespace.udecl]p6:
10135  // A using-declaration shall not name a namespace.
10136  if (R.getAsSingle<NamespaceDecl>()) {
10137  Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
10138  << SS.getRange();
10139  return BuildInvalid();
10140  }
10141 
10142  // C++14 [namespace.udecl]p7:
10143  // A using-declaration shall not name a scoped enumerator.
10144  if (auto *ED = R.getAsSingle<EnumConstantDecl>()) {
10145  if (cast<EnumDecl>(ED->getDeclContext())->isScoped()) {
10146  Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_scoped_enum)
10147  << SS.getRange();
10148  return BuildInvalid();
10149  }
10150  }
10151 
10152  UsingDecl *UD = BuildValid();
10153 
10154  // Some additional rules apply to inheriting constructors.
10155  if (UsingName.getName().getNameKind() ==
10157  // Suppress access diagnostics; the access check is instead performed at the
10158  // point of use for an inheriting constructor.
10159  R.suppressDiagnostics();
10160  if (CheckInheritingConstructorUsingDecl(UD))
10161  return UD;
10162  }
10163 
10164  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
10165  UsingShadowDecl *PrevDecl = nullptr;
10166  if (!CheckUsingShadowDecl(UD, *I, Previous, PrevDecl))
10167  BuildUsingShadowDecl(S, UD, *I, PrevDecl);
10168  }
10169 
10170  return UD;
10171 }
10172 
10174  ArrayRef<NamedDecl *> Expansions) {
10175  assert(isa<UnresolvedUsingValueDecl>(InstantiatedFrom) ||
10176  isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) ||
10177  isa<UsingPackDecl>(InstantiatedFrom));
10178 
10179  auto *UPD =
10180  UsingPackDecl::Create(Context, CurContext, InstantiatedFrom, Expansions);
10181  UPD->setAccess(InstantiatedFrom->getAccess());
10182  CurContext->addDecl(UPD);
10183  return UPD;
10184 }
10185 
10186 /// Additional checks for a using declaration referring to a constructor name.
10188  assert(!UD->hasTypename() && "expecting a constructor name");
10189 
10190  const Type *SourceType = UD->getQualifier()->getAsType();
10191  assert(SourceType &&
10192  "Using decl naming constructor doesn't have type in scope spec.");
10193  CXXRecordDecl *TargetClass = cast<CXXRecordDecl>(CurContext);
10194 
10195  // Check whether the named type is a direct base class.
10196  bool AnyDependentBases = false;
10197  auto *Base = findDirectBaseWithType(TargetClass, QualType(SourceType, 0),
10198  AnyDependentBases);
10199  if (!Base && !AnyDependentBases) {
10200  Diag(UD->getUsingLoc(),
10201  diag::err_using_decl_constructor_not_in_direct_base)
10202  << UD->getNameInfo().getSourceRange()
10203  << QualType(SourceType, 0) << TargetClass;
10204  UD->setInvalidDecl();
10205  return true;
10206  }
10207 
10208  if (Base)
10209  Base->setInheritConstructors();
10210 
10211  return false;
10212 }
10213 
10214 /// Checks that the given using declaration is not an invalid
10215 /// redeclaration. Note that this is checking only for the using decl
10216 /// itself, not for any ill-formedness among the UsingShadowDecls.
10218  bool HasTypenameKeyword,
10219  const CXXScopeSpec &SS,
10220  SourceLocation NameLoc,
10221  const LookupResult &Prev) {
10222  NestedNameSpecifier *Qual = SS.getScopeRep();
10223 
10224  // C++03 [namespace.udecl]p8:
10225  // C++0x [namespace.udecl]p10:
10226  // A using-declaration is a declaration and can therefore be used
10227  // repeatedly where (and only where) multiple declarations are
10228  // allowed.
10229  //
10230  // That's in non-member contexts.
10231  if (!CurContext->getRedeclContext()->isRecord()) {
10232  // A dependent qualifier outside a class can only ever resolve to an
10233  // enumeration type. Therefore it conflicts with any other non-type
10234  // declaration in the same scope.
10235  // FIXME: How should we check for dependent type-type conflicts at block
10236  // scope?
10237  if (Qual->isDependent() && !HasTypenameKeyword) {
10238  for (auto *D : Prev) {
10239  if (!isa<TypeDecl>(D) && !isa<UsingDecl>(D) && !isa<UsingPackDecl>(D)) {
10240  bool OldCouldBeEnumerator =
10241  isa<UnresolvedUsingValueDecl>(D) || isa<EnumConstantDecl>(D);
10242  Diag(NameLoc,
10243  OldCouldBeEnumerator ? diag::err_redefinition
10244  : diag::err_redefinition_different_kind)
10245  << Prev.getLookupName();
10246  Diag(D->getLocation(), diag::note_previous_definition);
10247  return true;
10248  }
10249  }
10250  }
10251  return false;
10252  }
10253 
10254  for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
10255  NamedDecl *D = *I;
10256 
10257  bool DTypename;
10258  NestedNameSpecifier *DQual;
10259  if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
10260  DTypename = UD->hasTypename();
10261  DQual = UD->getQualifier();
10262  } else if (UnresolvedUsingValueDecl *UD
10263  = dyn_cast<UnresolvedUsingValueDecl>(D)) {
10264  DTypename = false;
10265  DQual = UD->getQualifier();
10266  } else if (UnresolvedUsingTypenameDecl *UD
10267  = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
10268  DTypename = true;
10269  DQual = UD->getQualifier();
10270  } else continue;
10271 
10272  // using decls differ if one says 'typename' and the other doesn't.
10273  // FIXME: non-dependent using decls?
10274  if (HasTypenameKeyword != DTypename) continue;
10275 
10276  // using decls differ if they name different scopes (but note that
10277  // template instantiation can cause this check to trigger when it
10278  // didn't before instantiation).
10279  if (Context.getCanonicalNestedNameSpecifier(Qual) !=
10280  Context.getCanonicalNestedNameSpecifier(DQual))
10281  continue;
10282 
10283  Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
10284  Diag(D->getLocation(), diag::note_using_decl) << 1;
10285  return true;
10286  }
10287 
10288  return false;
10289 }
10290 
10291 
10292 /// Checks that the given nested-name qualifier used in a using decl
10293 /// in the current context is appropriately related to the current
10294 /// scope. If an error is found, diagnoses it and returns true.
10296  bool HasTypename,
10297  const CXXScopeSpec &SS,
10298  const DeclarationNameInfo &NameInfo,
10299  SourceLocation NameLoc) {
10300  DeclContext *NamedContext = computeDeclContext(SS);
10301 
10302  if (!CurContext->isRecord()) {
10303  // C++03 [namespace.udecl]p3:
10304  // C++0x [namespace.udecl]p8:
10305  // A using-declaration for a class member shall be a member-declaration.
10306 
10307  // If we weren't able to compute a valid scope, it might validly be a
10308  // dependent class scope or a dependent enumeration unscoped scope. If
10309  // we have a 'typename' keyword, the scope must resolve to a class type.
10310  if ((HasTypename && !NamedContext) ||
10311  (NamedContext && NamedContext->getRedeclContext()->isRecord())) {
10312  auto *RD = NamedContext
10313  ? cast<CXXRecordDecl>(NamedContext->getRedeclContext())
10314  : nullptr;
10315  if (RD && RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), RD))
10316  RD = nullptr;
10317 
10318  Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member)
10319  << SS.getRange();
10320 
10321  // If we have a complete, non-dependent source type, try to suggest a
10322  // way to get the same effect.
10323  if (!RD)
10324  return true;
10325 
10326  // Find what this using-declaration was referring to.
10327  LookupResult R(*this, NameInfo, LookupOrdinaryName);
10328  R.setHideTags(false);
10329  R.suppressDiagnostics();
10330  LookupQualifiedName(R, RD);
10331 
10332  if (R.getAsSingle<TypeDecl>()) {
10333  if (getLangOpts().CPlusPlus11) {
10334  // Convert 'using X::Y;' to 'using Y = X::Y;'.
10335  Diag(SS.getBeginLoc(), diag::note_using_decl_class_member_workaround)
10336  << 0 // alias declaration
10338  NameInfo.getName().getAsString() +
10339  " = ");
10340  } else {
10341  // Convert 'using X::Y;' to 'typedef X::Y Y;'.
10342  SourceLocation InsertLoc = getLocForEndOfToken(NameInfo.getEndLoc());
10343  Diag(InsertLoc, diag::note_using_decl_class_member_workaround)
10344  << 1 // typedef declaration
10345  << FixItHint::CreateReplacement(UsingLoc, "typedef")
10347  InsertLoc, " " + NameInfo.getName().getAsString());
10348  }
10349  } else if (R.getAsSingle<VarDecl>()) {
10350  // Don't provide a fixit outside C++11 mode; we don't want to suggest
10351  // repeating the type of the static data member here.
10352  FixItHint FixIt;
10353  if (getLangOpts().CPlusPlus11) {
10354  // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
10356  UsingLoc, "auto &" + NameInfo.getName().getAsString() + " = ");
10357  }
10358 
10359  Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
10360  << 2 // reference declaration
10361  << FixIt;
10362  } else if (R.getAsSingle<EnumConstantDecl>()) {
10363  // Don't provide a fixit outside C++11 mode; we don't want to suggest
10364  // repeating the type of the enumeration here, and we can't do so if
10365  // the type is anonymous.
10366  FixItHint FixIt;
10367  if (getLangOpts().CPlusPlus11) {
10368  // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
10370  UsingLoc,
10371  "constexpr auto " + NameInfo.getName().getAsString() + " = ");
10372  }
10373 
10374  Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
10375  << (getLangOpts().CPlusPlus11 ? 4 : 3) // const[expr] variable
10376  << FixIt;
10377  }
10378  return true;
10379  }
10380 
10381  // Otherwise, this might be valid.
10382  return false;
10383  }
10384 
10385  // The current scope is a record.
10386 
10387  // If the named context is dependent, we can't decide much.
10388  if (!NamedContext) {
10389  // FIXME: in C++0x, we can diagnose if we can prove that the
10390  // nested-name-specifier does not refer to a base class, which is
10391  // still possible in some cases.
10392 
10393  // Otherwise we have to conservatively report that things might be
10394  // okay.
10395  return false;
10396  }
10397 
10398  if (!NamedContext->isRecord()) {
10399  // Ideally this would point at the last name in the specifier,
10400  // but we don't have that level of source info.
10401  Diag(SS.getRange().getBegin(),
10402  diag::err_using_decl_nested_name_specifier_is_not_class)
10403  << SS.getScopeRep() << SS.getRange();
10404  return true;
10405  }
10406 
10407  if (!NamedContext->isDependentContext() &&
10408  RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), NamedContext))
10409  return true;
10410 
10411  if (getLangOpts().CPlusPlus11) {
10412  // C++11 [namespace.udecl]p3:
10413  // In a using-declaration used as a member-declaration, the
10414  // nested-name-specifier shall name a base class of the class
10415  // being defined.
10416 
10417  if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
10418  cast<CXXRecordDecl>(NamedContext))) {
10419  if (CurContext == NamedContext) {
10420  Diag(NameLoc,
10421  diag::err_using_decl_nested_name_specifier_is_current_class)
10422  << SS.getRange();
10423  return true;
10424  }
10425 
10426  if (!cast<CXXRecordDecl>(NamedContext)->isInvalidDecl()) {
10427  Diag(SS.getRange().getBegin(),
10428  diag::err_using_decl_nested_name_specifier_is_not_base_class)
10429  << SS.getScopeRep()
10430  << cast<CXXRecordDecl>(CurContext)
10431  << SS.getRange();
10432  }
10433  return true;
10434  }
10435 
10436  return false;
10437  }
10438 
10439  // C++03 [namespace.udecl]p4:
10440  // A using-declaration used as a member-declaration shall refer
10441  // to a member of a base class of the class being defined [etc.].
10442 
10443  // Salient point: SS doesn't have to name a base class as long as
10444  // lookup only finds members from base classes. Therefore we can
10445  // diagnose here only if we can prove that that can't happen,
10446  // i.e. if the class hierarchies provably don't intersect.
10447 
10448  // TODO: it would be nice if "definitely valid" results were cached
10449  // in the UsingDecl and UsingShadowDecl so that these checks didn't
10450  // need to be repeated.
10451 
10452  llvm::SmallPtrSet<const CXXRecordDecl *, 4> Bases;
10453  auto Collect = [&Bases](const CXXRecordDecl *Base) {
10454  Bases.insert(Base);
10455  return true;
10456  };
10457 
10458  // Collect all bases. Return false if we find a dependent base.
10459  if (!cast<CXXRecordDecl>(CurContext)->forallBases(Collect))
10460  return false;
10461 
10462  // Returns true if the base is dependent or is one of the accumulated base
10463  // classes.
10464  auto IsNotBase = [&Bases](const CXXRecordDecl *Base) {
10465  return !Bases.count(Base);
10466  };
10467 
10468  // Return false if the class has a dependent base or if it or one
10469  // of its bases is present in the base set of the current context.
10470  if (Bases.count(cast<CXXRecordDecl>(NamedContext)) ||
10471  !cast<CXXRecordDecl>(NamedContext)->forallBases(IsNotBase))
10472  return false;
10473 
10474  Diag(SS.getRange().getBegin(),
10475  diag::err_using_decl_nested_name_specifier_is_not_base_class)
10476  << SS.getScopeRep()
10477  << cast<CXXRecordDecl>(CurContext)
10478  << SS.getRange();
10479 
10480  return true;
10481 }
10482 
10484  MultiTemplateParamsArg TemplateParamLists,
10485  SourceLocation UsingLoc, UnqualifiedId &Name,
10486  const ParsedAttributesView &AttrList,
10487  TypeResult Type, Decl *DeclFromDeclSpec) {
10488  // Skip up to the relevant declaration scope.
10489  while (S->isTemplateParamScope())
10490  S = S->getParent();
10491  assert((S->getFlags() & Scope::DeclScope) &&
10492  "got alias-declaration outside of declaration scope");
10493 
10494  if (Type.isInvalid())
10495  return nullptr;
10496 
10497  bool Invalid = false;
10498  DeclarationNameInfo NameInfo = GetNameFromUnqualifiedId(Name);
10499  TypeSourceInfo *TInfo = nullptr;
10500  GetTypeFromParser(Type.get(), &TInfo);
10501 
10502  if (DiagnoseClassNameShadow(CurContext, NameInfo))
10503  return nullptr;
10504 
10505  if (DiagnoseUnexpandedParameterPack(Name.StartLocation, TInfo,
10506  UPPC_DeclarationType)) {
10507  Invalid = true;
10508  TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
10509  TInfo->getTypeLoc().getBeginLoc());
10510  }
10511 
10512  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
10513  TemplateParamLists.size()
10514  ? forRedeclarationInCurContext()
10515  : ForVisibleRedeclaration);
10516  LookupName(Previous, S);
10517 
10518  // Warn about shadowing the name of a template parameter.
10519  if (Previous.isSingleResult() &&
10520  Previous.getFoundDecl()->isTemplateParameter()) {
10521  DiagnoseTemplateParameterShadow(Name.StartLocation,Previous.getFoundDecl());
10522  Previous.clear();
10523  }
10524 
10525  assert(Name.Kind == UnqualifiedIdKind::IK_Identifier &&
10526  "name in alias declaration must be an identifier");
10527  TypeAliasDecl *NewTD = TypeAliasDecl::Create(Context, CurContext, UsingLoc,
10528  Name.StartLocation,
10529  Name.Identifier, TInfo);
10530 
10531  NewTD->setAccess(AS);
10532 
10533  if (Invalid)
10534  NewTD->setInvalidDecl();
10535 
10536  ProcessDeclAttributeList(S, NewTD, AttrList);
10537  AddPragmaAttributes(S, NewTD);
10538 
10539  CheckTypedefForVariablyModifiedType(S, NewTD);
10540  Invalid |= NewTD->isInvalidDecl();
10541 
10542  bool Redeclaration = false;
10543 
10544  NamedDecl *NewND;
10545  if (TemplateParamLists.size()) {
10546  TypeAliasTemplateDecl *OldDecl = nullptr;
10547  TemplateParameterList *OldTemplateParams = nullptr;
10548 
10549  if (TemplateParamLists.size() != 1) {
10550  Diag(UsingLoc, diag::err_alias_template_extra_headers)
10551  << SourceRange(TemplateParamLists[1]->getTemplateLoc(),
10552  TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
10553  }
10554  TemplateParameterList *TemplateParams = TemplateParamLists[0];
10555 
10556  // Check that we can declare a template here.
10557  if (CheckTemplateDeclScope(S, TemplateParams))
10558  return nullptr;
10559 
10560  // Only consider previous declarations in the same scope.
10561  FilterLookupForScope(Previous, CurContext, S, /*ConsiderLinkage*/false,
10562  /*ExplicitInstantiationOrSpecialization*/false);
10563  if (!Previous.empty()) {
10564  Redeclaration = true;
10565 
10566  OldDecl = Previous.getAsSingle<TypeAliasTemplateDecl>();
10567  if (!OldDecl && !Invalid) {
10568  Diag(UsingLoc, diag::err_redefinition_different_kind)
10569  << Name.Identifier;
10570 
10571  NamedDecl *OldD = Previous.getRepresentativeDecl();
10572  if (OldD->getLocation().isValid())
10573  Diag(OldD->getLocation(), diag::note_previous_definition);
10574 
10575  Invalid = true;
10576  }
10577 
10578  if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) {
10579  if (TemplateParameterListsAreEqual(TemplateParams,
10580  OldDecl->getTemplateParameters(),
10581  /*Complain=*/true,
10582  TPL_TemplateMatch))
10583  OldTemplateParams =
10585  else
10586  Invalid = true;
10587 
10588  TypeAliasDecl *OldTD = OldDecl->getTemplatedDecl();
10589  if (!Invalid &&
10590  !Context.hasSameType(OldTD->getUnderlyingType(),
10591  NewTD->getUnderlyingType())) {
10592  // FIXME: The C++0x standard does not clearly say this is ill-formed,
10593  // but we can't reasonably accept it.
10594  Diag(NewTD->getLocation(), diag::err_redefinition_different_typedef)
10595  << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType();
10596  if (OldTD->getLocation().isValid())
10597  Diag(OldTD->getLocation(), diag::note_previous_definition);
10598  Invalid = true;
10599  }
10600  }
10601  }
10602 
10603  // Merge any previous default template arguments into our parameters,
10604  // and check the parameter list.
10605  if (CheckTemplateParameterList(TemplateParams, OldTemplateParams,
10606  TPC_TypeAliasTemplate))
10607  return nullptr;
10608 
10609  TypeAliasTemplateDecl *NewDecl =
10610  TypeAliasTemplateDecl::Create(Context, CurContext, UsingLoc,
10611  Name.Identifier, TemplateParams,
10612  NewTD);
10613  NewTD->setDescribedAliasTemplate(NewDecl);
10614 
10615  NewDecl->setAccess(AS);
10616 
10617  if (Invalid)
10618  NewDecl->setInvalidDecl();
10619  else if (OldDecl) {
10620  NewDecl->setPreviousDecl(OldDecl);
10621  CheckRedeclarationModuleOwnership(NewDecl, OldDecl);
10622  }
10623 
10624  NewND = NewDecl;
10625  } else {
10626  if (auto *TD = dyn_cast_or_null<TagDecl>(DeclFromDeclSpec)) {
10627  setTagNameForLinkagePurposes(TD, NewTD);
10628  handleTagNumbering(TD, S);
10629  }
10630  ActOnTypedefNameDecl(S, CurContext, NewTD, Previous, Redeclaration);
10631  NewND = NewTD;
10632  }
10633 
10634  PushOnScopeChains(NewND, S);
10635  ActOnDocumentableDecl(NewND);
10636  return NewND;
10637 }
10638 
10640  SourceLocation AliasLoc,
10641  IdentifierInfo *Alias, CXXScopeSpec &SS,
10642  SourceLocation IdentLoc,
10643  IdentifierInfo *Ident) {
10644 
10645  // Lookup the namespace name.
10646  LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
10647  LookupParsedName(R, S, &SS);
10648 
10649  if (R.isAmbiguous())
10650  return nullptr;
10651 
10652  if (R.empty()) {
10653  if (!TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, Ident)) {
10654  Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
10655  return nullptr;
10656  }
10657  }
10658  assert(!R.isAmbiguous() && !R.empty());
10659  NamedDecl *ND = R.getRepresentativeDecl();
10660 
10661  // Check if we have a previous declaration with the same name.
10662  LookupResult PrevR(*this, Alias, AliasLoc, LookupOrdinaryName,
10663  ForVisibleRedeclaration);
10664  LookupName(PrevR, S);
10665 
10666  // Check we're not shadowing a template parameter.
10667  if (PrevR.isSingleResult() && PrevR.getFoundDecl()->isTemplateParameter()) {
10668  DiagnoseTemplateParameterShadow(AliasLoc, PrevR.getFoundDecl());
10669  PrevR.clear();
10670  }
10671 
10672  // Filter out any other lookup result from an enclosing scope.
10673  FilterLookupForScope(PrevR, CurContext, S, /*ConsiderLinkage*/false,
10674  /*AllowInlineNamespace*/false);
10675 
10676  // Find the previous declaration and check that we can redeclare it.
10677  NamespaceAliasDecl *Prev = nullptr;
10678  if (PrevR.isSingleResult()) {
10679  NamedDecl *PrevDecl = PrevR.getRepresentativeDecl();
10680  if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
10681  // We already have an alias with the same name that points to the same
10682  // namespace; check that it matches.
10683  if (AD->getNamespace()->Equals(getNamespaceDecl(ND))) {
10684  Prev = AD;
10685  } else if (isVisible(PrevDecl)) {
10686  Diag(AliasLoc, diag::err_redefinition_different_namespace_alias)
10687  << Alias;
10688  Diag(AD->getLocation(), diag::note_previous_namespace_alias)
10689  << AD->getNamespace();
10690  return nullptr;
10691  }
10692  } else if (isVisible(PrevDecl)) {
10693  unsigned DiagID = isa<NamespaceDecl>(PrevDecl->getUnderlyingDecl())
10694  ? diag::err_redefinition
10695  : diag::err_redefinition_different_kind;
10696  Diag(AliasLoc, DiagID) << Alias;
10697  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
10698  return nullptr;
10699  }
10700  }
10701 
10702  // The use of a nested name specifier may trigger deprecation warnings.
10703  DiagnoseUseOfDecl(ND, IdentLoc);
10704 
10705  NamespaceAliasDecl *AliasDecl =
10706  NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
10707  Alias, SS.getWithLocInContext(Context),
10708  IdentLoc, ND);
10709  if (Prev)
10710  AliasDecl->setPreviousDecl(Prev);
10711 
10712  PushOnScopeChains(AliasDecl, S);
10713  return AliasDecl;
10714 }
10715 
10716 namespace {
10717 struct SpecialMemberExceptionSpecInfo
10718  : SpecialMemberVisitor<SpecialMemberExceptionSpecInfo> {
10719  SourceLocation Loc;
10721 
10722  SpecialMemberExceptionSpecInfo(Sema &S, CXXMethodDecl *MD,
10725  SourceLocation Loc)
10726  : SpecialMemberVisitor(S, MD, CSM, ICI), Loc(Loc), ExceptSpec(S) {}
10727 
10728  bool visitBase(CXXBaseSpecifier *Base);
10729  bool visitField(FieldDecl *FD);
10730 
10731  void visitClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
10732  unsigned Quals);
10733 
10734  void visitSubobjectCall(Subobject Subobj,
10736 };
10737 }
10738 
10739 bool SpecialMemberExceptionSpecInfo::visitBase(CXXBaseSpecifier *Base) {
10740  auto *RT = Base->getType()->getAs<RecordType>();
10741  if (!RT)
10742  return false;
10743 
10744  auto *BaseClass = cast<CXXRecordDecl>(RT->getDecl());
10745  Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
10746  if (auto *BaseCtor = SMOR.getMethod()) {
10747  visitSubobjectCall(Base, BaseCtor);
10748  return false;
10749  }
10750 
10751  visitClassSubobject(BaseClass, Base, 0);
10752  return false;
10753 }
10754 
10755 bool SpecialMemberExceptionSpecInfo::visitField(FieldDecl *FD) {
10756  if (CSM == Sema::CXXDefaultConstructor && FD->hasInClassInitializer()) {
10757  Expr *E = FD->getInClassInitializer();
10758  if (!E)
10759  // FIXME: It's a little wasteful to build and throw away a
10760  // CXXDefaultInitExpr here.
10761  // FIXME: We should have a single context note pointing at Loc, and
10762  // this location should be MD->getLocation() instead, since that's
10763  // the location where we actually use the default init expression.
10764  E = S.BuildCXXDefaultInitExpr(Loc, FD).get();
10765  if (E)
10766  ExceptSpec.CalledExpr(E);
10767  } else if (auto *RT = S.Context.getBaseElementType(FD->getType())
10768  ->getAs<RecordType>()) {
10769  visitClassSubobject(cast<CXXRecordDecl>(RT->getDecl()), FD,
10770  FD->getType().getCVRQualifiers());
10771  }
10772  return false;
10773 }
10774 
10775 void SpecialMemberExceptionSpecInfo::visitClassSubobject(CXXRecordDecl *Class,
10776  Subobject Subobj,
10777  unsigned Quals) {
10778  FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
10779  bool IsMutable = Field && Field->isMutable();
10780  visitSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable));
10781 }
10782 
10783 void SpecialMemberExceptionSpecInfo::visitSubobjectCall(
10784  Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR) {
10785  // Note, if lookup fails, it doesn't matter what exception specification we
10786  // choose because the special member will be deleted.
10787  if (CXXMethodDecl *MD = SMOR.getMethod())
10788  ExceptSpec.CalledDecl(getSubobjectLoc(Subobj), MD);
10789 }
10790 
10791 namespace {
10792 /// RAII object to register a special member as being currently declared.
10793 struct ComputingExceptionSpec {
10794  Sema &S;
10795 
10796  ComputingExceptionSpec(Sema &S, CXXMethodDecl *MD, SourceLocation Loc)
10797  : S(S) {
10800  Ctx.PointOfInstantiation = Loc;
10801  Ctx.Entity = MD;
10802  S.pushCodeSynthesisContext(Ctx);
10803  }
10804  ~ComputingExceptionSpec() {
10806  }
10807 };
10808 }
10809 
10814  ComputingExceptionSpec CES(S, MD, Loc);
10815 
10816  CXXRecordDecl *ClassDecl = MD->getParent();
10817 
10818  // C++ [except.spec]p14:
10819  // An implicitly declared special member function (Clause 12) shall have an
10820  // exception-specification. [...]
10821  SpecialMemberExceptionSpecInfo Info(S, MD, CSM, ICI, MD->getLocation());
10822  if (ClassDecl->isInvalidDecl())
10823  return Info.ExceptSpec;
10824 
10825  // FIXME: If this diagnostic fires, we're probably missing a check for
10826  // attempting to resolve an exception specification before it's known
10827  // at a higher level.
10829  S.Context.getRecordType(ClassDecl),
10830  diag::err_exception_spec_incomplete_type))
10831  return Info.ExceptSpec;
10832 
10833  // C++1z [except.spec]p7:
10834  // [Look for exceptions thrown by] a constructor selected [...] to
10835  // initialize a potentially constructed subobject,
10836  // C++1z [except.spec]p8:
10837  // The exception specification for an implicitly-declared destructor, or a
10838  // destructor without a noexcept-specifier, is potentially-throwing if and
10839  // only if any of the destructors for any of its potentially constructed
10840  // subojects is potentially throwing.
10841  // FIXME: We respect the first rule but ignore the "potentially constructed"
10842  // in the second rule to resolve a core issue (no number yet) that would have
10843  // us reject:
10844  // struct A { virtual void f() = 0; virtual ~A() noexcept(false) = 0; };
10845  // struct B : A {};
10846  // struct C : B { void f(); };
10847  // ... due to giving B::~B() a non-throwing exception specification.
10848  Info.visit(Info.IsConstructor ? Info.VisitPotentiallyConstructedBases
10849  : Info.VisitAllBases);
10850 
10851  return Info.ExceptSpec;
10852 }
10853 
10854 namespace {
10855 /// RAII object to register a special member as being currently declared.
10856 struct DeclaringSpecialMember {
10857  Sema &S;
10859  Sema::ContextRAII SavedContext;
10860  bool WasAlreadyBeingDeclared;
10861 
10862  DeclaringSpecialMember(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM)
10863  : S(S), D(RD, CSM), SavedContext(S, RD) {
10864  WasAlreadyBeingDeclared = !S.SpecialMembersBeingDeclared.insert(D).second;
10865  if (WasAlreadyBeingDeclared)
10866  // This almost never happens, but if it does, ensure that our cache
10867  // doesn't contain a stale result.
10868  S.SpecialMemberCache.clear();
10869  else {
10870  // Register a note to be produced if we encounter an error while
10871  // declaring the special member.
10874  // FIXME: We don't have a location to use here. Using the class's
10875  // location maintains the fiction that we declare all special members
10876  // with the class, but (1) it's not clear that lying about that helps our
10877  // users understand what's going on, and (2) there may be outer contexts
10878  // on the stack (some of which are relevant) and printing them exposes
10879  // our lies.
10880  Ctx.PointOfInstantiation = RD->getLocation();
10881  Ctx.Entity = RD;
10882  Ctx.SpecialMember = CSM;
10883  S.pushCodeSynthesisContext(Ctx);
10884  }
10885  }
10886  ~DeclaringSpecialMember() {
10887  if (!WasAlreadyBeingDeclared) {
10888  S.SpecialMembersBeingDeclared.erase(D);
10890  }
10891  }
10892 
10893  /// Are we already trying to declare this special member?
10894  bool isAlreadyBeingDeclared() const {
10895  return WasAlreadyBeingDeclared;
10896  }
10897 };
10898 }
10899 
10901  // Look up any existing declarations, but don't trigger declaration of all
10902  // implicit special members with this name.
10903  DeclarationName Name = FD->getDeclName();
10904  LookupResult R(*this, Name, SourceLocation(), LookupOrdinaryName,
10905  ForExternalRedeclaration);
10906  for (auto *D : FD->getParent()->lookup(Name))
10907  if (auto *Acceptable = R.getAcceptableDecl(D))
10908  R.addDecl(Acceptable);
10909  R.resolveKind();
10910  R.suppressDiagnostics();
10911 
10912  CheckFunctionDeclaration(S, FD, R, /*IsMemberSpecialization*/false);
10913 }
10914 
10915 void Sema::setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem,
10916  QualType ResultTy,
10917  ArrayRef<QualType> Args) {
10918  // Build an exception specification pointing back at this constructor.
10919  FunctionProtoType::ExtProtoInfo EPI = getImplicitMethodEPI(*this, SpecialMem);
10920 
10921  if (getLangOpts().OpenCLCPlusPlus) {
10922  // OpenCL: Implicitly defaulted special member are of the generic address
10923  // space.
10925  }
10926 
10927  auto QT = Context.getFunctionType(ResultTy, Args, EPI);
10928  SpecialMem->setType(QT);
10929 }
10930 
10932  CXXRecordDecl *ClassDecl) {
10933  // C++ [class.ctor]p5:
10934  // A default constructor for a class X is a constructor of class X
10935  // that can be called without an argument. If there is no
10936  // user-declared constructor for class X, a default constructor is
10937  // implicitly declared. An implicitly-declared default constructor
10938  // is an inline public member of its class.
10939  assert(ClassDecl->needsImplicitDefaultConstructor() &&
10940  "Should not build implicit default constructor!");
10941 
10942  DeclaringSpecialMember DSM(*this, ClassDecl, CXXDefaultConstructor);
10943  if (DSM.isAlreadyBeingDeclared())
10944  return nullptr;
10945 
10946  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
10947  CXXDefaultConstructor,
10948  false);
10949 
10950  // Create the actual constructor declaration.
10951  CanQualType ClassType
10952  = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
10953  SourceLocation ClassLoc = ClassDecl->getLocation();
10954  DeclarationName Name
10955  = Context.DeclarationNames.getCXXConstructorName(ClassType);
10956  DeclarationNameInfo NameInfo(Name, ClassLoc);
10958  Context, ClassDecl, ClassLoc, NameInfo, /*Type*/QualType(),
10959  /*TInfo=*/nullptr, /*isExplicit=*/false, /*isInline=*/true,
10960  /*isImplicitlyDeclared=*/true, Constexpr);
10961  DefaultCon->setAccess(AS_public);
10962  DefaultCon->setDefaulted();
10963 
10964  if (getLangOpts().CUDA) {
10965  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDefaultConstructor,
10966  DefaultCon,
10967  /* ConstRHS */ false,
10968  /* Diagnose */ false);
10969  }
10970 
10971  setupImplicitSpecialMemberType(DefaultCon, Context.VoidTy, None);
10972 
10973  // We don't need to use SpecialMemberIsTrivial here; triviality for default
10974  // constructors is easy to compute.
10975  DefaultCon->setTrivial(ClassDecl->hasTrivialDefaultConstructor());
10976 
10977  // Note that we have declared this constructor.
10979 
10980  Scope *S = getScopeForContext(ClassDecl);
10981  CheckImplicitSpecialMemberDeclaration(S, DefaultCon);
10982 
10983  if (ShouldDeleteSpecialMember(DefaultCon, CXXDefaultConstructor))
10984  SetDeclDeleted(DefaultCon, ClassLoc);
10985 
10986  if (S)
10987  PushOnScopeChains(DefaultCon, S, false);
10988  ClassDecl->addDecl(DefaultCon);
10989 
10990  return DefaultCon;
10991 }
10992 
10994  CXXConstructorDecl *Constructor) {
10995  assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
10996  !Constructor->doesThisDeclarationHaveABody() &&
10997  !Constructor->isDeleted()) &&
10998  "DefineImplicitDefaultConstructor - call it for implicit default ctor");
10999  if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
11000  return;
11001 
11002  CXXRecordDecl *ClassDecl = Constructor->getParent();
11003  assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
11004 
11005  SynthesizedFunctionScope Scope(*this, Constructor);
11006 
11007  // The exception specification is needed because we are defining the
11008  // function.
11009  ResolveExceptionSpec(CurrentLocation,
11010  Constructor->getType()->castAs<FunctionProtoType>());
11011  MarkVTableUsed(CurrentLocation, ClassDecl);
11012 
11013  // Add a context note for diagnostics produced after this point.
11014  Scope.addContextNote(CurrentLocation);
11015 
11016  if (SetCtorInitializers(Constructor, /*AnyErrors=*/false)) {
11017  Constructor->setInvalidDecl();
11018  return;
11019  }
11020 
11021  SourceLocation Loc = Constructor->getEndLoc().isValid()
11022  ? Constructor->getEndLoc()
11023  : Constructor->getLocation();
11024  Constructor->setBody(new (Context) CompoundStmt(Loc));
11025  Constructor->markUsed(Context);
11026 
11027  if (ASTMutationListener *L = getASTMutationListener()) {
11028  L->CompletedImplicitDefinition(Constructor);
11029  }
11030 
11031  DiagnoseUninitializedFields(*this, Constructor);
11032 }
11033 
11035  // Perform any delayed checks on exception specifications.
11036  CheckDelayedMemberExceptionSpecs();
11037 }
11038 
11039 /// Find or create the fake constructor we synthesize to model constructing an
11040 /// object of a derived class via a constructor of a base class.
11043  CXXConstructorDecl *BaseCtor,
11044  ConstructorUsingShadowDecl *Shadow) {
11045  CXXRecordDecl *Derived = Shadow->getParent();
11046  SourceLocation UsingLoc = Shadow->getLocation();
11047 
11048  // FIXME: Add a new kind of DeclarationName for an inherited constructor.
11049  // For now we use the name of the base class constructor as a member of the
11050  // derived class to indicate a (fake) inherited constructor name.
11051  DeclarationName Name = BaseCtor->getDeclName();
11052 
11053  // Check to see if we already have a fake constructor for this inherited
11054  // constructor call.
11055  for (NamedDecl *Ctor : Derived->lookup(Name))
11056  if (declaresSameEntity(cast<CXXConstructorDecl>(Ctor)
11057  ->getInheritedConstructor()
11058  .getConstructor(),
11059  BaseCtor))
11060  return cast<CXXConstructorDecl>(Ctor);
11061 
11062  DeclarationNameInfo NameInfo(Name, UsingLoc);
11063  TypeSourceInfo *TInfo =
11064  Context.getTrivialTypeSourceInfo(BaseCtor->getType(), UsingLoc);
11065  FunctionProtoTypeLoc ProtoLoc =
11067 
11068  // Check the inherited constructor is valid and find the list of base classes
11069  // from which it was inherited.
11070  InheritedConstructorInfo ICI(*this, Loc, Shadow);
11071 
11072  bool Constexpr =
11073  BaseCtor->isConstexpr() &&
11074  defaultedSpecialMemberIsConstexpr(*this, Derived, CXXDefaultConstructor,
11075  false, BaseCtor, &ICI);
11076 
11078  Context, Derived, UsingLoc, NameInfo, TInfo->getType(), TInfo,
11079  BaseCtor->isExplicit(), /*Inline=*/true,
11080  /*ImplicitlyDeclared=*/true, Constexpr,
11081  InheritedConstructor(Shadow, BaseCtor));
11082  if (Shadow->isInvalidDecl())
11083  DerivedCtor->setInvalidDecl();
11084 
11085  // Build an unevaluated exception specification for this fake constructor.
11086  const FunctionProtoType *FPT = TInfo->getType()->castAs<FunctionProtoType>();
11089  EPI.ExceptionSpec.SourceDecl = DerivedCtor;
11090  DerivedCtor->setType(Context.getFunctionType(FPT->getReturnType(),
11091  FPT->getParamTypes(), EPI));
11092 
11093  // Build the parameter declarations.
11094  SmallVector<ParmVarDecl *, 16> ParamDecls;
11095  for (unsigned I = 0, N = FPT->getNumParams(); I != N; ++I) {
11096  TypeSourceInfo *TInfo =
11097  Context.getTrivialTypeSourceInfo(FPT->getParamType(I), UsingLoc);
11099  Context, DerivedCtor, UsingLoc, UsingLoc, /*IdentifierInfo=*/nullptr,
11100  FPT->getParamType(I), TInfo, SC_None, /*DefaultArg=*/nullptr);
11101  PD->setScopeInfo(0, I);
11102  PD->setImplicit();
11103  // Ensure attributes are propagated onto parameters (this matters for
11104  // format, pass_object_size, ...).
11105  mergeDeclAttributes(PD, BaseCtor->getParamDecl(I));
11106  ParamDecls.push_back(PD);
11107  ProtoLoc.setParam(I, PD);
11108  }
11109 
11110  // Set up the new constructor.
11111  assert(!BaseCtor->isDeleted() && "should not use deleted constructor");
11112  DerivedCtor->setAccess(BaseCtor->getAccess());
11113  DerivedCtor->setParams(ParamDecls);
11114  Derived->addDecl(DerivedCtor);
11115 
11116  if (ShouldDeleteSpecialMember(DerivedCtor, CXXDefaultConstructor, &ICI))
11117  SetDeclDeleted(DerivedCtor, UsingLoc);
11118 
11119  return DerivedCtor;
11120 }
11121 
11123  InheritedConstructorInfo ICI(*this, Ctor->getLocation(),
11125  ShouldDeleteSpecialMember(Ctor, CXXDefaultConstructor, &ICI,
11126  /*Diagnose*/true);
11127 }
11128 
11130  CXXConstructorDecl *Constructor) {
11131  CXXRecordDecl *ClassDecl = Constructor->getParent();
11132  assert(Constructor->getInheritedConstructor() &&
11133  !Constructor->doesThisDeclarationHaveABody() &&
11134  !Constructor->isDeleted());
11135  if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
11136  return;
11137 
11138  // Initializations are performed "as if by a defaulted default constructor",
11139  // so enter the appropriate scope.
11140  SynthesizedFunctionScope Scope(*this, Constructor);
11141 
11142  // The exception specification is needed because we are defining the
11143  // function.
11144  ResolveExceptionSpec(CurrentLocation,
11145  Constructor->getType()->castAs<FunctionProtoType>());
11146  MarkVTableUsed(CurrentLocation, ClassDecl);
11147 
11148  // Add a context note for diagnostics produced after this point.
11149  Scope.addContextNote(CurrentLocation);
11150 
11151  ConstructorUsingShadowDecl *Shadow =
11152  Constructor->getInheritedConstructor().getShadowDecl();
11153  CXXConstructorDecl *InheritedCtor =
11154  Constructor->getInheritedConstructor().getConstructor();
11155 
11156  // [class.inhctor.init]p1:
11157  // initialization proceeds as if a defaulted default constructor is used to
11158  // initialize the D object and each base class subobject from which the
11159  // constructor was inherited
11160 
11161  InheritedConstructorInfo ICI(*this, CurrentLocation, Shadow);
11162  CXXRecordDecl *RD = Shadow->getParent();
11163  SourceLocation InitLoc = Shadow->getLocation();
11164 
11165  // Build explicit initializers for all base classes from which the
11166  // constructor was inherited.
11168  for (bool VBase : {false, true}) {
11169  for (CXXBaseSpecifier &B : VBase ? RD->vbases() : RD->bases()) {
11170  if (B.isVirtual() != VBase)
11171  continue;
11172 
11173  auto *BaseRD = B.getType()->getAsCXXRecordDecl();
11174  if (!BaseRD)
11175  continue;
11176 
11177  auto BaseCtor = ICI.findConstructorForBase(BaseRD, InheritedCtor);
11178  if (!BaseCtor.first)
11179  continue;
11180 
11181  MarkFunctionReferenced(CurrentLocation, BaseCtor.first);
11182  ExprResult Init = new (Context) CXXInheritedCtorInitExpr(
11183  InitLoc, B.getType(), BaseCtor.first, VBase, BaseCtor.second);
11184 
11185  auto *TInfo = Context.getTrivialTypeSourceInfo(B.getType(), InitLoc);
11186  Inits.push_back(new (Context) CXXCtorInitializer(
11187  Context, TInfo, VBase, InitLoc, Init.get(), InitLoc,
11188  SourceLocation()));
11189  }
11190  }
11191 
11192  // We now proceed as if for a defaulted default constructor, with the relevant
11193  // initializers replaced.
11194 
11195  if (SetCtorInitializers(Constructor, /*AnyErrors*/false, Inits)) {
11196  Constructor->setInvalidDecl();
11197  return;
11198  }
11199 
11200  Constructor->setBody(new (Context) CompoundStmt(InitLoc));
11201  Constructor->markUsed(Context);
11202 
11203  if (ASTMutationListener *L = getASTMutationListener()) {
11204  L->CompletedImplicitDefinition(Constructor);
11205  }
11206 
11207  DiagnoseUninitializedFields(*this, Constructor);
11208 }
11209 
11211  // C++ [class.dtor]p2:
11212  // If a class has no user-declared destructor, a destructor is
11213  // declared implicitly. An implicitly-declared destructor is an
11214  // inline public member of its class.
11215  assert(ClassDecl->needsImplicitDestructor());
11216 
11217  DeclaringSpecialMember DSM(*this, ClassDecl, CXXDestructor);
11218  if (DSM.isAlreadyBeingDeclared())
11219  return nullptr;
11220 
11221  // Create the actual destructor declaration.
11222  CanQualType ClassType
11223  = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
11224  SourceLocation ClassLoc = ClassDecl->getLocation();
11225  DeclarationName Name
11226  = Context.DeclarationNames.getCXXDestructorName(ClassType);
11227  DeclarationNameInfo NameInfo(Name, ClassLoc);
11228  CXXDestructorDecl *Destructor
11229  = CXXDestructorDecl::Create(Context, ClassDecl, ClassLoc, NameInfo,
11230  QualType(), nullptr, /*isInline=*/true,
11231  /*isImplicitlyDeclared=*/true);
11232  Destructor->setAccess(AS_public);
11233  Destructor->setDefaulted();
11234 
11235  if (getLangOpts().CUDA) {
11236  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDestructor,
11237  Destructor,
11238  /* ConstRHS */ false,
11239  /* Diagnose */ false);
11240  }
11241 
11242  setupImplicitSpecialMemberType(Destructor, Context.VoidTy, None);
11243 
11244  // We don't need to use SpecialMemberIsTrivial here; triviality for
11245  // destructors is easy to compute.
11246  Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
11247  Destructor->setTrivialForCall(ClassDecl->hasAttr<TrivialABIAttr>() ||
11248  ClassDecl->hasTrivialDestructorForCall());
11249 
11250  // Note that we have declared this destructor.
11252 
11253  Scope *S = getScopeForContext(ClassDecl);
11254  CheckImplicitSpecialMemberDeclaration(S, Destructor);
11255 
11256  // We can't check whether an implicit destructor is deleted before we complete
11257  // the definition of the class, because its validity depends on the alignment
11258  // of the class. We'll check this from ActOnFields once the class is complete.
11259  if (ClassDecl->isCompleteDefinition() &&
11260  ShouldDeleteSpecialMember(Destructor, CXXDestructor))
11261  SetDeclDeleted(Destructor, ClassLoc);
11262 
11263  // Introduce this destructor into its scope.
11264  if (S)
11265  PushOnScopeChains(Destructor, S, false);
11266  ClassDecl->addDecl(Destructor);
11267 
11268  return Destructor;
11269 }
11270 
11272  CXXDestructorDecl *Destructor) {
11273  assert((Destructor->isDefaulted() &&
11274  !Destructor->doesThisDeclarationHaveABody() &&
11275  !Destructor->isDeleted()) &&
11276  "DefineImplicitDestructor - call it for implicit default dtor");
11277  if (Destructor->willHaveBody() || Destructor->isInvalidDecl())
11278  return;
11279 
11280  CXXRecordDecl *ClassDecl = Destructor->getParent();
11281  assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
11282 
11283  SynthesizedFunctionScope Scope(*this, Destructor);
11284 
11285  // The exception specification is needed because we are defining the
11286  // function.
11287  ResolveExceptionSpec(CurrentLocation,
11288  Destructor->getType()->castAs<FunctionProtoType>());
11289  MarkVTableUsed(CurrentLocation, ClassDecl);
11290 
11291  // Add a context note for diagnostics produced after this point.
11292  Scope.addContextNote(CurrentLocation);
11293 
11294  MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
11295  Destructor->getParent());
11296 
11297  if (CheckDestructor(Destructor)) {
11298  Destructor->setInvalidDecl();
11299  return;
11300  }
11301 
11302  SourceLocation Loc = Destructor->getEndLoc().isValid()
11303  ? Destructor->getEndLoc()
11304  : Destructor->getLocation();
11305  Destructor->setBody(new (Context) CompoundStmt(Loc));
11306  Destructor->markUsed(Context);
11307 
11308  if (ASTMutationListener *L = getASTMutationListener()) {
11309  L->CompletedImplicitDefinition(Destructor);
11310  }
11311 }
11312 
11313 /// Perform any semantic analysis which needs to be delayed until all
11314 /// pending class member declarations have been parsed.
11316  // If the context is an invalid C++ class, just suppress these checks.
11317  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(CurContext)) {
11318  if (Record->isInvalidDecl()) {
11319  DelayedOverridingExceptionSpecChecks.clear();
11320  DelayedEquivalentExceptionSpecChecks.clear();
11321  DelayedDefaultedMemberExceptionSpecs.clear();
11322  return;
11323  }
11325  }
11326 }
11327 
11329  referenceDLLExportedClassMethods();
11330 }
11331 
11333  if (!DelayedDllExportClasses.empty()) {
11334  // Calling ReferenceDllExportedMembers might cause the current function to
11335  // be called again, so use a local copy of DelayedDllExportClasses.
11337  std::swap(DelayedDllExportClasses, WorkList);
11338  for (CXXRecordDecl *Class : WorkList)
11339  ReferenceDllExportedMembers(*this, Class);
11340  }
11341 }
11342 
11344  assert(getLangOpts().CPlusPlus11 &&
11345  "adjusting dtor exception specs was introduced in c++11");
11346 
11347  if (Destructor->isDependentContext())
11348  return;
11349 
11350  // C++11 [class.dtor]p3:
11351  // A declaration of a destructor that does not have an exception-
11352  // specification is implicitly considered to have the same exception-
11353  // specification as an implicit declaration.
11354  const FunctionProtoType *DtorType = Destructor->getType()->
11355  getAs<FunctionProtoType>();
11356  if (DtorType->hasExceptionSpec())
11357  return;
11358 
11359  // Replace the destructor's type, building off the existing one. Fortunately,
11360  // the only thing of interest in the destructor type is its extended info.
11361  // The return and arguments are fixed.
11364  EPI.ExceptionSpec.SourceDecl = Destructor;
11365  Destructor->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
11366 
11367  // FIXME: If the destructor has a body that could throw, and the newly created
11368  // spec doesn't allow exceptions, we should emit a warning, because this
11369  // change in behavior can break conforming C++03 programs at runtime.
11370  // However, we don't have a body or an exception specification yet, so it
11371  // needs to be done somewhere else.
11372 }
11373 
11374 namespace {
11375 /// An abstract base class for all helper classes used in building the
11376 // copy/move operators. These classes serve as factory functions and help us
11377 // avoid using the same Expr* in the AST twice.
11378 class ExprBuilder {
11379  ExprBuilder(const ExprBuilder&) = delete;
11380  ExprBuilder &operator=(const ExprBuilder&) = delete;
11381 
11382 protected:
11383  static Expr *assertNotNull(Expr *E) {
11384  assert(E && "Expression construction must not fail.");
11385  return E;
11386  }
11387 
11388 public:
11389  ExprBuilder() {}
11390  virtual ~ExprBuilder() {}
11391 
11392  virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
11393 };
11394 
11395 class RefBuilder: public ExprBuilder {
11396  VarDecl *Var;
11397  QualType VarType;
11398 
11399 public:
11400  Expr *build(Sema &S, SourceLocation Loc) const override {
11401  return assertNotNull(S.BuildDeclRefExpr(Var, VarType, VK_LValue, Loc).get());
11402  }
11403 
11404  RefBuilder(VarDecl *Var, QualType VarType)
11405  : Var(Var), VarType(VarType) {}
11406 };
11407 
11408 class ThisBuilder: public ExprBuilder {
11409 public:
11410  Expr *build(Sema &S, SourceLocation Loc) const override {
11411  return assertNotNull(S.ActOnCXXThis(Loc).getAs<Expr>());
11412  }
11413 };
11414 
11415 class CastBuilder: public ExprBuilder {
11416  const ExprBuilder &Builder;
11417  QualType Type;
11419  const CXXCastPath &Path;
11420 
11421 public:
11422  Expr *build(Sema &S, SourceLocation Loc) const override {
11423  return assertNotNull(S.ImpCastExprToType(Builder.build(S, Loc), Type,
11424  CK_UncheckedDerivedToBase, Kind,
11425  &Path).get());
11426  }
11427 
11428  CastBuilder(const ExprBuilder &Builder, QualType Type, ExprValueKind Kind,
11429  const CXXCastPath &Path)
11430  : Builder(Builder), Type(Type), Kind(Kind), Path(Path) {}
11431 };
11432 
11433 class DerefBuilder: public ExprBuilder {
11434  const ExprBuilder &Builder;
11435 
11436 public:
11437  Expr *build(Sema &S, SourceLocation Loc) const override {
11438  return assertNotNull(
11439  S.CreateBuiltinUnaryOp(Loc, UO_Deref, Builder.build(S, Loc)).get());
11440  }
11441 
11442  DerefBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
11443 };
11444 
11445 class MemberBuilder: public ExprBuilder {
11446  const ExprBuilder &Builder;
11447  QualType Type;
11448  CXXScopeSpec SS;
11449  bool IsArrow;
11450  LookupResult &MemberLookup;
11451 
11452 public:
11453  Expr *build(Sema &S, SourceLocation Loc) const override {
11454  return assertNotNull(S.BuildMemberReferenceExpr(
11455  Builder.build(S, Loc), Type, Loc, IsArrow, SS, SourceLocation(),
11456  nullptr, MemberLookup, nullptr, nullptr).get());
11457  }
11458 
11459  MemberBuilder(const ExprBuilder &Builder, QualType Type, bool IsArrow,
11460  LookupResult &MemberLookup)
11461  : Builder(Builder), Type(Type), IsArrow(IsArrow),
11462  MemberLookup(MemberLookup) {}
11463 };
11464 
11465 class MoveCastBuilder: public ExprBuilder {
11466  const ExprBuilder &Builder;
11467 
11468 public:
11469  Expr *build(Sema &S, SourceLocation Loc) const override {
11470  return assertNotNull(CastForMoving(S, Builder.build(S, Loc)));
11471  }
11472 
11473  MoveCastBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
11474 };
11475 
11476 class LvalueConvBuilder: public ExprBuilder {
11477  const ExprBuilder &Builder;
11478 
11479 public:
11480  Expr *build(Sema &S, SourceLocation Loc) const override {
11481  return assertNotNull(
11482  S.DefaultLvalueConversion(Builder.build(S, Loc)).get());
11483  }
11484 
11485  LvalueConvBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
11486 };
11487 
11488 class SubscriptBuilder: public ExprBuilder {
11489  const ExprBuilder &Base;
11490  const ExprBuilder &Index;
11491 
11492 public:
11493  Expr *build(Sema &S, SourceLocation Loc) const override {
11494  return assertNotNull(S.CreateBuiltinArraySubscriptExpr(
11495  Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).get());
11496  }
11497 
11498  SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index)
11499  : Base(Base), Index(Index) {}
11500 };
11501 
11502 } // end anonymous namespace
11503 
11504 /// When generating a defaulted copy or move assignment operator, if a field
11505 /// should be copied with __builtin_memcpy rather than via explicit assignments,
11506 /// do so. This optimization only applies for arrays of scalars, and for arrays
11507 /// of class type where the selected copy/move-assignment operator is trivial.
11508 static StmtResult
11510  const ExprBuilder &ToB, const ExprBuilder &FromB) {
11511  // Compute the size of the memory buffer to be copied.
11512  QualType SizeType = S.Context.getSizeType();
11513  llvm::APInt Size(S.Context.getTypeSize(SizeType),
11515 
11516  // Take the address of the field references for "from" and "to". We
11517  // directly construct UnaryOperators here because semantic analysis
11518  // does not permit us to take the address of an xvalue.
11519  Expr *From = FromB.build(S, Loc);
11520  From = new (S.Context) UnaryOperator(From, UO_AddrOf,
11521  S.Context.getPointerType(From->getType()),
11522  VK_RValue, OK_Ordinary, Loc, false);
11523  Expr *To = ToB.build(S, Loc);
11524  To = new (S.Context) UnaryOperator(To, UO_AddrOf,
11525  S.Context.getPointerType(To->getType()),
11526  VK_RValue, OK_Ordinary, Loc, false);
11527 
11528  const Type *E = T->getBaseElementTypeUnsafe();
11529  bool NeedsCollectableMemCpy =
11530  E->isRecordType() && E->getAs<RecordType>()->getDecl()->hasObjectMember();
11531 
11532  // Create a reference to the __builtin_objc_memmove_collectable function
11533  StringRef MemCpyName = NeedsCollectableMemCpy ?
11534  "__builtin_objc_memmove_collectable" :
11535  "__builtin_memcpy";
11536  LookupResult R(S, &S.Context.Idents.get(MemCpyName), Loc,
11538  S.LookupName(R, S.TUScope, true);
11539 
11540  FunctionDecl *MemCpy = R.getAsSingle<FunctionDecl>();
11541  if (!MemCpy)
11542  // Something went horribly wrong earlier, and we will have complained
11543  // about it.
11544  return StmtError();
11545 
11546  ExprResult MemCpyRef = S.BuildDeclRefExpr(MemCpy, S.Context.BuiltinFnTy,
11547  VK_RValue, Loc, nullptr);
11548  assert(MemCpyRef.isUsable() && "Builtin reference cannot fail");
11549 
11550  Expr *CallArgs[] = {
11551  To, From, IntegerLiteral::Create(S.Context, Size, SizeType, Loc)
11552  };
11553  ExprResult Call = S.ActOnCallExpr(/*Scope=*/nullptr, MemCpyRef.get(),
11554  Loc, CallArgs, Loc);
11555 
11556  assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!");
11557  return Call.getAs<Stmt>();
11558 }
11559 
11560 /// Builds a statement that copies/moves the given entity from \p From to
11561 /// \c To.
11562 ///
11563 /// This routine is used to copy/move the members of a class with an
11564 /// implicitly-declared copy/move assignment operator. When the entities being
11565 /// copied are arrays, this routine builds for loops to copy them.
11566 ///
11567 /// \param S The Sema object used for type-checking.
11568 ///
11569 /// \param Loc The location where the implicit copy/move is being generated.
11570 ///
11571 /// \param T The type of the expressions being copied/moved. Both expressions
11572 /// must have this type.
11573 ///
11574 /// \param To The expression we are copying/moving to.
11575 ///
11576 /// \param From The expression we are copying/moving from.
11577 ///
11578 /// \param CopyingBaseSubobject Whether we're copying/moving a base subobject.
11579 /// Otherwise, it's a non-static member subobject.
11580 ///
11581 /// \param Copying Whether we're copying or moving.
11582 ///
11583 /// \param Depth Internal parameter recording the depth of the recursion.
11584 ///
11585 /// \returns A statement or a loop that copies the expressions, or StmtResult(0)
11586 /// if a memcpy should be used instead.
11587 static StmtResult
11589  const ExprBuilder &To, const ExprBuilder &From,
11590  bool CopyingBaseSubobject, bool Copying,
11591  unsigned Depth = 0) {
11592  // C++11 [class.copy]p28:
11593  // Each subobject is assigned in the manner appropriate to its type:
11594  //
11595  // - if the subobject is of class type, as if by a call to operator= with
11596  // the subobject as the object expression and the corresponding
11597  // subobject of x as a single function argument (as if by explicit
11598  // qualification; that is, ignoring any possible virtual overriding
11599  // functions in more derived classes);
11600  //
11601  // C++03 [class.copy]p13:
11602  // - if the subobject is of class type, the copy assignment operator for
11603  // the class is used (as if by explicit qualification; that is,
11604  // ignoring any possible virtual overriding functions in more derived
11605  // classes);
11606  if (const RecordType *RecordTy = T->getAs<RecordType>()) {
11607  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
11608 
11609  // Look for operator=.
11610  DeclarationName Name
11612  LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName);
11613  S.LookupQualifiedName(OpLookup, ClassDecl, false);
11614 
11615  // Prior to C++11, filter out any result that isn't a copy/move-assignment
11616  // operator.
11617  if (!S.getLangOpts().CPlusPlus11) {
11618  LookupResult::Filter F = OpLookup.makeFilter();
11619  while (F.hasNext()) {
11620  NamedDecl *D = F.next();
11621  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
11622  if (Method->isCopyAssignmentOperator() ||
11623  (!Copying && Method->isMoveAssignmentOperator()))
11624  continue;
11625 
11626  F.erase();
11627  }
11628  F.done();
11629  }
11630 
11631  // Suppress the protected check (C++ [class.protected]) for each of the
11632  // assignment operators we found. This strange dance is required when
11633  // we're assigning via a base classes's copy-assignment operator. To
11634  // ensure that we're getting the right base class subobject (without
11635  // ambiguities), we need to cast "this" to that subobject type; to
11636  // ensure that we don't go through the virtual call mechanism, we need
11637  // to qualify the operator= name with the base class (see below). However,
11638  // this means that if the base class has a protected copy assignment
11639  // operator, the protected member access check will fail. So, we
11640  // rewrite "protected" access to "public" access in this case, since we
11641  // know by construction that we're calling from a derived class.
11642  if (CopyingBaseSubobject) {
11643  for (LookupResult::iterator L = OpLookup.begin(), LEnd = OpLookup.end();
11644  L != LEnd; ++L) {
11645  if (L.getAccess() == AS_protected)
11646  L.setAccess(AS_public);
11647  }
11648  }
11649 
11650  // Create the nested-name-specifier that will be used to qualify the
11651  // reference to operator=; this is required to suppress the virtual
11652  // call mechanism.
11653  CXXScopeSpec SS;
11654  const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
11655  SS.MakeTrivial(S.Context,
11656  NestedNameSpecifier::Create(S.Context, nullptr, false,
11657  CanonicalT),
11658  Loc);
11659 
11660  // Create the reference to operator=.
11661  ExprResult OpEqualRef
11662  = S.BuildMemberReferenceExpr(To.build(S, Loc), T, Loc, /*isArrow=*/false,
11663  SS, /*TemplateKWLoc=*/SourceLocation(),
11664  /*FirstQualifierInScope=*/nullptr,
11665  OpLookup,
11666  /*TemplateArgs=*/nullptr, /*S*/nullptr,
11667  /*SuppressQualifierCheck=*/true);
11668  if (OpEqualRef.isInvalid())
11669  return StmtError();
11670 
11671  // Build the call to the assignment operator.
11672 
11673  Expr *FromInst = From.build(S, Loc);
11674  ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/nullptr,
11675  OpEqualRef.getAs<Expr>(),
11676  Loc, FromInst, Loc);
11677  if (Call.isInvalid())
11678  return StmtError();
11679 
11680  // If we built a call to a trivial 'operator=' while copying an array,
11681  // bail out. We'll replace the whole shebang with a memcpy.
11682  CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(Call.get());
11683  if (CE && CE->getMethodDecl()->isTrivial() && Depth)
11684  return StmtResult((Stmt*)nullptr);
11685 
11686  // Convert to an expression-statement, and clean up any produced
11687  // temporaries.
11688  return S.ActOnExprStmt(Call);
11689  }
11690 
11691  // - if the subobject is of scalar type, the built-in assignment
11692  // operator is used.
11693  const ConstantArrayType *ArrayTy = S.Context.getAsConstantArrayType(T);
11694  if (!ArrayTy) {
11696  Loc, BO_Assign, To.build(S, Loc), From.build(S, Loc));
11697  if (Assignment.isInvalid())
11698  return StmtError();
11699  return S.ActOnExprStmt(Assignment);
11700  }
11701 
11702  // - if the subobject is an array, each element is assigned, in the
11703  // manner appropriate to the element type;
11704 
11705  // Construct a loop over the array bounds, e.g.,
11706  //
11707  // for (__SIZE_TYPE__ i0 = 0; i0 != array-size; ++i0)
11708  //
11709  // that will copy each of the array elements.
11710  QualType SizeType = S.Context.getSizeType();
11711 
11712  // Create the iteration variable.
11713  IdentifierInfo *IterationVarName = nullptr;
11714  {
11715  SmallString<8> Str;
11716  llvm::raw_svector_ostream OS(Str);
11717  OS << "__i" << Depth;
11718  IterationVarName = &S.Context.Idents.get(OS.str());
11719  }
11720  VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
11721  IterationVarName, SizeType,
11722  S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
11723  SC_None);
11724 
11725  // Initialize the iteration variable to zero.
11726  llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
11727  IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
11728 
11729  // Creates a reference to the iteration variable.
11730  RefBuilder IterationVarRef(IterationVar, SizeType);
11731  LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
11732 
11733  // Create the DeclStmt that holds the iteration variable.
11734  Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);
11735 
11736  // Subscript the "from" and "to" expressions with the iteration variable.
11737  SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
11738  MoveCastBuilder FromIndexMove(FromIndexCopy);
11739  const ExprBuilder *FromIndex;
11740  if (Copying)
11741  FromIndex = &FromIndexCopy;
11742  else
11743  FromIndex = &FromIndexMove;
11744 
11745  SubscriptBuilder ToIndex(To, IterationVarRefRVal);
11746 
11747  // Build the copy/move for an individual element of the array.
11748  StmtResult Copy =
11750  ToIndex, *FromIndex, CopyingBaseSubobject,
11751  Copying, Depth + 1);
11752  // Bail out if copying fails or if we determined that we should use memcpy.
11753  if (Copy.isInvalid() || !Copy.get())
11754  return Copy;
11755 
11756  // Create the comparison against the array bound.
11757  llvm::APInt Upper
11758  = ArrayTy->getSize().zextOrTrunc(S.Context.getTypeSize(SizeType));
11759  Expr *Comparison
11760  = new (S.Context) BinaryOperator(IterationVarRefRVal.build(S, Loc),
11761  IntegerLiteral::Create(S.Context, Upper, SizeType, Loc),
11762  BO_NE, S.Context.BoolTy,
11763  VK_RValue, OK_Ordinary, Loc, FPOptions());
11764 
11765  // Create the pre-increment of the iteration variable. We can determine
11766  // whether the increment will overflow based on the value of the array
11767  // bound.
11768  Expr *Increment = new (S.Context)
11769  UnaryOperator(IterationVarRef.build(S, Loc), UO_PreInc, SizeType,
11770  VK_LValue, OK_Ordinary, Loc, Upper.isMaxValue());
11771 
11772  // Construct the loop that copies all elements of this array.
11773  return S.ActOnForStmt(
11774  Loc, Loc, InitStmt,
11775  S.ActOnCondition(nullptr, Loc, Comparison, Sema::ConditionKind::Boolean),
11776  S.MakeFullDiscardedValueExpr(Increment), Loc, Copy.get());
11777 }
11778 
11779 static StmtResult
11781  const ExprBuilder &To, const ExprBuilder &From,
11782  bool CopyingBaseSubobject, bool Copying) {
11783  // Maybe we should use a memcpy?
11784  if (T->isArrayType() && !T.isConstQualified() && !T.isVolatileQualified() &&
11786  return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
11787 
11789  CopyingBaseSubobject,
11790  Copying, 0));
11791 
11792  // If we ended up picking a trivial assignment operator for an array of a
11793  // non-trivially-copyable class type, just emit a memcpy.
11794  if (!Result.isInvalid() && !Result.get())
11795  return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
11796 
11797  return Result;
11798 }
11799 
11801  // Note: The following rules are largely analoguous to the copy
11802  // constructor rules. Note that virtual bases are not taken into account
11803  // for determining the argument type of the operator. Note also that
11804  // operators taking an object instead of a reference are allowed.
11805  assert(ClassDecl->needsImplicitCopyAssignment());
11806 
11807  DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyAssignment);
11808  if (DSM.isAlreadyBeingDeclared())
11809  return nullptr;
11810 
11811  QualType ArgType = Context.getTypeDeclType(ClassDecl);
11812  QualType RetType = Context.getLValueReferenceType(ArgType);
11813  bool Const = ClassDecl->implicitCopyAssignmentHasConstParam();
11814  if (Const)
11815  ArgType = ArgType.withConst();
11816 
11817  if (Context.getLangOpts().OpenCLCPlusPlus)
11818  ArgType = Context.getAddrSpaceQualType(ArgType, LangAS::opencl_generic);
11819 
11820  ArgType = Context.getLValueReferenceType(ArgType);
11821 
11822  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
11823  CXXCopyAssignment,
11824  Const);
11825 
11826  // An implicitly-declared copy assignment operator is an inline public
11827  // member of its class.
11828  DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
11829  SourceLocation ClassLoc = ClassDecl->getLocation();
11830  DeclarationNameInfo NameInfo(Name, ClassLoc);
11831  CXXMethodDecl *CopyAssignment =
11832  CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
11833  /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
11834  /*isInline=*/true, Constexpr, SourceLocation());
11835  CopyAssignment->setAccess(AS_public);
11836  CopyAssignment->setDefaulted();
11837  CopyAssignment->setImplicit();
11838 
11839  if (getLangOpts().CUDA) {
11840  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyAssignment,
11841  CopyAssignment,
11842  /* ConstRHS */ Const,
11843  /* Diagnose */ false);
11844  }
11845 
11846  setupImplicitSpecialMemberType(CopyAssignment, RetType, ArgType);
11847 
11848  // Add the parameter to the operator.
11849  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
11850  ClassLoc, ClassLoc,
11851  /*Id=*/nullptr, ArgType,
11852  /*TInfo=*/nullptr, SC_None,
11853  nullptr);
11854  CopyAssignment->setParams(FromParam);
11855 
11856  CopyAssignment->setTrivial(
11858  ? SpecialMemberIsTrivial(CopyAssignment, CXXCopyAssignment)
11859  : ClassDecl->hasTrivialCopyAssignment());
11860 
11861  // Note that we have added this copy-assignment operator.
11863 
11864  Scope *S = getScopeForContext(ClassDecl);
11865  CheckImplicitSpecialMemberDeclaration(S, CopyAssignment);
11866 
11867  if (ShouldDeleteSpecialMember(CopyAssignment, CXXCopyAssignment))
11868  SetDeclDeleted(CopyAssignment, ClassLoc);
11869 
11870  if (S)
11871  PushOnScopeChains(CopyAssignment, S, false);
11872  ClassDecl->addDecl(CopyAssignment);
11873 
11874  return CopyAssignment;
11875 }
11876 
11877 /// Diagnose an implicit copy operation for a class which is odr-used, but
11878 /// which is deprecated because the class has a user-declared copy constructor,
11879 /// copy assignment operator, or destructor.
11881  assert(CopyOp->isImplicit());
11882 
11883  CXXRecordDecl *RD = CopyOp->getParent();
11884  CXXMethodDecl *UserDeclaredOperation = nullptr;
11885 
11886  // In Microsoft mode, assignment operations don't affect constructors and
11887  // vice versa.
11888  if (RD->hasUserDeclaredDestructor()) {
11889  UserDeclaredOperation = RD->getDestructor();
11890  } else if (!isa<CXXConstructorDecl>(CopyOp) &&
11891  RD->hasUserDeclaredCopyConstructor() &&
11892  !S.getLangOpts().MSVCCompat) {
11893  // Find any user-declared copy constructor.
11894  for (auto *I : RD->ctors()) {
11895  if (I->isCopyConstructor()) {
11896  UserDeclaredOperation = I;
11897  break;
11898  }
11899  }
11900  assert(UserDeclaredOperation);
11901  } else if (isa<CXXConstructorDecl>(CopyOp) &&
11902  RD->hasUserDeclaredCopyAssignment() &&
11903  !S.getLangOpts().MSVCCompat) {
11904  // Find any user-declared move assignment operator.
11905  for (auto *I : RD->methods()) {
11906  if (I->isCopyAssignmentOperator()) {
11907  UserDeclaredOperation = I;
11908  break;
11909  }
11910  }
11911  assert(UserDeclaredOperation);
11912  }
11913 
11914  if (UserDeclaredOperation) {
11915  S.Diag(UserDeclaredOperation->getLocation(),
11916  diag::warn_deprecated_copy_operation)
11917  << RD << /*copy assignment*/!isa<CXXConstructorDecl>(CopyOp)
11918  << /*destructor*/isa<CXXDestructorDecl>(UserDeclaredOperation);
11919  }
11920 }
11921 
11923  CXXMethodDecl *CopyAssignOperator) {
11924  assert((CopyAssignOperator->isDefaulted() &&
11925  CopyAssignOperator->isOverloadedOperator() &&
11926  CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
11927  !CopyAssignOperator->doesThisDeclarationHaveABody() &&
11928  !CopyAssignOperator->isDeleted()) &&
11929  "DefineImplicitCopyAssignment called for wrong function");
11930  if (CopyAssignOperator->willHaveBody() || CopyAssignOperator->isInvalidDecl())
11931  return;
11932 
11933  CXXRecordDecl *ClassDecl = CopyAssignOperator->getParent();
11934  if (ClassDecl->isInvalidDecl()) {
11935  CopyAssignOperator->setInvalidDecl();
11936  return;
11937  }
11938 
11939  SynthesizedFunctionScope Scope(*this, CopyAssignOperator);
11940 
11941  // The exception specification is needed because we are defining the
11942  // function.
11943  ResolveExceptionSpec(CurrentLocation,
11944  CopyAssignOperator->getType()->castAs<FunctionProtoType>());
11945 
11946  // Add a context note for diagnostics produced after this point.
11947  Scope.addContextNote(CurrentLocation);
11948 
11949  // C++11 [class.copy]p18:
11950  // The [definition of an implicitly declared copy assignment operator] is
11951  // deprecated if the class has a user-declared copy constructor or a
11952  // user-declared destructor.
11953  if (getLangOpts().CPlusPlus11 && CopyAssignOperator->isImplicit())
11954  diagnoseDeprecatedCopyOperation(*this, CopyAssignOperator);
11955 
11956  // C++0x [class.copy]p30:
11957  // The implicitly-defined or explicitly-defaulted copy assignment operator
11958  // for a non-union class X performs memberwise copy assignment of its
11959  // subobjects. The direct base classes of X are assigned first, in the
11960  // order of their declaration in the base-specifier-list, and then the
11961  // immediate non-static data members of X are assigned, in the order in
11962  // which they were declared in the class definition.
11963 
11964  // The statements that form the synthesized function body.
11965  SmallVector<Stmt*, 8> Statements;
11966 
11967  // The parameter for the "other" object, which we are copying from.
11968  ParmVarDecl *Other = CopyAssignOperator->getParamDecl(0);
11969  Qualifiers OtherQuals = Other->getType().getQualifiers();
11970  QualType OtherRefType = Other->getType();
11971  if (const LValueReferenceType *OtherRef
11972  = OtherRefType->getAs<LValueReferenceType>()) {
11973  OtherRefType = OtherRef->getPointeeType();
11974  OtherQuals = OtherRefType.getQualifiers();
11975  }
11976 
11977  // Our location for everything implicitly-generated.
11978  SourceLocation Loc = CopyAssignOperator->getEndLoc().isValid()
11979  ? CopyAssignOperator->getEndLoc()
11980  : CopyAssignOperator->getLocation();
11981 
11982  // Builds a DeclRefExpr for the "other" object.
11983  RefBuilder OtherRef(Other, OtherRefType);
11984 
11985  // Builds the "this" pointer.
11986  ThisBuilder This;
11987 
11988  // Assign base classes.
11989  bool Invalid = false;
11990  for (auto &Base : ClassDecl->bases()) {
11991  // Form the assignment:
11992  // static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other));
11993  QualType BaseType = Base.getType().getUnqualifiedType();
11994  if (!BaseType->isRecordType()) {
11995  Invalid = true;
11996  continue;
11997  }
11998 
11999  CXXCastPath BasePath;
12000  BasePath.push_back(&Base);
12001 
12002  // Construct the "from" expression, which is an implicit cast to the
12003  // appropriately-qualified base type.
12004  CastBuilder From(OtherRef, Context.getQualifiedType(BaseType, OtherQuals),
12005  VK_LValue, BasePath);
12006 
12007  // Dereference "this".
12008  DerefBuilder DerefThis(This);
12009  CastBuilder To(DerefThis,
12010  Context.getQualifiedType(
12011  BaseType, CopyAssignOperator->getTypeQualifiers()),
12012  VK_LValue, BasePath);
12013 
12014  // Build the copy.
12015  StmtResult Copy = buildSingleCopyAssign(*this, Loc, BaseType,
12016  To, From,
12017  /*CopyingBaseSubobject=*/true,
12018  /*Copying=*/true);
12019  if (Copy.isInvalid()) {
12020  CopyAssignOperator->setInvalidDecl();
12021  return;
12022  }
12023 
12024  // Success! Record the copy.
12025  Statements.push_back(Copy.getAs<Expr>());
12026  }
12027 
12028  // Assign non-static members.
12029  for (auto *Field : ClassDecl->fields()) {
12030  // FIXME: We should form some kind of AST representation for the implied
12031  // memcpy in a union copy operation.
12032  if (Field->isUnnamedBitfield() || Field->getParent()->isUnion())
12033  continue;
12034 
12035  if (Field->isInvalidDecl()) {
12036  Invalid = true;
12037  continue;
12038  }
12039 
12040  // Check for members of reference type; we can't copy those.
12041  if (Field->getType()->isReferenceType()) {
12042  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
12043  << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
12044  Diag(Field->getLocation(), diag::note_declared_at);
12045  Invalid = true;
12046  continue;
12047  }
12048 
12049  // Check for members of const-qualified, non-class type.
12050  QualType BaseType = Context.getBaseElementType(Field->getType());
12051  if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
12052  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
12053  << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
12054  Diag(Field->getLocation(), diag::note_declared_at);
12055  Invalid = true;
12056  continue;
12057  }
12058 
12059  // Suppress assigning zero-width bitfields.
12060  if (Field->isZeroLengthBitField(Context))
12061  continue;
12062 
12063  QualType FieldType = Field->getType().getNonReferenceType();
12064  if (FieldType->isIncompleteArrayType()) {
12065  assert(ClassDecl->hasFlexibleArrayMember() &&
12066  "Incomplete array type is not valid");
12067  continue;
12068  }
12069 
12070  // Build references to the field in the object we're copying from and to.
12071  CXXScopeSpec SS; // Intentionally empty
12072  LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
12073  LookupMemberName);
12074  MemberLookup.addDecl(Field);
12075  MemberLookup.resolveKind();
12076 
12077  MemberBuilder From(OtherRef, OtherRefType, /*IsArrow=*/false, MemberLookup);
12078 
12079  MemberBuilder To(This, getCurrentThisType(), /*IsArrow=*/true, MemberLookup);
12080 
12081  // Build the copy of this field.
12082  StmtResult Copy = buildSingleCopyAssign(*this, Loc, FieldType,
12083  To, From,
12084  /*CopyingBaseSubobject=*/false,
12085  /*Copying=*/true);
12086  if (Copy.isInvalid()) {
12087  CopyAssignOperator->setInvalidDecl();
12088  return;
12089  }
12090 
12091  // Success! Record the copy.
12092  Statements.push_back(Copy.getAs<Stmt>());
12093  }
12094 
12095  if (!Invalid) {
12096  // Add a "return *this;"
12097  ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
12098 
12099  StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
12100  if (Return.isInvalid())
12101  Invalid = true;
12102  else
12103  Statements.push_back(Return.getAs<Stmt>());
12104  }
12105 
12106  if (Invalid) {
12107  CopyAssignOperator->setInvalidDecl();
12108  return;
12109  }
12110 
12111  StmtResult Body;
12112  {
12113  CompoundScopeRAII CompoundScope(*this);
12114  Body = ActOnCompoundStmt(Loc, Loc, Statements,
12115  /*isStmtExpr=*/false);
12116  assert(!Body.isInvalid() && "Compound statement creation cannot fail");
12117  }
12118  CopyAssignOperator->setBody(Body.getAs<Stmt>());
12119  CopyAssignOperator->markUsed(Context);
12120 
12121  if (ASTMutationListener *L = getASTMutationListener()) {
12122  L->CompletedImplicitDefinition(CopyAssignOperator);
12123  }
12124 }
12125 
12127  assert(ClassDecl->needsImplicitMoveAssignment());
12128 
12129  DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveAssignment);
12130  if (DSM.isAlreadyBeingDeclared())
12131  return nullptr;
12132 
12133  // Note: The following rules are largely analoguous to the move
12134  // constructor rules.
12135 
12136  QualType ArgType = Context.getTypeDeclType(ClassDecl);
12137  QualType RetType = Context.getLValueReferenceType(ArgType);
12138  ArgType = Context.getRValueReferenceType(ArgType);
12139 
12140  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
12141  CXXMoveAssignment,
12142  false);
12143 
12144  // An implicitly-declared move assignment operator is an inline public
12145  // member of its class.
12146  DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
12147  SourceLocation ClassLoc = ClassDecl->getLocation();
12148  DeclarationNameInfo NameInfo(Name, ClassLoc);
12149  CXXMethodDecl *MoveAssignment =
12150  CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
12151  /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
12152  /*isInline=*/true, Constexpr, SourceLocation());
12153  MoveAssignment->setAccess(AS_public);
12154  MoveAssignment->setDefaulted();
12155  MoveAssignment->setImplicit();
12156 
12157  if (getLangOpts().CUDA) {
12158  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveAssignment,
12159  MoveAssignment,
12160  /* ConstRHS */ false,
12161  /* Diagnose */ false);
12162  }
12163 
12164  // Build an exception specification pointing back at this member.
12166  getImplicitMethodEPI(*this, MoveAssignment);
12167  MoveAssignment->setType(Context.getFunctionType(RetType, ArgType, EPI));
12168 
12169  // Add the parameter to the operator.
12170  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveAssignment,
12171  ClassLoc, ClassLoc,
12172  /*Id=*/nullptr, ArgType,
12173  /*TInfo=*/nullptr, SC_None,
12174  nullptr);
12175  MoveAssignment->setParams(FromParam);
12176 
12177  MoveAssignment->setTrivial(
12179  ? SpecialMemberIsTrivial(MoveAssignment, CXXMoveAssignment)
12180  : ClassDecl->hasTrivialMoveAssignment());
12181 
12182  // Note that we have added this copy-assignment operator.
12184 
12185  Scope *S = getScopeForContext(ClassDecl);
12186  CheckImplicitSpecialMemberDeclaration(S, MoveAssignment);
12187 
12188  if (ShouldDeleteSpecialMember(MoveAssignment, CXXMoveAssignment)) {
12190  SetDeclDeleted(MoveAssignment, ClassLoc);
12191  }
12192 
12193  if (S)
12194  PushOnScopeChains(MoveAssignment, S, false);
12195  ClassDecl->addDecl(MoveAssignment);
12196 
12197  return MoveAssignment;
12198 }
12199 
12200 /// Check if we're implicitly defining a move assignment operator for a class
12201 /// with virtual bases. Such a move assignment might move-assign the virtual
12202 /// base multiple times.
12204  SourceLocation CurrentLocation) {
12205  assert(!Class->isDependentContext() && "should not define dependent move");
12206 
12207  // Only a virtual base could get implicitly move-assigned multiple times.
12208  // Only a non-trivial move assignment can observe this. We only want to
12209  // diagnose if we implicitly define an assignment operator that assigns
12210  // two base classes, both of which move-assign the same virtual base.
12211  if (Class->getNumVBases() == 0 || Class->hasTrivialMoveAssignment() ||
12212  Class->getNumBases() < 2)
12213  return;
12214 
12216  typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
12217  VBaseMap VBases;
12218 
12219  for (auto &BI : Class->bases()) {
12220  Worklist.push_back(&BI);
12221  while (!Worklist.empty()) {
12222  CXXBaseSpecifier *BaseSpec = Worklist.pop_back_val();
12223  CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
12224 
12225  // If the base has no non-trivial move assignment operators,
12226  // we don't care about moves from it.
12227  if (!Base->hasNonTrivialMoveAssignment())
12228  continue;
12229 
12230  // If there's nothing virtual here, skip it.
12231  if (!BaseSpec->isVirtual() && !Base->getNumVBases())
12232  continue;
12233 
12234  // If we're not actually going to call a move assignment for this base,
12235  // or the selected move assignment is trivial, skip it.
12238  /*ConstArg*/false, /*VolatileArg*/false,
12239  /*RValueThis*/true, /*ConstThis*/false,
12240  /*VolatileThis*/false);
12241  if (!SMOR.getMethod() || SMOR.getMethod()->isTrivial() ||
12243  continue;
12244 
12245  if (BaseSpec->isVirtual()) {
12246  // We're going to move-assign this virtual base, and its move
12247  // assignment operator is not trivial. If this can happen for
12248  // multiple distinct direct bases of Class, diagnose it. (If it
12249  // only happens in one base, we'll diagnose it when synthesizing
12250  // that base class's move assignment operator.)
12251  CXXBaseSpecifier *&Existing =
12252  VBases.insert(std::make_pair(Base->getCanonicalDecl(), &BI))
12253  .first->second;
12254  if (Existing && Existing != &BI) {
12255  S.Diag(CurrentLocation, diag::warn_vbase_moved_multiple_times)
12256  << Class << Base;
12257  S.Diag(Existing->getBeginLoc(), diag::note_vbase_moved_here)
12258  << (Base->getCanonicalDecl() ==
12259  Existing->getType()->getAsCXXRecordDecl()->getCanonicalDecl())
12260  << Base << Existing->getType() << Existing->getSourceRange();
12261  S.Diag(BI.getBeginLoc(), diag::note_vbase_moved_here)
12262  << (Base->getCanonicalDecl() ==
12263  BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
12264  << Base << BI.getType() << BaseSpec->getSourceRange();
12265 
12266  // Only diagnose each vbase once.
12267  Existing = nullptr;
12268  }
12269  } else {
12270  // Only walk over bases that have defaulted move assignment operators.
12271  // We assume that any user-provided move assignment operator handles
12272  // the multiple-moves-of-vbase case itself somehow.
12273  if (!SMOR.getMethod()->isDefaulted())
12274  continue;
12275 
12276  // We're going to move the base classes of Base. Add them to the list.
12277  for (auto &BI : Base->bases())
12278  Worklist.push_back(&BI);
12279  }
12280  }
12281  }
12282 }
12283 
12285  CXXMethodDecl *MoveAssignOperator) {
12286  assert((MoveAssignOperator->isDefaulted() &&
12287  MoveAssignOperator->isOverloadedOperator() &&
12288  MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
12289  !MoveAssignOperator->doesThisDeclarationHaveABody() &&
12290  !MoveAssignOperator->isDeleted()) &&
12291  "DefineImplicitMoveAssignment called for wrong function");
12292  if (MoveAssignOperator->willHaveBody() || MoveAssignOperator->isInvalidDecl())
12293  return;
12294 
12295  CXXRecordDecl *ClassDecl = MoveAssignOperator->getParent();
12296  if (ClassDecl->isInvalidDecl()) {
12297  MoveAssignOperator->setInvalidDecl();
12298  return;
12299  }
12300 
12301  // C++0x [class.copy]p28:
12302  // The implicitly-defined or move assignment operator for a non-union class
12303  // X performs memberwise move assignment of its subobjects. The direct base
12304  // classes of X are assigned first, in the order of their declaration in the
12305  // base-specifier-list, and then the immediate non-static data members of X
12306  // are assigned, in the order in which they were declared in the class
12307  // definition.
12308 
12309  // Issue a warning if our implicit move assignment operator will move
12310  // from a virtual base more than once.
12311  checkMoveAssignmentForRepeatedMove(*this, ClassDecl, CurrentLocation);
12312 
12313  SynthesizedFunctionScope Scope(*this, MoveAssignOperator);
12314 
12315  // The exception specification is needed because we are defining the
12316  // function.
12317  ResolveExceptionSpec(CurrentLocation,
12318  MoveAssignOperator->getType()->castAs<FunctionProtoType>());
12319 
12320  // Add a context note for diagnostics produced after this point.
12321  Scope.addContextNote(CurrentLocation);
12322 
12323  // The statements that form the synthesized function body.
12324  SmallVector<Stmt*, 8> Statements;
12325 
12326  // The parameter for the "other" object, which we are move from.
12327  ParmVarDecl *Other = MoveAssignOperator->getParamDecl(0);
12328  QualType OtherRefType = Other->getType()->
12329  getAs<RValueReferenceType>()->getPointeeType();
12330 
12331  // Our location for everything implicitly-generated.
12332  SourceLocation Loc = MoveAssignOperator->getEndLoc().isValid()
12333  ? MoveAssignOperator->getEndLoc()
12334  : MoveAssignOperator->getLocation();
12335 
12336  // Builds a reference to the "other" object.
12337  RefBuilder OtherRef(Other, OtherRefType);
12338  // Cast to rvalue.
12339  MoveCastBuilder MoveOther(OtherRef);
12340 
12341  // Builds the "this" pointer.
12342  ThisBuilder This;
12343 
12344  // Assign base classes.
12345  bool Invalid = false;
12346  for (auto &Base : ClassDecl->bases()) {
12347  // C++11 [class.copy]p28:
12348  // It is unspecified whether subobjects representing virtual base classes
12349  // are assigned more than once by the implicitly-defined copy assignment
12350  // operator.
12351  // FIXME: Do not assign to a vbase that will be assigned by some other base
12352  // class. For a move-assignment, this can result in the vbase being moved
12353  // multiple times.
12354 
12355  // Form the assignment:
12356  // static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other));
12357  QualType BaseType = Base.getType().getUnqualifiedType();
12358  if (!BaseType->isRecordType()) {
12359  Invalid = true;
12360  continue;
12361  }
12362 
12363  CXXCastPath BasePath;
12364  BasePath.push_back(&Base);
12365 
12366  // Construct the "from" expression, which is an implicit cast to the
12367  // appropriately-qualified base type.
12368  CastBuilder From(OtherRef, BaseType, VK_XValue, BasePath);
12369 
12370  // Dereference "this".
12371  DerefBuilder DerefThis(This);
12372 
12373  // Implicitly cast "this" to the appropriately-qualified base type.
12374  CastBuilder To(DerefThis,
12375  Context.getQualifiedType(
12376  BaseType, MoveAssignOperator->getTypeQualifiers()),
12377  VK_LValue, BasePath);
12378 
12379  // Build the move.
12380  StmtResult Move = buildSingleCopyAssign(*this, Loc, BaseType,
12381  To, From,
12382  /*CopyingBaseSubobject=*/true,
12383  /*Copying=*/false);
12384  if (Move.isInvalid()) {
12385  MoveAssignOperator->setInvalidDecl();
12386  return;
12387  }
12388 
12389  // Success! Record the move.
12390  Statements.push_back(Move.getAs<Expr>());
12391  }
12392 
12393  // Assign non-static members.
12394  for (auto *Field : ClassDecl->fields()) {
12395  // FIXME: We should form some kind of AST representation for the implied
12396  // memcpy in a union copy operation.
12397  if (Field->isUnnamedBitfield() || Field->getParent()->isUnion())
12398  continue;
12399 
12400  if (Field->isInvalidDecl()) {
12401  Invalid = true;
12402  continue;
12403  }
12404 
12405  // Check for members of reference type; we can't move those.
12406  if (Field->getType()->isReferenceType()) {
12407  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
12408  << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
12409  Diag(Field->getLocation(), diag::note_declared_at);
12410  Invalid = true;
12411  continue;
12412  }
12413 
12414  // Check for members of const-qualified, non-class type.
12415  QualType BaseType = Context.getBaseElementType(Field->getType());
12416  if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
12417  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
12418  << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
12419  Diag(Field->getLocation(), diag::note_declared_at);
12420  Invalid = true;
12421  continue;
12422  }
12423 
12424  // Suppress assigning zero-width bitfields.
12425  if (Field->isZeroLengthBitField(Context))
12426  continue;
12427 
12428  QualType FieldType = Field->getType().getNonReferenceType();
12429  if (FieldType->isIncompleteArrayType()) {
12430  assert(ClassDecl->hasFlexibleArrayMember() &&
12431  "Incomplete array type is not valid");
12432  continue;
12433  }
12434 
12435  // Build references to the field in the object we're copying from and to.
12436  LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
12437  LookupMemberName);
12438  MemberLookup.addDecl(Field);
12439  MemberLookup.resolveKind();
12440  MemberBuilder From(MoveOther, OtherRefType,
12441  /*IsArrow=*/false, MemberLookup);
12442  MemberBuilder To(This, getCurrentThisType(),
12443  /*IsArrow=*/true, MemberLookup);
12444 
12445  assert(!From.build(*this, Loc)->isLValue() && // could be xvalue or prvalue
12446  "Member reference with rvalue base must be rvalue except for reference "
12447  "members, which aren't allowed for move assignment.");
12448 
12449  // Build the move of this field.
12450  StmtResult Move = buildSingleCopyAssign(*this, Loc, FieldType,
12451  To, From,
12452  /*CopyingBaseSubobject=*/false,
12453  /*Copying=*/false);
12454  if (Move.isInvalid()) {
12455  MoveAssignOperator->setInvalidDecl();
12456  return;
12457  }
12458 
12459  // Success! Record the copy.
12460  Statements.push_back(Move.getAs<Stmt>());
12461  }
12462 
12463  if (!Invalid) {
12464  // Add a "return *this;"
12465  ExprResult ThisObj =
12466  CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
12467 
12468  StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
12469  if (Return.isInvalid())
12470  Invalid = true;
12471  else
12472  Statements.push_back(Return.getAs<Stmt>());
12473  }
12474 
12475  if (Invalid) {
12476  MoveAssignOperator->setInvalidDecl();
12477  return;
12478  }
12479 
12480  StmtResult Body;
12481  {
12482  CompoundScopeRAII CompoundScope(*this);
12483  Body = ActOnCompoundStmt(Loc, Loc, Statements,
12484  /*isStmtExpr=*/false);
12485  assert(!Body.isInvalid() && "Compound statement creation cannot fail");
12486  }
12487  MoveAssignOperator->setBody(Body.getAs<Stmt>());
12488  MoveAssignOperator->markUsed(Context);
12489 
12490  if (ASTMutationListener *L = getASTMutationListener()) {
12491  L->CompletedImplicitDefinition(MoveAssignOperator);
12492  }
12493 }
12494 
12496  CXXRecordDecl *ClassDecl) {
12497  // C++ [class.copy]p4:
12498  // If the class definition does not explicitly declare a copy
12499  // constructor, one is declared implicitly.
12500  assert(ClassDecl->needsImplicitCopyConstructor());
12501 
12502  DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyConstructor);
12503  if (DSM.isAlreadyBeingDeclared())
12504  return nullptr;
12505 
12506  QualType ClassType = Context.getTypeDeclType(ClassDecl);
12507  QualType ArgType = ClassType;
12508  bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
12509  if (Const)
12510  ArgType = ArgType.withConst();
12511 
12512  if (Context.getLangOpts().OpenCLCPlusPlus)
12513  ArgType = Context.getAddrSpaceQualType(ArgType, LangAS::opencl_generic);
12514 
12515  ArgType = Context.getLValueReferenceType(ArgType);
12516 
12517  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
12518  CXXCopyConstructor,
12519  Const);
12520 
12521  DeclarationName Name
12523  Context.getCanonicalType(ClassType));
12524  SourceLocation ClassLoc = ClassDecl->getLocation();
12525  DeclarationNameInfo NameInfo(Name, ClassLoc);
12526 
12527  // An implicitly-declared copy constructor is an inline public
12528  // member of its class.
12530  Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
12531  /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
12532  Constexpr);
12533  CopyConstructor->setAccess(AS_public);
12534  CopyConstructor->setDefaulted();
12535 
12536  if (getLangOpts().CUDA) {
12537  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyConstructor,
12538  CopyConstructor,
12539  /* ConstRHS */ Const,
12540  /* Diagnose */ false);
12541  }
12542 
12543  setupImplicitSpecialMemberType(CopyConstructor, Context.VoidTy, ArgType);
12544 
12545  // Add the parameter to the constructor.
12546  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
12547  ClassLoc, ClassLoc,
12548  /*IdentifierInfo=*/nullptr,
12549  ArgType, /*TInfo=*/nullptr,
12550  SC_None, nullptr);
12551  CopyConstructor->setParams(FromParam);
12552 
12553  CopyConstructor->setTrivial(
12555  ? SpecialMemberIsTrivial(CopyConstructor, CXXCopyConstructor)
12556  : ClassDecl->hasTrivialCopyConstructor());
12557 
12558  CopyConstructor->setTrivialForCall(
12559  ClassDecl->hasAttr<TrivialABIAttr>() ||
12561  ? SpecialMemberIsTrivial(CopyConstructor, CXXCopyConstructor,
12562  TAH_ConsiderTrivialABI)
12563  : ClassDecl->hasTrivialCopyConstructorForCall()));
12564 
12565  // Note that we have declared this constructor.
12567 
12568  Scope *S = getScopeForContext(ClassDecl);
12569  CheckImplicitSpecialMemberDeclaration(S, CopyConstructor);
12570 
12571  if (ShouldDeleteSpecialMember(CopyConstructor, CXXCopyConstructor)) {
12573  SetDeclDeleted(CopyConstructor, ClassLoc);
12574  }
12575 
12576  if (S)
12577  PushOnScopeChains(CopyConstructor, S, false);
12578  ClassDecl->addDecl(CopyConstructor);
12579 
12580  return CopyConstructor;
12581 }
12582 
12584  CXXConstructorDecl *CopyConstructor) {
12585  assert((CopyConstructor->isDefaulted() &&
12586  CopyConstructor->isCopyConstructor() &&
12587  !CopyConstructor->doesThisDeclarationHaveABody() &&
12588  !CopyConstructor->isDeleted()) &&
12589  "DefineImplicitCopyConstructor - call it for implicit copy ctor");
12590  if (CopyConstructor->willHaveBody() || CopyConstructor->isInvalidDecl())
12591  return;
12592 
12593  CXXRecordDecl *ClassDecl = CopyConstructor->getParent();
12594  assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
12595 
12596  SynthesizedFunctionScope Scope(*this, CopyConstructor);
12597 
12598  // The exception specification is needed because we are defining the
12599  // function.
12600  ResolveExceptionSpec(CurrentLocation,
12601  CopyConstructor->getType()->castAs<FunctionProtoType>());
12602  MarkVTableUsed(CurrentLocation, ClassDecl);
12603 
12604  // Add a context note for diagnostics produced after this point.
12605  Scope.addContextNote(CurrentLocation);
12606 
12607  // C++11 [class.copy]p7:
12608  // The [definition of an implicitly declared copy constructor] is
12609  // deprecated if the class has a user-declared copy assignment operator
12610  // or a user-declared destructor.
12611  if (getLangOpts().CPlusPlus11 && CopyConstructor->isImplicit())
12612  diagnoseDeprecatedCopyOperation(*this, CopyConstructor);
12613 
12614  if (SetCtorInitializers(CopyConstructor, /*AnyErrors=*/false)) {
12615  CopyConstructor->setInvalidDecl();
12616  } else {
12617  SourceLocation Loc = CopyConstructor->getEndLoc().isValid()
12618  ? CopyConstructor->getEndLoc()
12619  : CopyConstructor->getLocation();
12620  Sema::CompoundScopeRAII CompoundScope(*this);
12621  CopyConstructor->setBody(
12622  ActOnCompoundStmt(Loc, Loc, None, /*isStmtExpr=*/false).getAs<Stmt>());
12623  CopyConstructor->markUsed(Context);
12624  }
12625 
12626  if (ASTMutationListener *L = getASTMutationListener()) {
12627  L->CompletedImplicitDefinition(CopyConstructor);
12628  }
12629 }
12630 
12632  CXXRecordDecl *ClassDecl) {
12633  assert(ClassDecl->needsImplicitMoveConstructor());
12634 
12635  DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveConstructor);
12636  if (DSM.isAlreadyBeingDeclared())
12637  return nullptr;
12638 
12639  QualType ClassType = Context.getTypeDeclType(ClassDecl);
12640 
12641  QualType ArgType = ClassType;
12642  if (Context.getLangOpts().OpenCLCPlusPlus)
12643  ArgType = Context.getAddrSpaceQualType(ClassType, LangAS::opencl_generic);
12644  ArgType = Context.getRValueReferenceType(ArgType);
12645 
12646  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
12647  CXXMoveConstructor,
12648  false);
12649 
12650  DeclarationName Name
12652  Context.getCanonicalType(ClassType));
12653  SourceLocation ClassLoc = ClassDecl->getLocation();
12654  DeclarationNameInfo NameInfo(Name, ClassLoc);
12655 
12656  // C++11 [class.copy]p11:
12657  // An implicitly-declared copy/move constructor is an inline public
12658  // member of its class.
12660  Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
12661  /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
12662  Constexpr);
12663  MoveConstructor->setAccess(AS_public);
12664  MoveConstructor->setDefaulted();
12665 
12666  if (getLangOpts().CUDA) {
12667  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveConstructor,
12668  MoveConstructor,
12669  /* ConstRHS */ false,
12670  /* Diagnose */ false);
12671  }
12672 
12673  setupImplicitSpecialMemberType(MoveConstructor, Context.VoidTy, ArgType);
12674 
12675  // Add the parameter to the constructor.
12676  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveConstructor,
12677  ClassLoc, ClassLoc,
12678  /*IdentifierInfo=*/nullptr,
12679  ArgType, /*TInfo=*/nullptr,
12680  SC_None, nullptr);
12681  MoveConstructor->setParams(FromParam);
12682 
12683  MoveConstructor->setTrivial(
12685  ? SpecialMemberIsTrivial(MoveConstructor, CXXMoveConstructor)
12686  : ClassDecl->hasTrivialMoveConstructor());
12687 
12688  MoveConstructor->setTrivialForCall(
12689  ClassDecl->hasAttr<TrivialABIAttr>() ||
12691  ? SpecialMemberIsTrivial(MoveConstructor, CXXMoveConstructor,
12692  TAH_ConsiderTrivialABI)
12693  : ClassDecl->hasTrivialMoveConstructorForCall()));
12694 
12695  // Note that we have declared this constructor.
12697 
12698  Scope *S = getScopeForContext(ClassDecl);
12699  CheckImplicitSpecialMemberDeclaration(S, MoveConstructor);
12700 
12701  if (ShouldDeleteSpecialMember(MoveConstructor, CXXMoveConstructor)) {
12703  SetDeclDeleted(MoveConstructor, ClassLoc);
12704  }
12705 
12706  if (S)
12707  PushOnScopeChains(MoveConstructor, S, false);
12708  ClassDecl->addDecl(MoveConstructor);
12709 
12710  return MoveConstructor;
12711 }
12712 
12714  CXXConstructorDecl *MoveConstructor) {
12715  assert((MoveConstructor->isDefaulted() &&
12716  MoveConstructor->isMoveConstructor() &&
12717  !MoveConstructor->doesThisDeclarationHaveABody() &&
12718  !MoveConstructor->isDeleted()) &&
12719  "DefineImplicitMoveConstructor - call it for implicit move ctor");
12720  if (MoveConstructor->willHaveBody() || MoveConstructor->isInvalidDecl())
12721  return;
12722 
12723  CXXRecordDecl *ClassDecl = MoveConstructor->getParent();
12724  assert(ClassDecl && "DefineImplicitMoveConstructor - invalid constructor");
12725 
12726  SynthesizedFunctionScope Scope(*this, MoveConstructor);
12727 
12728  // The exception specification is needed because we are defining the
12729  // function.
12730  ResolveExceptionSpec(CurrentLocation,
12731  MoveConstructor->getType()->castAs<FunctionProtoType>());
12732  MarkVTableUsed(CurrentLocation, ClassDecl);
12733 
12734  // Add a context note for diagnostics produced after this point.
12735  Scope.addContextNote(CurrentLocation);
12736 
12737  if (SetCtorInitializers(MoveConstructor, /*AnyErrors=*/false)) {
12738  MoveConstructor->setInvalidDecl();
12739  } else {
12740  SourceLocation Loc = MoveConstructor->getEndLoc().isValid()
12741  ? MoveConstructor->getEndLoc()
12742  : MoveConstructor->getLocation();
12743  Sema::CompoundScopeRAII CompoundScope(*this);
12744  MoveConstructor->setBody(ActOnCompoundStmt(
12745  Loc, Loc, None, /*isStmtExpr=*/ false).getAs<Stmt>());
12746  MoveConstructor->markUsed(Context);
12747  }
12748 
12749  if (ASTMutationListener *L = getASTMutationListener()) {
12750  L->CompletedImplicitDefinition(MoveConstructor);
12751  }
12752 }
12753 
12755  return FD->isDeleted() && FD->isDefaulted() && isa<CXXMethodDecl>(FD);
12756 }
12757 
12759  SourceLocation CurrentLocation,
12760  CXXConversionDecl *Conv) {
12761  SynthesizedFunctionScope Scope(*this, Conv);
12762  assert(!Conv->getReturnType()->isUndeducedType());
12763 
12764  CXXRecordDecl *Lambda = Conv->getParent();
12765  FunctionDecl *CallOp = Lambda->getLambdaCallOperator();
12766  FunctionDecl *Invoker = Lambda->getLambdaStaticInvoker();
12767 
12768  if (auto *TemplateArgs = Conv->getTemplateSpecializationArgs()) {
12769  CallOp = InstantiateFunctionDeclaration(
12770  CallOp->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
12771  if (!CallOp)
12772  return;
12773 
12774  Invoker = InstantiateFunctionDeclaration(
12775  Invoker->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
12776  if (!Invoker)
12777  return;
12778  }
12779 
12780  if (CallOp->isInvalidDecl())
12781  return;
12782 
12783  // Mark the call operator referenced (and add to pending instantiations
12784  // if necessary).
12785  // For both the conversion and static-invoker template specializations
12786  // we construct their body's in this function, so no need to add them
12787  // to the PendingInstantiations.
12788  MarkFunctionReferenced(CurrentLocation, CallOp);
12789 
12790  // Fill in the __invoke function with a dummy implementation. IR generation
12791  // will fill in the actual details. Update its type in case it contained
12792  // an 'auto'.
12793  Invoker->markUsed(Context);
12794  Invoker->setReferenced();
12795  Invoker->setType(Conv->getReturnType()->getPointeeType());
12796  Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));
12797 
12798  // Construct the body of the conversion function { return __invoke; }.
12799  Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(),
12800  VK_LValue, Conv->getLocation()).get();
12801  assert(FunctionRef && "Can't refer to __invoke function?");
12802  Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
12803  Conv->setBody(CompoundStmt::Create(Context, Return, Conv->getLocation(),
12804  Conv->getLocation()));
12805  Conv->markUsed(Context);
12806  Conv->setReferenced();
12807 
12808  if (ASTMutationListener *L = getASTMutationListener()) {
12809  L->CompletedImplicitDefinition(Conv);
12810  L->CompletedImplicitDefinition(Invoker);
12811  }
12812 }
12813 
12814 
12815 
12817  SourceLocation CurrentLocation,
12818  CXXConversionDecl *Conv)
12819 {
12820  assert(!Conv->getParent()->isGenericLambda());
12821 
12822  SynthesizedFunctionScope Scope(*this, Conv);
12823 
12824  // Copy-initialize the lambda object as needed to capture it.
12825  Expr *This = ActOnCXXThis(CurrentLocation).get();
12826  Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).get();
12827 
12828  ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation,
12829  Conv->getLocation(),
12830  Conv, DerefThis);
12831 
12832  // If we're not under ARC, make sure we still get the _Block_copy/autorelease
12833  // behavior. Note that only the general conversion function does this
12834  // (since it's unusable otherwise); in the case where we inline the
12835  // block literal, it has block literal lifetime semantics.
12836  if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
12837  BuildBlock = ImplicitCastExpr::Create(Context, BuildBlock.get()->getType(),
12838  CK_CopyAndAutoreleaseBlockObject,
12839  BuildBlock.get(), nullptr, VK_RValue);
12840 
12841  if (BuildBlock.isInvalid()) {
12842  Diag(CurrentLocation, diag::note_lambda_to_block_conv);
12843  Conv->setInvalidDecl();
12844  return;
12845  }
12846 
12847  // Create the return statement that returns the block from the conversion
12848  // function.
12849  StmtResult Return = BuildReturnStmt(Conv->getLocation(), BuildBlock.get());
12850  if (Return.isInvalid()) {
12851  Diag(CurrentLocation, diag::note_lambda_to_block_conv);
12852  Conv->setInvalidDecl();
12853  return;
12854  }
12855 
12856  // Set the body of the conversion function.
12857  Stmt *ReturnS = Return.get();
12858  Conv->setBody(CompoundStmt::Create(Context, ReturnS, Conv->getLocation(),
12859  Conv->getLocation()));
12860  Conv->markUsed(Context);
12861 
12862  // We're done; notify the mutation listener, if any.
12863  if (ASTMutationListener *L = getASTMutationListener()) {
12864  L->CompletedImplicitDefinition(Conv);
12865  }
12866 }
12867 
12868 /// Determine whether the given list arguments contains exactly one
12869 /// "real" (non-default) argument.
12871  switch (Args.size()) {
12872  case 0:
12873  return false;
12874 
12875  default:
12876  if (!Args[1]->isDefaultArgument())
12877  return false;
12878 
12879  LLVM_FALLTHROUGH;
12880  case 1:
12881  return !Args[0]->isDefaultArgument();
12882  }
12883 
12884  return false;
12885 }
12886 
12887 ExprResult
12889  NamedDecl *FoundDecl,
12890  CXXConstructorDecl *Constructor,
12891  MultiExprArg ExprArgs,
12892  bool HadMultipleCandidates,
12893  bool IsListInitialization,
12894  bool IsStdInitListInitialization,
12895  bool RequiresZeroInit,
12896  unsigned ConstructKind,
12897  SourceRange ParenRange) {
12898  bool Elidable = false;
12899 
12900  // C++0x [class.copy]p34:
12901  // When certain criteria are met, an implementation is allowed to
12902  // omit the copy/move construction of a class object, even if the
12903  // copy/move constructor and/or destructor for the object have
12904  // side effects. [...]
12905  // - when a temporary class object that has not been bound to a
12906  // reference (12.2) would be copied/moved to a class object
12907  // with the same cv-unqualified type, the copy/move operation
12908  // can be omitted by constructing the temporary object
12909  // directly into the target of the omitted copy/move
12910  if (ConstructKind == CXXConstructExpr::CK_Complete && Constructor &&
12911  Constructor->isCopyOrMoveConstructor() && hasOneRealArgument(ExprArgs)) {
12912  Expr *SubExpr = ExprArgs[0];
12913  Elidable = SubExpr->isTemporaryObject(
12914  Context, cast<CXXRecordDecl>(FoundDecl->getDeclContext()));
12915  }
12916 
12917  return BuildCXXConstructExpr(ConstructLoc, DeclInitType,
12918  FoundDecl, Constructor,
12919  Elidable, ExprArgs, HadMultipleCandidates,
12920  IsListInitialization,
12921  IsStdInitListInitialization, RequiresZeroInit,
12922  ConstructKind, ParenRange);
12923 }
12924 
12925 ExprResult
12927  NamedDecl *FoundDecl,
12928  CXXConstructorDecl *Constructor,
12929  bool Elidable,
12930  MultiExprArg ExprArgs,
12931  bool HadMultipleCandidates,
12932  bool IsListInitialization,
12933  bool IsStdInitListInitialization,
12934  bool RequiresZeroInit,
12935  unsigned ConstructKind,
12936  SourceRange ParenRange) {
12937  if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl)) {
12938  Constructor = findInheritingConstructor(ConstructLoc, Constructor, Shadow);
12939  if (DiagnoseUseOfDecl(Constructor, ConstructLoc))
12940  return ExprError();
12941  }
12942 
12943  return BuildCXXConstructExpr(
12944  ConstructLoc, DeclInitType, Constructor, Elidable, ExprArgs,
12945  HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
12946  RequiresZeroInit, ConstructKind, ParenRange);
12947 }
12948 
12949 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
12950 /// including handling of its default argument expressions.
12951 ExprResult
12953  CXXConstructorDecl *Constructor,
12954  bool Elidable,
12955  MultiExprArg ExprArgs,
12956  bool HadMultipleCandidates,
12957  bool IsListInitialization,
12958  bool IsStdInitListInitialization,
12959  bool RequiresZeroInit,
12960  unsigned ConstructKind,
12961  SourceRange ParenRange) {
12962  assert(declaresSameEntity(
12963  Constructor->getParent(),
12964  DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) &&
12965  "given constructor for wrong type");
12966  MarkFunctionReferenced(ConstructLoc, Constructor);
12967  if (getLangOpts().CUDA && !CheckCUDACall(ConstructLoc, Constructor))
12968  return ExprError();
12969 
12970  return CXXConstructExpr::Create(
12971  Context, DeclInitType, ConstructLoc, Constructor, Elidable,
12972  ExprArgs, HadMultipleCandidates, IsListInitialization,
12973  IsStdInitListInitialization, RequiresZeroInit,
12974  static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
12975  ParenRange);
12976 }
12977 
12979  assert(Field->hasInClassInitializer());
12980 
12981  // If we already have the in-class initializer nothing needs to be done.
12982  if (Field->getInClassInitializer())
12983  return CXXDefaultInitExpr::Create(Context, Loc, Field);
12984 
12985  // If we might have already tried and failed to instantiate, don't try again.
12986  if (Field->isInvalidDecl())
12987  return ExprError();
12988 
12989  // Maybe we haven't instantiated the in-class initializer. Go check the
12990  // pattern FieldDecl to see if it has one.
12991  CXXRecordDecl *ParentRD = cast<CXXRecordDecl>(Field->getParent());
12992 
12994  CXXRecordDecl *ClassPattern = ParentRD->getTemplateInstantiationPattern();
12996  ClassPattern->lookup(Field->getDeclName());
12997 
12998  // Lookup can return at most two results: the pattern for the field, or the
12999  // injected class name of the parent record. No other member can have the
13000  // same name as the field.
13001  // In modules mode, lookup can return multiple results (coming from
13002  // different modules).
13003  assert((getLangOpts().Modules || (!Lookup.empty() && Lookup.size() <= 2)) &&
13004  "more than two lookup results for field name");
13005  FieldDecl *Pattern = dyn_cast<FieldDecl>(Lookup[0]);
13006  if (!Pattern) {
13007  assert(isa<CXXRecordDecl>(Lookup[0]) &&
13008  "cannot have other non-field member with same name");
13009  for (auto L : Lookup)
13010  if (isa<FieldDecl>(L)) {
13011  Pattern = cast<FieldDecl>(L);
13012  break;
13013  }
13014  assert(Pattern && "We must have set the Pattern!");
13015  }
13016 
13017  if (!Pattern->hasInClassInitializer() ||
13018  InstantiateInClassInitializer(Loc, Field, Pattern,
13019  getTemplateInstantiationArgs(Field))) {
13020  // Don't diagnose this again.
13021  Field->setInvalidDecl();
13022  return ExprError();
13023  }
13024  return CXXDefaultInitExpr::Create(Context, Loc, Field);
13025  }
13026 
13027  // DR1351:
13028  // If the brace-or-equal-initializer of a non-static data member
13029  // invokes a defaulted default constructor of its class or of an
13030  // enclosing class in a potentially evaluated subexpression, the
13031  // program is ill-formed.
13032  //
13033  // This resolution is unworkable: the exception specification of the
13034  // default constructor can be needed in an unevaluated context, in
13035  // particular, in the operand of a noexcept-expression, and we can be
13036  // unable to compute an exception specification for an enclosed class.
13037  //
13038  // Any attempt to resolve the exception specification of a defaulted default
13039  // constructor before the initializer is lexically complete will ultimately
13040  // come here at which point we can diagnose it.
13041  RecordDecl *OutermostClass = ParentRD->getOuterLexicalRecordContext();
13042  Diag(Loc, diag::err_in_class_initializer_not_yet_parsed)
13043  << OutermostClass << Field;
13044  Diag(Field->getEndLoc(), diag::note_in_class_initializer_not_yet_parsed);
13045  // Recover by marking the field invalid, unless we're in a SFINAE context.
13046  if (!isSFINAEContext())
13047  Field->setInvalidDecl();
13048  return ExprError();
13049 }
13050 
13052  if (VD->isInvalidDecl()) return;
13053 
13054  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());
13055  if (ClassDecl->isInvalidDecl()) return;
13056  if (ClassDecl->hasIrrelevantDestructor()) return;
13057  if (ClassDecl->isDependentContext()) return;
13058 
13059  if (VD->isNoDestroy(getASTContext()))
13060  return;
13061 
13062  CXXDestructorDecl *Destructor = LookupDestructor(ClassDecl);
13063  MarkFunctionReferenced(VD->getLocation(), Destructor);
13064  CheckDestructorAccess(VD->getLocation(), Destructor,
13065  PDiag(diag::err_access_dtor_var)
13066  << VD->getDeclName()
13067  << VD->getType());
13068  DiagnoseUseOfDecl(Destructor, VD->getLocation());
13069 
13070  if (Destructor->isTrivial()) return;
13071  if (!VD->hasGlobalStorage()) return;
13072 
13073  // Emit warning for non-trivial dtor in global scope (a real global,
13074  // class-static, function-static).
13075  Diag(VD->getLocation(), diag::warn_exit_time_destructor);
13076 
13077  // TODO: this should be re-enabled for static locals by !CXAAtExit
13078  if (!VD->isStaticLocal())
13079  Diag(VD->getLocation(), diag::warn_global_destructor);
13080 }
13081 
13082 /// Given a constructor and the set of arguments provided for the
13083 /// constructor, convert the arguments and add any required default arguments
13084 /// to form a proper call to this constructor.
13085 ///
13086 /// \returns true if an error occurred, false otherwise.
13087 bool
13089  MultiExprArg ArgsPtr,
13090  SourceLocation Loc,
13091  SmallVectorImpl<Expr*> &ConvertedArgs,
13092  bool AllowExplicit,
13093  bool IsListInitialization) {
13094  // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
13095  unsigned NumArgs = ArgsPtr.size();
13096  Expr **Args = ArgsPtr.data();
13097 
13098  const FunctionProtoType *Proto
13099  = Constructor->getType()->getAs<FunctionProtoType>();
13100  assert(Proto && "Constructor without a prototype?");
13101  unsigned NumParams = Proto->getNumParams();
13102 
13103  // If too few arguments are available, we'll fill in the rest with defaults.
13104  if (NumArgs < NumParams)
13105  ConvertedArgs.reserve(NumParams);
13106  else
13107  ConvertedArgs.reserve(NumArgs);
13108 
13109  VariadicCallType CallType =
13110  Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
13111  SmallVector<Expr *, 8> AllArgs;
13112  bool Invalid = GatherArgumentsForCall(Loc, Constructor,
13113  Proto, 0,
13114  llvm::makeArrayRef(Args, NumArgs),
13115  AllArgs,
13116  CallType, AllowExplicit,
13117  IsListInitialization);
13118  ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
13119 
13120  DiagnoseSentinelCalls(Constructor, Loc, AllArgs);
13121 
13122  CheckConstructorCall(Constructor,
13123  llvm::makeArrayRef(AllArgs.data(), AllArgs.size()),
13124  Proto, Loc);
13125 
13126  return Invalid;
13127 }
13128 
13129 static inline bool
13131  const FunctionDecl *FnDecl) {
13132  const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
13133  if (isa<NamespaceDecl>(DC)) {
13134  return SemaRef.Diag(FnDecl->getLocation(),
13135  diag::err_operator_new_delete_declared_in_namespace)
13136  << FnDecl->getDeclName();
13137  }
13138 
13139  if (isa<TranslationUnitDecl>(DC) &&
13140  FnDecl->getStorageClass() == SC_Static) {
13141  return SemaRef.Diag(FnDecl->getLocation(),
13142  diag::err_operator_new_delete_declared_static)
13143  << FnDecl->getDeclName();
13144  }
13145 
13146  return false;
13147 }
13148 
13149 static QualType
13150 RemoveAddressSpaceFromPtr(Sema &SemaRef, const PointerType *PtrTy) {
13151  QualType QTy = PtrTy->getPointeeType();
13152  QTy = SemaRef.Context.removeAddrSpaceQualType(QTy);
13153  return SemaRef.Context.getPointerType(QTy);
13154 }
13155 
13156 static inline bool
13158  CanQualType ExpectedResultType,
13159  CanQualType ExpectedFirstParamType,
13160  unsigned DependentParamTypeDiag,
13161  unsigned InvalidParamTypeDiag) {
13162  QualType ResultType =
13163  FnDecl->getType()->getAs<FunctionType>()->getReturnType();
13164 
13165  // Check that the result type is not dependent.
13166  if (ResultType->isDependentType())
13167  return SemaRef.Diag(FnDecl->getLocation(),
13168  diag::err_operator_new_delete_dependent_result_type)
13169  << FnDecl->getDeclName() << ExpectedResultType;
13170 
13171  // OpenCL C++: the operator is valid on any address space.
13172  if (SemaRef.getLangOpts().OpenCLCPlusPlus) {
13173  if (auto *PtrTy = ResultType->getAs<PointerType>()) {
13174  ResultType = RemoveAddressSpaceFromPtr(SemaRef, PtrTy);
13175  }
13176  }
13177 
13178  // Check that the result type is what we expect.
13179  if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType)
13180  return SemaRef.Diag(FnDecl->getLocation(),
13181  diag::err_operator_new_delete_invalid_result_type)
13182  << FnDecl->getDeclName() << ExpectedResultType;
13183 
13184  // A function template must have at least 2 parameters.
13185  if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
13186  return SemaRef.Diag(FnDecl->getLocation(),
13187  diag::err_operator_new_delete_template_too_few_parameters)
13188  << FnDecl->getDeclName();
13189 
13190  // The function decl must have at least 1 parameter.
13191  if (FnDecl->getNumParams() == 0)
13192  return SemaRef.Diag(FnDecl->getLocation(),
13193  diag::err_operator_new_delete_too_few_parameters)
13194  << FnDecl->getDeclName();
13195 
13196  // Check the first parameter type is not dependent.
13197  QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
13198  if (FirstParamType->isDependentType())
13199  return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag)
13200  << FnDecl->getDeclName() << ExpectedFirstParamType;
13201 
13202  // Check that the first parameter type is what we expect.
13203  if (SemaRef.getLangOpts().OpenCLCPlusPlus) {
13204  // OpenCL C++: the operator is valid on any address space.
13205  if (auto *PtrTy =
13206  FnDecl->getParamDecl(0)->getType()->getAs<PointerType>()) {
13207  FirstParamType = RemoveAddressSpaceFromPtr(SemaRef, PtrTy);
13208  }
13209  }
13210  if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
13211  ExpectedFirstParamType)
13212  return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
13213  << FnDecl->getDeclName() << ExpectedFirstParamType;
13214 
13215  return false;
13216 }
13217 
13218 static bool
13220  // C++ [basic.stc.dynamic.allocation]p1:
13221  // A program is ill-formed if an allocation function is declared in a
13222  // namespace scope other than global scope or declared static in global
13223  // scope.
13224  if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
13225  return true;
13226 
13227  CanQualType SizeTy =
13228  SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType());
13229 
13230  // C++ [basic.stc.dynamic.allocation]p1:
13231  // The return type shall be void*. The first parameter shall have type
13232  // std::size_t.
13233  if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy,
13234  SizeTy,
13235  diag::err_operator_new_dependent_param_type,
13236  diag::err_operator_new_param_type))
13237  return true;
13238 
13239  // C++ [basic.stc.dynamic.allocation]p1:
13240  // The first parameter shall not have an associated default argument.
13241  if (FnDecl->getParamDecl(0)->hasDefaultArg())
13242  return SemaRef.Diag(FnDecl->getLocation(),
13243  diag::err_operator_new_default_arg)
13244  << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();
13245 
13246  return false;
13247 }
13248 
13249 static bool
13251  // C++ [basic.stc.dynamic.deallocation]p1:
13252  // A program is ill-formed if deallocation functions are declared in a
13253  // namespace scope other than global scope or declared static in global
13254  // scope.
13255  if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
13256  return true;
13257 
13258  auto *MD = dyn_cast<CXXMethodDecl>(FnDecl);
13259 
13260  // C++ P0722:
13261  // Within a class C, the first parameter of a destroying operator delete
13262  // shall be of type C *. The first parameter of any other deallocation
13263  // function shall be of type void *.
13264  CanQualType ExpectedFirstParamType =
13265  MD && MD->isDestroyingOperatorDelete()
13266  ? SemaRef.Context.getCanonicalType(SemaRef.Context.getPointerType(
13267  SemaRef.Context.getRecordType(MD->getParent())))
13268  : SemaRef.Context.VoidPtrTy;
13269 
13270  // C++ [basic.stc.dynamic.deallocation]p2:
13271  // Each deallocation function shall return void
13273  SemaRef, FnDecl, SemaRef.Context.VoidTy, ExpectedFirstParamType,
13274  diag::err_operator_delete_dependent_param_type,
13275  diag::err_operator_delete_param_type))
13276  return true;
13277 
13278  // C++ P0722:
13279  // A destroying operator delete shall be a usual deallocation function.
13280  if (MD && !MD->getParent()->isDependentContext() &&
13282  !SemaRef.isUsualDeallocationFunction(MD)) {
13283  SemaRef.Diag(MD->getLocation(),
13284  diag::err_destroying_operator_delete_not_usual);
13285  return true;
13286  }
13287 
13288  return false;
13289 }
13290 
13291 /// CheckOverloadedOperatorDeclaration - Check whether the declaration
13292 /// of this overloaded operator is well-formed. If so, returns false;
13293 /// otherwise, emits appropriate diagnostics and returns true.
13295  assert(FnDecl && FnDecl->isOverloadedOperator() &&
13296  "Expected an overloaded operator declaration");
13297 
13299 
13300  // C++ [over.oper]p5:
13301  // The allocation and deallocation functions, operator new,
13302  // operator new[], operator delete and operator delete[], are
13303  // described completely in 3.7.3. The attributes and restrictions
13304  // found in the rest of this subclause do not apply to them unless
13305  // explicitly stated in 3.7.3.
13306  if (Op == OO_Delete || Op == OO_Array_Delete)
13307  return CheckOperatorDeleteDeclaration(*this, FnDecl);
13308 
13309  if (Op == OO_New || Op == OO_Array_New)
13310  return CheckOperatorNewDeclaration(*this, FnDecl);
13311 
13312  // C++ [over.oper]p6:
13313  // An operator function shall either be a non-static member
13314  // function or be a non-member function and have at least one
13315  // parameter whose type is a class, a reference to a class, an
13316  // enumeration, or a reference to an enumeration.
13317  if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
13318  if (MethodDecl->isStatic())
13319  return Diag(FnDecl->getLocation(),
13320  diag::err_operator_overload_static) << FnDecl->getDeclName();
13321  } else {
13322  bool ClassOrEnumParam = false;
13323  for (auto Param : FnDecl->parameters()) {
13324  QualType ParamType = Param->getType().getNonReferenceType();
13325  if (ParamType->isDependentType() || ParamType->isRecordType() ||
13326  ParamType->isEnumeralType()) {
13327  ClassOrEnumParam = true;
13328  break;
13329  }
13330  }
13331 
13332  if (!ClassOrEnumParam)
13333  return Diag(FnDecl->getLocation(),
13334  diag::err_operator_overload_needs_class_or_enum)
13335  << FnDecl->getDeclName();
13336  }
13337 
13338  // C++ [over.oper]p8:
13339  // An operator function cannot have default arguments (8.3.6),
13340  // except where explicitly stated below.
13341  //
13342  // Only the function-call operator allows default arguments
13343  // (C++ [over.call]p1).
13344  if (Op != OO_Call) {
13345  for (auto Param : FnDecl->parameters()) {
13346  if (Param->hasDefaultArg())
13347  return Diag(Param->getLocation(),
13348  diag::err_operator_overload_default_arg)
13349  << FnDecl->getDeclName() << Param->getDefaultArgRange();
13350  }
13351  }
13352 
13353  static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
13354  { false, false, false }
13355 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
13356  , { Unary, Binary, MemberOnly }
13357 #include "clang/Basic/OperatorKinds.def"
13358  };
13359 
13360  bool CanBeUnaryOperator = OperatorUses[Op][0];
13361  bool CanBeBinaryOperator = OperatorUses[Op][1];
13362  bool MustBeMemberOperator = OperatorUses[Op][2];
13363 
13364  // C++ [over.oper]p8:
13365  // [...] Operator functions cannot have more or fewer parameters
13366  // than the number required for the corresponding operator, as
13367  // described in the rest of this subclause.
13368  unsigned NumParams = FnDecl->getNumParams()
13369  + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
13370  if (Op != OO_Call &&
13371  ((NumParams == 1 && !CanBeUnaryOperator) ||
13372  (NumParams == 2 && !CanBeBinaryOperator) ||
13373  (NumParams < 1) || (NumParams > 2))) {
13374  // We have the wrong number of parameters.
13375  unsigned ErrorKind;
13376  if (CanBeUnaryOperator && CanBeBinaryOperator) {
13377  ErrorKind = 2; // 2 -> unary or binary.
13378  } else if (CanBeUnaryOperator) {
13379  ErrorKind = 0; // 0 -> unary
13380  } else {
13381  assert(CanBeBinaryOperator &&
13382  "All non-call overloaded operators are unary or binary!");
13383  ErrorKind = 1; // 1 -> binary
13384  }
13385 
13386  return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
13387  << FnDecl->getDeclName() << NumParams << ErrorKind;
13388  }
13389 
13390  // Overloaded operators other than operator() cannot be variadic.
13391  if (Op != OO_Call &&
13392  FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) {
13393  return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
13394  << FnDecl->getDeclName();
13395  }
13396 
13397  // Some operators must be non-static member functions.
13398  if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
13399  return Diag(FnDecl->getLocation(),
13400  diag::err_operator_overload_must_be_member)
13401  << FnDecl->getDeclName();
13402  }
13403 
13404  // C++ [over.inc]p1:
13405  // The user-defined function called operator++ implements the
13406  // prefix and postfix ++ operator. If this function is a member
13407  // function with no parameters, or a non-member function with one
13408  // parameter of class or enumeration type, it defines the prefix
13409  // increment operator ++ for objects of that type. If the function
13410  // is a member function with one parameter (which shall be of type
13411  // int) or a non-member function with two parameters (the second
13412  // of which shall be of type int), it defines the postfix
13413  // increment operator ++ for objects of that type.
13414  if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
13415  ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
13416  QualType ParamType = LastParam->getType();
13417 
13418  if (!ParamType->isSpecificBuiltinType(BuiltinType::Int) &&
13419  !ParamType->isDependentType())
13420  return Diag(LastParam->getLocation(),
13421  diag::err_operator_overload_post_incdec_must_be_int)
13422  << LastParam->getType() << (Op == OO_MinusMinus);
13423  }
13424 
13425  return false;
13426 }
13427 
13428 static bool
13430  FunctionTemplateDecl *TpDecl) {
13431  TemplateParameterList *TemplateParams = TpDecl->getTemplateParameters();
13432 
13433  // Must have one or two template parameters.
13434  if (TemplateParams->size() == 1) {
13435  NonTypeTemplateParmDecl *PmDecl =
13436  dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(0));
13437 
13438  // The template parameter must be a char parameter pack.
13439  if (PmDecl && PmDecl->isTemplateParameterPack() &&
13440  SemaRef.Context.hasSameType(PmDecl->getType(), SemaRef.Context.CharTy))
13441  return false;
13442 
13443  } else if (TemplateParams->size() == 2) {
13444  TemplateTypeParmDecl *PmType =
13445  dyn_cast<TemplateTypeParmDecl>(TemplateParams->getParam(0));
13446  NonTypeTemplateParmDecl *PmArgs =
13447  dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(1));
13448 
13449  // The second template parameter must be a parameter pack with the
13450  // first template parameter as its type.
13451  if (PmType && PmArgs && !PmType->isTemplateParameterPack() &&
13452  PmArgs->isTemplateParameterPack()) {
13453  const TemplateTypeParmType *TArgs =
13454  PmArgs->getType()->getAs<TemplateTypeParmType>();
13455  if (TArgs && TArgs->getDepth() == PmType->getDepth() &&
13456  TArgs->getIndex() == PmType->getIndex()) {
13457  if (!SemaRef.inTemplateInstantiation())
13458  SemaRef.Diag(TpDecl->getLocation(),
13459  diag::ext_string_literal_operator_template);
13460  return false;
13461  }
13462  }
13463  }
13464 
13465  SemaRef.Diag(TpDecl->getTemplateParameters()->getSourceRange().getBegin(),
13466  diag::err_literal_operator_template)
13467  << TpDecl->getTemplateParameters()->getSourceRange();
13468  return true;
13469 }
13470 
13471 /// CheckLiteralOperatorDeclaration - Check whether the declaration
13472 /// of this literal operator function is well-formed. If so, returns
13473 /// false; otherwise, emits appropriate diagnostics and returns true.
13475  if (isa<CXXMethodDecl>(FnDecl)) {
13476  Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
13477  << FnDecl->getDeclName();
13478  return true;
13479  }
13480 
13481  if (FnDecl->isExternC()) {
13482  Diag(FnDecl->getLocation(), diag::err_literal_operator_extern_c);
13483  if (const LinkageSpecDecl *LSD =
13484  FnDecl->getDeclContext()->getExternCContext())
13485  Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
13486  return true;
13487  }
13488 
13489  // This might be the definition of a literal operator template.
13491 
13492  // This might be a specialization of a literal operator template.
13493  if (!TpDecl)
13494  TpDecl = FnDecl->getPrimaryTemplate();
13495 
13496  // template <char...> type operator "" name() and
13497  // template <class T, T...> type operator "" name() are the only valid
13498  // template signatures, and the only valid signatures with no parameters.
13499  if (TpDecl) {
13500  if (FnDecl->param_size() != 0) {
13501  Diag(FnDecl->getLocation(),
13502  diag::err_literal_operator_template_with_params);
13503  return true;
13504  }
13505 
13506  if (checkLiteralOperatorTemplateParameterList(*this, TpDecl))
13507  return true;
13508 
13509  } else if (FnDecl->param_size() == 1) {
13510  const ParmVarDecl *Param = FnDecl->getParamDecl(0);
13511 
13512  QualType ParamType = Param->getType().getUnqualifiedType();
13513 
13514  // Only unsigned long long int, long double, any character type, and const
13515  // char * are allowed as the only parameters.
13516  if (ParamType->isSpecificBuiltinType(BuiltinType::ULongLong) ||
13517  ParamType->isSpecificBuiltinType(BuiltinType::LongDouble) ||
13518  Context.hasSameType(ParamType, Context.CharTy) ||
13519  Context.hasSameType(ParamType, Context.WideCharTy) ||
13520  Context.hasSameType(ParamType, Context.Char8Ty) ||
13521  Context.hasSameType(ParamType, Context.Char16Ty) ||
13522  Context.hasSameType(ParamType, Context.Char32Ty)) {
13523  } else if (const PointerType *Ptr = ParamType->getAs<PointerType>()) {
13524  QualType InnerType = Ptr->getPointeeType();
13525 
13526  // Pointer parameter must be a const char *.
13527  if (!(Context.hasSameType(InnerType.getUnqualifiedType(),
13528  Context.CharTy) &&
13529  InnerType.isConstQualified() && !InnerType.isVolatileQualified())) {
13530  Diag(Param->getSourceRange().getBegin(),
13531  diag::err_literal_operator_param)
13532  << ParamType << "'const char *'" << Param->getSourceRange();
13533  return true;
13534  }
13535 
13536  } else if (ParamType->isRealFloatingType()) {
13537  Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
13538  << ParamType << Context.LongDoubleTy << Param->getSourceRange();
13539  return true;
13540 
13541  } else if (ParamType->isIntegerType()) {
13542  Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
13543  << ParamType << Context.UnsignedLongLongTy << Param->getSourceRange();
13544  return true;
13545 
13546  } else {
13547  Diag(Param->getSourceRange().getBegin(),
13548  diag::err_literal_operator_invalid_param)
13549  << ParamType << Param->getSourceRange();
13550  return true;
13551  }
13552 
13553  } else if (FnDecl->param_size() == 2) {
13554  FunctionDecl::param_iterator Param = FnDecl->param_begin();
13555 
13556  // First, verify that the first parameter is correct.
13557 
13558  QualType FirstParamType = (*Param)->getType().getUnqualifiedType();
13559 
13560  // Two parameter function must have a pointer to const as a
13561  // first parameter; let's strip those qualifiers.
13562  const PointerType *PT = FirstParamType->getAs<PointerType>();
13563 
13564  if (!PT) {
13565  Diag((*Param)->getSourceRange().getBegin(),
13566  diag::err_literal_operator_param)
13567  << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
13568  return true;
13569  }
13570 
13571  QualType PointeeType = PT->getPointeeType();
13572  // First parameter must be const
13573  if (!PointeeType.isConstQualified() || PointeeType.isVolatileQualified()) {
13574  Diag((*Param)->getSourceRange().getBegin(),
13575  diag::err_literal_operator_param)
13576  << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
13577  return true;
13578  }
13579 
13580  QualType InnerType = PointeeType.getUnqualifiedType();
13581  // Only const char *, const wchar_t*, const char8_t*, const char16_t*, and
13582  // const char32_t* are allowed as the first parameter to a two-parameter
13583  // function
13584  if (!(Context.hasSameType(InnerType, Context.CharTy) ||
13585  Context.hasSameType(InnerType, Context.WideCharTy) ||
13586  Context.hasSameType(InnerType, Context.Char8Ty) ||
13587  Context.hasSameType(InnerType, Context.Char16Ty) ||
13588  Context.hasSameType(InnerType, Context.Char32Ty))) {
13589  Diag((*Param)->getSourceRange().getBegin(),
13590  diag::err_literal_operator_param)
13591  << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
13592  return true;
13593  }
13594 
13595  // Move on to the second and final parameter.
13596  ++Param;
13597 
13598  // The second parameter must be a std::size_t.
13599  QualType SecondParamType = (*Param)->getType().getUnqualifiedType();
13600  if (!Context.hasSameType(SecondParamType, Context.getSizeType())) {
13601  Diag((*Param)->getSourceRange().getBegin(),
13602  diag::err_literal_operator_param)
13603  << SecondParamType << Context.getSizeType()
13604  << (*Param)->getSourceRange();
13605  return true;
13606  }
13607  } else {
13608  Diag(FnDecl->getLocation(), diag::err_literal_operator_bad_param_count);
13609  return true;
13610  }
13611 
13612  // Parameters are good.
13613 
13614  // A parameter-declaration-clause containing a default argument is not
13615  // equivalent to any of the permitted forms.
13616  for (auto Param : FnDecl->parameters()) {
13617  if (Param->hasDefaultArg()) {
13618  Diag(Param->getDefaultArgRange().getBegin(),
13619  diag::err_literal_operator_default_argument)
13620  << Param->getDefaultArgRange();
13621  break;
13622  }
13623  }
13624 
13625  StringRef LiteralName
13626  = FnDecl->getDeclName().getCXXLiteralIdentifier()->getName();
13627  if (LiteralName[0] != '_' &&
13628  !getSourceManager().isInSystemHeader(FnDecl->getLocation())) {
13629  // C++11 [usrlit.suffix]p1:
13630  // Literal suffix identifiers that do not start with an underscore
13631  // are reserved for future standardization.
13632  Diag(FnDecl->getLocation(), diag::warn_user_literal_reserved)
13633  << StringLiteralParser::isValidUDSuffix(getLangOpts(), LiteralName);
13634  }
13635 
13636  return false;
13637 }
13638 
13639 /// ActOnStartLinkageSpecification - Parsed the beginning of a C++
13640 /// linkage specification, including the language and (if present)
13641 /// the '{'. ExternLoc is the location of the 'extern', Lang is the
13642 /// language string literal. LBraceLoc, if valid, provides the location of
13643 /// the '{' brace. Otherwise, this linkage specification does not
13644 /// have any braces.
13646  Expr *LangStr,
13647  SourceLocation LBraceLoc) {
13648  StringLiteral *Lit = cast<StringLiteral>(LangStr);
13649  if (!Lit->isAscii()) {
13650  Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_not_ascii)
13651  << LangStr->getSourceRange();
13652  return nullptr;
13653  }
13654 
13655  StringRef Lang = Lit->getString();
13657  if (Lang == "C")
13658  Language = LinkageSpecDecl::lang_c;
13659  else if (Lang == "C++")
13660  Language = LinkageSpecDecl::lang_cxx;
13661  else {
13662  Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_unknown)
13663  << LangStr->getSourceRange();
13664  return nullptr;
13665  }
13666 
13667  // FIXME: Add all the various semantics of linkage specifications
13668 
13669  LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext, ExternLoc,
13670  LangStr->getExprLoc(), Language,
13671  LBraceLoc.isValid());
13672  CurContext->addDecl(D);
13673  PushDeclContext(S, D);
13674  return D;
13675 }
13676 
13677 /// ActOnFinishLinkageSpecification - Complete the definition of
13678 /// the C++ linkage specification LinkageSpec. If RBraceLoc is
13679 /// valid, it's the position of the closing '}' brace in a linkage
13680 /// specification that uses braces.
13682  Decl *LinkageSpec,
13683  SourceLocation RBraceLoc) {
13684  if (RBraceLoc.isValid()) {
13685  LinkageSpecDecl* LSDecl = cast<LinkageSpecDecl>(LinkageSpec);
13686  LSDecl->setRBraceLoc(RBraceLoc);
13687  }
13688  PopDeclContext();
13689  return LinkageSpec;
13690 }
13691 
13693  const ParsedAttributesView &AttrList,
13694  SourceLocation SemiLoc) {
13695  Decl *ED = EmptyDecl::Create(Context, CurContext, SemiLoc);
13696  // Attribute declarations appertain to empty declaration so we handle
13697  // them here.
13698  ProcessDeclAttributeList(S, ED, AttrList);
13699 
13700  CurContext->addDecl(ED);
13701  return ED;
13702 }
13703 
13704 /// Perform semantic analysis for the variable declaration that
13705 /// occurs within a C++ catch clause, returning the newly-created
13706 /// variable.
13708  TypeSourceInfo *TInfo,
13709  SourceLocation StartLoc,
13710  SourceLocation Loc,
13711  IdentifierInfo *Name) {
13712  bool Invalid = false;
13713  QualType ExDeclType = TInfo->getType();
13714 
13715  // Arrays and functions decay.
13716  if (ExDeclType->isArrayType())
13717  ExDeclType = Context.getArrayDecayedType(ExDeclType);
13718  else if (ExDeclType->isFunctionType())
13719  ExDeclType = Context.getPointerType(ExDeclType);
13720 
13721  // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
13722  // The exception-declaration shall not denote a pointer or reference to an
13723  // incomplete type, other than [cv] void*.
13724  // N2844 forbids rvalue references.
13725  if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
13726  Diag(Loc, diag::err_catch_rvalue_ref);
13727  Invalid = true;
13728  }
13729 
13730  if (ExDeclType->isVariablyModifiedType()) {
13731  Diag(Loc, diag::err_catch_variably_modified) << ExDeclType;
13732  Invalid = true;
13733  }
13734 
13735  QualType BaseType = ExDeclType;
13736  int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
13737  unsigned DK = diag::err_catch_incomplete;
13738  if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
13739  BaseType = Ptr->getPointeeType();
13740  Mode = 1;
13741  DK = diag::err_catch_incomplete_ptr;
13742  } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
13743  // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
13744  BaseType = Ref->getPointeeType();
13745  Mode = 2;
13746  DK = diag::err_catch_incomplete_ref;
13747  }
13748  if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
13749  !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
13750  Invalid = true;
13751 
13752  if (!Invalid && !ExDeclType->isDependentType() &&
13753  RequireNonAbstractType(Loc, ExDeclType,
13754  diag::err_abstract_type_in_decl,
13755  AbstractVariableType))
13756  Invalid = true;
13757 
13758  // Only the non-fragile NeXT runtime currently supports C++ catches
13759  // of ObjC types, and no runtime supports catching ObjC types by value.
13760  if (!Invalid && getLangOpts().ObjC) {
13761  QualType T = ExDeclType;
13762  if (const ReferenceType *RT = T->getAs<ReferenceType>())
13763  T = RT->getPointeeType();
13764 
13765  if (T->isObjCObjectType()) {
13766  Diag(Loc, diag::err_objc_object_catch);
13767  Invalid = true;
13768  } else if (T->isObjCObjectPointerType()) {
13769  // FIXME: should this be a test for macosx-fragile specifically?
13770  if (getLangOpts().ObjCRuntime.isFragile())
13771  Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
13772  }
13773  }
13774 
13775  VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
13776  ExDeclType, TInfo, SC_None);
13777  ExDecl->setExceptionVariable(true);
13778 
13779  // In ARC, infer 'retaining' for variables of retainable type.
13780  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(ExDecl))
13781  Invalid = true;
13782 
13783  if (!Invalid && !ExDeclType->isDependentType()) {
13784  if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) {
13785  // Insulate this from anything else we might currently be parsing.
13787  *this, ExpressionEvaluationContext::PotentiallyEvaluated);
13788 
13789  // C++ [except.handle]p16:
13790  // The object declared in an exception-declaration or, if the
13791  // exception-declaration does not specify a name, a temporary (12.2) is
13792  // copy-initialized (8.5) from the exception object. [...]
13793  // The object is destroyed when the handler exits, after the destruction
13794  // of any automatic objects initialized within the handler.
13795  //
13796  // We just pretend to initialize the object with itself, then make sure
13797  // it can be destroyed later.
13798  QualType initType = Context.getExceptionObjectType(ExDeclType);
13799 
13800  InitializedEntity entity =
13802  InitializationKind initKind =
13804 
13805  Expr *opaqueValue =
13806  new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary);
13807  InitializationSequence sequence(*this, entity, initKind, opaqueValue);
13808  ExprResult result = sequence.Perform(*this, entity, initKind, opaqueValue);
13809  if (result.isInvalid())
13810  Invalid = true;
13811  else {
13812  // If the constructor used was non-trivial, set this as the
13813  // "initializer".
13814  CXXConstructExpr *construct = result.getAs<CXXConstructExpr>();
13815  if (!construct->getConstructor()->isTrivial()) {
13816  Expr *init = MaybeCreateExprWithCleanups(construct);
13817  ExDecl->setInit(init);
13818  }
13819 
13820  // And make sure it's destructable.
13821  FinalizeVarWithDestructor(ExDecl, recordType);
13822  }
13823  }
13824  }
13825 
13826  if (Invalid)
13827  ExDecl->setInvalidDecl();
13828 
13829  return ExDecl;
13830 }
13831 
13832 /// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
13833 /// handler.
13835  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
13836  bool Invalid = D.isInvalidType();
13837 
13838  // Check for unexpanded parameter packs.
13839  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
13840  UPPC_ExceptionType)) {
13841  TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
13842  D.getIdentifierLoc());
13843  Invalid = true;
13844  }
13845 
13846  IdentifierInfo *II = D.getIdentifier();
13847  if (NamedDecl *PrevDecl = LookupSingleName(S, II, D.getIdentifierLoc(),
13848  LookupOrdinaryName,
13849  ForVisibleRedeclaration)) {
13850  // The scope should be freshly made just for us. There is just no way
13851  // it contains any previous declaration, except for function parameters in
13852  // a function-try-block's catch statement.
13853  assert(!S->isDeclScope(PrevDecl));
13854  if (isDeclInScope(PrevDecl, CurContext, S)) {
13855  Diag(D.getIdentifierLoc(), diag::err_redefinition)
13856  << D.getIdentifier();
13857  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
13858  Invalid = true;
13859  } else if (PrevDecl->isTemplateParameter())
13860  // Maybe we will complain about the shadowed template parameter.
13861  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
13862  }
13863 
13864  if (D.getCXXScopeSpec().isSet() && !Invalid) {
13865  Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
13866  << D.getCXXScopeSpec().getRange();
13867  Invalid = true;
13868  }
13869 
13870  VarDecl *ExDecl = BuildExceptionDeclaration(
13871  S, TInfo, D.getBeginLoc(), D.getIdentifierLoc(), D.getIdentifier());
13872  if (Invalid)
13873  ExDecl->setInvalidDecl();
13874 
13875  // Add the exception declaration into this scope.
13876  if (II)
13877  PushOnScopeChains(ExDecl, S);
13878  else
13879  CurContext->addDecl(ExDecl);
13880 
13881  ProcessDeclAttributes(S, ExDecl, D);
13882  return ExDecl;
13883 }
13884 
13886  Expr *AssertExpr,
13887  Expr *AssertMessageExpr,
13888  SourceLocation RParenLoc) {
13889  StringLiteral *AssertMessage =
13890  AssertMessageExpr ? cast<StringLiteral>(AssertMessageExpr) : nullptr;
13891 
13892  if (DiagnoseUnexpandedParameterPack(AssertExpr, UPPC_StaticAssertExpression))
13893  return nullptr;
13894 
13895  return BuildStaticAssertDeclaration(StaticAssertLoc, AssertExpr,
13896  AssertMessage, RParenLoc, false);
13897 }
13898 
13900  Expr *AssertExpr,
13901  StringLiteral *AssertMessage,
13902  SourceLocation RParenLoc,
13903  bool Failed) {
13904  assert(AssertExpr != nullptr && "Expected non-null condition");
13905  if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent() &&
13906  !Failed) {
13907  // In a static_assert-declaration, the constant-expression shall be a
13908  // constant expression that can be contextually converted to bool.
13909  ExprResult Converted = PerformContextuallyConvertToBool(AssertExpr);
13910  if (Converted.isInvalid())
13911  Failed = true;
13912  else
13913  Converted = ConstantExpr::Create(Context, Converted.get());
13914 
13915  llvm::APSInt Cond;
13916  if (!Failed && VerifyIntegerConstantExpression(Converted.get(), &Cond,
13917  diag::err_static_assert_expression_is_not_constant,
13918  /*AllowFold=*/false).isInvalid())
13919  Failed = true;
13920 
13921  if (!Failed && !Cond) {
13922  SmallString<256> MsgBuffer;
13923  llvm::raw_svector_ostream Msg(MsgBuffer);
13924  if (AssertMessage)
13925  AssertMessage->printPretty(Msg, nullptr, getPrintingPolicy());
13926 
13927  Expr *InnerCond = nullptr;
13928  std::string InnerCondDescription;
13929  std::tie(InnerCond, InnerCondDescription) =
13930  findFailedBooleanCondition(Converted.get());
13931  if (InnerCond && !isa<CXXBoolLiteralExpr>(InnerCond)
13932  && !isa<IntegerLiteral>(InnerCond)) {
13933  Diag(StaticAssertLoc, diag::err_static_assert_requirement_failed)
13934  << InnerCondDescription << !AssertMessage
13935  << Msg.str() << InnerCond->getSourceRange();
13936  } else {
13937  Diag(StaticAssertLoc, diag::err_static_assert_failed)
13938  << !AssertMessage << Msg.str() << AssertExpr->getSourceRange();
13939  }
13940  Failed = true;
13941  }
13942  }
13943 
13944  ExprResult FullAssertExpr = ActOnFinishFullExpr(AssertExpr, StaticAssertLoc,
13945  /*DiscardedValue*/false,
13946  /*IsConstexpr*/true);
13947  if (FullAssertExpr.isInvalid())
13948  Failed = true;
13949  else
13950  AssertExpr = FullAssertExpr.get();
13951 
13952  Decl *Decl = StaticAssertDecl::Create(Context, CurContext, StaticAssertLoc,
13953  AssertExpr, AssertMessage, RParenLoc,
13954  Failed);
13955 
13956  CurContext->addDecl(Decl);
13957  return Decl;
13958 }
13959 
13960 /// Perform semantic analysis of the given friend type declaration.
13961 ///
13962 /// \returns A friend declaration that.
13964  SourceLocation FriendLoc,
13965  TypeSourceInfo *TSInfo) {
13966  assert(TSInfo && "NULL TypeSourceInfo for friend type declaration");
13967 
13968  QualType T = TSInfo->getType();
13969  SourceRange TypeRange = TSInfo->getTypeLoc().getLocalSourceRange();
13970 
13971  // C++03 [class.friend]p2:
13972  // An elaborated-type-specifier shall be used in a friend declaration
13973  // for a class.*
13974  //
13975  // * The class-key of the elaborated-type-specifier is required.
13976  if (!CodeSynthesisContexts.empty()) {
13977  // Do not complain about the form of friend template types during any kind
13978  // of code synthesis. For template instantiation, we will have complained
13979  // when the template was defined.
13980  } else {
13981  if (!T->isElaboratedTypeSpecifier()) {
13982  // If we evaluated the type to a record type, suggest putting
13983  // a tag in front.
13984  if (const RecordType *RT = T->getAs<RecordType>()) {
13985  RecordDecl *RD = RT->getDecl();
13986 
13987  SmallString<16> InsertionText(" ");
13988  InsertionText += RD->getKindName();
13989 
13990  Diag(TypeRange.getBegin(),
13991  getLangOpts().CPlusPlus11 ?
13992  diag::warn_cxx98_compat_unelaborated_friend_type :
13993  diag::ext_unelaborated_friend_type)
13994  << (unsigned) RD->getTagKind()
13995  << T
13996  << FixItHint::CreateInsertion(getLocForEndOfToken(FriendLoc),
13997  InsertionText);
13998  } else {
13999  Diag(FriendLoc,
14000  getLangOpts().CPlusPlus11 ?
14001  diag::warn_cxx98_compat_nonclass_type_friend :
14002  diag::ext_nonclass_type_friend)
14003  << T
14004  << TypeRange;
14005  }
14006  } else if (T->getAs<EnumType>()) {
14007  Diag(FriendLoc,
14008  getLangOpts().CPlusPlus11 ?
14009  diag::warn_cxx98_compat_enum_friend :
14010  diag::ext_enum_friend)
14011  << T
14012  << TypeRange;
14013  }
14014 
14015  // C++11 [class.friend]p3:
14016  // A friend declaration that does not declare a function shall have one
14017  // of the following forms:
14018  // friend elaborated-type-specifier ;
14019  // friend simple-type-specifier ;
14020  // friend typename-specifier ;
14021  if (getLangOpts().CPlusPlus11 && LocStart != FriendLoc)
14022  Diag(FriendLoc, diag::err_friend_not_first_in_declaration) << T;
14023  }
14024 
14025  // If the type specifier in a friend declaration designates a (possibly
14026  // cv-qualified) class type, that class is declared as a friend; otherwise,
14027  // the friend declaration is ignored.
14028  return FriendDecl::Create(Context, CurContext,
14029  TSInfo->getTypeLoc().getBeginLoc(), TSInfo,
14030  FriendLoc);
14031 }
14032 
14033 /// Handle a friend tag declaration where the scope specifier was
14034 /// templated.
14036  unsigned TagSpec, SourceLocation TagLoc,
14037  CXXScopeSpec &SS, IdentifierInfo *Name,
14038  SourceLocation NameLoc,
14039  const ParsedAttributesView &Attr,
14040  MultiTemplateParamsArg TempParamLists) {
14042 
14043  bool IsMemberSpecialization = false;
14044  bool Invalid = false;
14045 
14046  if (TemplateParameterList *TemplateParams =
14047  MatchTemplateParametersToScopeSpecifier(
14048  TagLoc, NameLoc, SS, nullptr, TempParamLists, /*friend*/ true,
14049  IsMemberSpecialization, Invalid)) {
14050  if (TemplateParams->size() > 0) {
14051  // This is a declaration of a class template.
14052  if (Invalid)
14053  return nullptr;
14054 
14055  return CheckClassTemplate(S, TagSpec, TUK_Friend, TagLoc, SS, Name,
14056  NameLoc, Attr, TemplateParams, AS_public,
14057  /*ModulePrivateLoc=*/SourceLocation(),
14058  FriendLoc, TempParamLists.size() - 1,
14059  TempParamLists.data()).get();
14060  } else {
14061  // The "template<>" header is extraneous.
14062  Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
14063  << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
14064  IsMemberSpecialization = true;
14065  }
14066  }
14067 
14068  if (Invalid) return nullptr;
14069 
14070  bool isAllExplicitSpecializations = true;
14071  for (unsigned I = TempParamLists.size(); I-- > 0; ) {
14072  if (TempParamLists[I]->size()) {
14073  isAllExplicitSpecializations = false;
14074  break;
14075  }
14076  }
14077 
14078  // FIXME: don't ignore attributes.
14079 
14080  // If it's explicit specializations all the way down, just forget
14081  // about the template header and build an appropriate non-templated
14082  // friend. TODO: for source fidelity, remember the headers.
14083  if (isAllExplicitSpecializations) {
14084  if (SS.isEmpty()) {
14085  bool Owned = false;
14086  bool IsDependent = false;
14087  return ActOnTag(S, TagSpec, TUK_Friend, TagLoc, SS, Name, NameLoc,
14088  Attr, AS_public,
14089  /*ModulePrivateLoc=*/SourceLocation(),
14090  MultiTemplateParamsArg(), Owned, IsDependent,
14091  /*ScopedEnumKWLoc=*/SourceLocation(),
14092  /*ScopedEnumUsesClassTag=*/false,
14093  /*UnderlyingType=*/TypeResult(),
14094  /*IsTypeSpecifier=*/false,
14095  /*IsTemplateParamOrArg=*/false);
14096  }
14097 
14098  NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
14099  ElaboratedTypeKeyword Keyword
14101  QualType T = CheckTypenameType(Keyword, TagLoc, QualifierLoc,
14102  *Name, NameLoc);
14103  if (T.isNull())
14104  return nullptr;
14105 
14106  TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
14107  if (isa<DependentNameType>(T)) {
14110  TL.setElaboratedKeywordLoc(TagLoc);
14111  TL.setQualifierLoc(QualifierLoc);
14112  TL.setNameLoc(NameLoc);
14113  } else {
14115  TL.setElaboratedKeywordLoc(TagLoc);
14116  TL.setQualifierLoc(QualifierLoc);
14117  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(NameLoc);
14118  }
14119 
14120  FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
14121  TSI, FriendLoc, TempParamLists);
14122  Friend->setAccess(AS_public);
14123  CurContext->addDecl(Friend);
14124  return Friend;
14125  }
14126 
14127  assert(SS.isNotEmpty() && "valid templated tag with no SS and no direct?");
14128 
14129 
14130 
14131  // Handle the case of a templated-scope friend class. e.g.
14132  // template <class T> class A<T>::B;
14133  // FIXME: we don't support these right now.
14134  Diag(NameLoc, diag::warn_template_qualified_friend_unsupported)
14135  << SS.getScopeRep() << SS.getRange() << cast<CXXRecordDecl>(CurContext);
14137  QualType T = Context.getDependentNameType(ETK, SS.getScopeRep(), Name);
14138  TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
14140  TL.setElaboratedKeywordLoc(TagLoc);
14141  TL.setQualifierLoc(SS.getWithLocInContext(Context));
14142  TL.setNameLoc(NameLoc);
14143 
14144  FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
14145  TSI, FriendLoc, TempParamLists);
14146  Friend->setAccess(AS_public);
14147  Friend->setUnsupportedFriend(true);
14148  CurContext->addDecl(Friend);
14149  return Friend;
14150 }
14151 
14152 /// Handle a friend type declaration. This works in tandem with
14153 /// ActOnTag.
14154 ///
14155 /// Notes on friend class templates:
14156 ///
14157 /// We generally treat friend class declarations as if they were
14158 /// declaring a class. So, for example, the elaborated type specifier
14159 /// in a friend declaration is required to obey the restrictions of a
14160 /// class-head (i.e. no typedefs in the scope chain), template
14161 /// parameters are required to match up with simple template-ids, &c.
14162 /// However, unlike when declaring a template specialization, it's
14163 /// okay to refer to a template specialization without an empty
14164 /// template parameter declaration, e.g.
14165 /// friend class A<T>::B<unsigned>;
14166 /// We permit this as a special case; if there are any template
14167 /// parameters present at all, require proper matching, i.e.
14168 /// template <> template <class T> friend class A<int>::B;
14170  MultiTemplateParamsArg TempParams) {
14171  SourceLocation Loc = DS.getBeginLoc();
14172 
14173  assert(DS.isFriendSpecified());
14175 
14176  // C++ [class.friend]p3:
14177  // A friend declaration that does not declare a function shall have one of
14178  // the following forms:
14179  // friend elaborated-type-specifier ;
14180  // friend simple-type-specifier ;
14181  // friend typename-specifier ;
14182  //
14183  // Any declaration with a type qualifier does not have that form. (It's
14184  // legal to specify a qualified type as a friend, you just can't write the
14185  // keywords.)
14186  if (DS.getTypeQualifiers()) {
14188  Diag(DS.getConstSpecLoc(), diag::err_friend_decl_spec) << "const";
14190  Diag(DS.getVolatileSpecLoc(), diag::err_friend_decl_spec) << "volatile";
14192  Diag(DS.getRestrictSpecLoc(), diag::err_friend_decl_spec) << "restrict";
14194  Diag(DS.getAtomicSpecLoc(), diag::err_friend_decl_spec) << "_Atomic";
14196  Diag(DS.getUnalignedSpecLoc(), diag::err_friend_decl_spec) << "__unaligned";
14197  }
14198 
14199  // Try to convert the decl specifier to a type. This works for
14200  // friend templates because ActOnTag never produces a ClassTemplateDecl
14201  // for a TUK_Friend.
14202  Declarator TheDeclarator(DS, DeclaratorContext::MemberContext);
14203  TypeSourceInfo *TSI = GetTypeForDeclarator(TheDeclarator, S);
14204  QualType T = TSI->getType();
14205  if (TheDeclarator.isInvalidType())
14206  return nullptr;
14207 
14208  if (DiagnoseUnexpandedParameterPack(Loc, TSI, UPPC_FriendDeclaration))
14209  return nullptr;
14210 
14211  // This is definitely an error in C++98. It's probably meant to
14212  // be forbidden in C++0x, too, but the specification is just
14213  // poorly written.
14214  //
14215  // The problem is with declarations like the following:
14216  // template <T> friend A<T>::foo;
14217  // where deciding whether a class C is a friend or not now hinges
14218  // on whether there exists an instantiation of A that causes
14219  // 'foo' to equal C. There are restrictions on class-heads
14220  // (which we declare (by fiat) elaborated friend declarations to
14221  // be) that makes this tractable.
14222  //
14223  // FIXME: handle "template <> friend class A<T>;", which
14224  // is possibly well-formed? Who even knows?
14225  if (TempParams.size() && !T->isElaboratedTypeSpecifier()) {
14226  Diag(Loc, diag::err_tagless_friend_type_template)
14227  << DS.getSourceRange();
14228  return nullptr;
14229  }
14230 
14231  // C++98 [class.friend]p1: A friend of a class is a function
14232  // or class that is not a member of the class . . .
14233  // This is fixed in DR77, which just barely didn't make the C++03
14234  // deadline. It's also a very silly restriction that seriously
14235  // affects inner classes and which nobody else seems to implement;
14236  // thus we never diagnose it, not even in -pedantic.
14237  //
14238  // But note that we could warn about it: it's always useless to
14239  // friend one of your own members (it's not, however, worthless to
14240  // friend a member of an arbitrary specialization of your template).
14241 
14242  Decl *D;
14243  if (!TempParams.empty())
14244  D = FriendTemplateDecl::Create(Context, CurContext, Loc,
14245  TempParams,
14246  TSI,
14247  DS.getFriendSpecLoc());
14248  else
14249  D = CheckFriendTypeDecl(Loc, DS.getFriendSpecLoc(), TSI);
14250 
14251  if (!D)
14252  return nullptr;
14253 
14254  D->setAccess(AS_public);
14255  CurContext->addDecl(D);
14256 
14257  return D;
14258 }
14259 
14261  MultiTemplateParamsArg TemplateParams) {
14262  const DeclSpec &DS = D.getDeclSpec();
14263 
14264  assert(DS.isFriendSpecified());
14266 
14267  SourceLocation Loc = D.getIdentifierLoc();
14268  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
14269 
14270  // C++ [class.friend]p1
14271  // A friend of a class is a function or class....
14272  // Note that this sees through typedefs, which is intended.
14273  // It *doesn't* see through dependent types, which is correct
14274  // according to [temp.arg.type]p3:
14275  // If a declaration acquires a function type through a
14276  // type dependent on a template-parameter and this causes
14277  // a declaration that does not use the syntactic form of a
14278  // function declarator to have a function type, the program
14279  // is ill-formed.
14280  if (!TInfo->getType()->isFunctionType()) {
14281  Diag(Loc, diag::err_unexpected_friend);
14282 
14283  // It might be worthwhile to try to recover by creating an
14284  // appropriate declaration.
14285  return nullptr;
14286  }
14287 
14288  // C++ [namespace.memdef]p3
14289  // - If a friend declaration in a non-local class first declares a
14290  // class or function, the friend class or function is a member
14291  // of the innermost enclosing namespace.
14292  // - The name of the friend is not found by simple name lookup
14293  // until a matching declaration is provided in that namespace
14294  // scope (either before or after the class declaration granting
14295  // friendship).
14296  // - If a friend function is called, its name may be found by the
14297  // name lookup that considers functions from namespaces and
14298  // classes associated with the types of the function arguments.
14299  // - When looking for a prior declaration of a class or a function
14300  // declared as a friend, scopes outside the innermost enclosing
14301  // namespace scope are not considered.
14302 
14303  CXXScopeSpec &SS = D.getCXXScopeSpec();
14304  DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
14305  assert(NameInfo.getName());
14306 
14307  // Check for unexpanded parameter packs.
14308  if (DiagnoseUnexpandedParameterPack(Loc, TInfo, UPPC_FriendDeclaration) ||
14309  DiagnoseUnexpandedParameterPack(NameInfo, UPPC_FriendDeclaration) ||
14310  DiagnoseUnexpandedParameterPack(SS, UPPC_FriendDeclaration))
14311  return nullptr;
14312 
14313  // The context we found the declaration in, or in which we should
14314  // create the declaration.
14315  DeclContext *DC;
14316  Scope *DCScope = S;
14317  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
14318  ForExternalRedeclaration);
14319 
14320  // There are five cases here.
14321  // - There's no scope specifier and we're in a local class. Only look
14322  // for functions declared in the immediately-enclosing block scope.
14323  // We recover from invalid scope qualifiers as if they just weren't there.
14324  FunctionDecl *FunctionContainingLocalClass = nullptr;
14325  if ((SS.isInvalid() || !SS.isSet()) &&
14326  (FunctionContainingLocalClass =
14327  cast<CXXRecordDecl>(CurContext)->isLocalClass())) {
14328  // C++11 [class.friend]p11:
14329  // If a friend declaration appears in a local class and the name
14330  // specified is an unqualified name, a prior declaration is
14331  // looked up without considering scopes that are outside the
14332  // innermost enclosing non-class scope. For a friend function
14333  // declaration, if there is no prior declaration, the program is
14334  // ill-formed.
14335 
14336  // Find the innermost enclosing non-class scope. This is the block
14337  // scope containing the local class definition (or for a nested class,
14338  // the outer local class).
14339  DCScope = S->getFnParent();
14340 
14341  // Look up the function name in the scope.
14342  Previous.clear(LookupLocalFriendName);
14343  LookupName(Previous, S, /*AllowBuiltinCreation*/false);
14344 
14345  if (!Previous.empty()) {
14346  // All possible previous declarations must have the same context:
14347  // either they were declared at block scope or they are members of
14348  // one of the enclosing local classes.
14349  DC = Previous.getRepresentativeDecl()->getDeclContext();
14350  } else {
14351  // This is ill-formed, but provide the context that we would have
14352  // declared the function in, if we were permitted to, for error recovery.
14353  DC = FunctionContainingLocalClass;
14354  }
14355  adjustContextForLocalExternDecl(DC);
14356 
14357  // C++ [class.friend]p6:
14358  // A function can be defined in a friend declaration of a class if and
14359  // only if the class is a non-local class (9.8), the function name is
14360  // unqualified, and the function has namespace scope.
14361  if (D.isFunctionDefinition()) {
14362  Diag(NameInfo.getBeginLoc(), diag::err_friend_def_in_local_class);
14363  }
14364 
14365  // - There's no scope specifier, in which case we just go to the
14366  // appropriate scope and look for a function or function template
14367  // there as appropriate.
14368  } else if (SS.isInvalid() || !SS.isSet()) {
14369  // C++11 [namespace.memdef]p3:
14370  // If the name in a friend declaration is neither qualified nor
14371  // a template-id and the declaration is a function or an
14372  // elaborated-type-specifier, the lookup to determine whether
14373  // the entity has been previously declared shall not consider
14374  // any scopes outside the innermost enclosing namespace.
14375  bool isTemplateId =
14377 
14378  // Find the appropriate context according to the above.
14379  DC = CurContext;
14380 
14381  // Skip class contexts. If someone can cite chapter and verse
14382  // for this behavior, that would be nice --- it's what GCC and
14383  // EDG do, and it seems like a reasonable intent, but the spec
14384  // really only says that checks for unqualified existing
14385  // declarations should stop at the nearest enclosing namespace,
14386  // not that they should only consider the nearest enclosing
14387  // namespace.
14388  while (DC->isRecord())
14389  DC = DC->getParent();
14390 
14391  DeclContext *LookupDC = DC;
14392  while (LookupDC->isTransparentContext())
14393  LookupDC = LookupDC->getParent();
14394 
14395  while (true) {
14396  LookupQualifiedName(Previous, LookupDC);
14397 
14398  if (!Previous.empty()) {
14399  DC = LookupDC;
14400  break;
14401  }
14402 
14403  if (isTemplateId) {
14404  if (isa<TranslationUnitDecl>(LookupDC)) break;
14405  } else {
14406  if (LookupDC->isFileContext()) break;
14407  }
14408  LookupDC = LookupDC->getParent();
14409  }
14410 
14411  DCScope = getScopeForDeclContext(S, DC);
14412 
14413  // - There's a non-dependent scope specifier, in which case we
14414  // compute it and do a previous lookup there for a function
14415  // or function template.
14416  } else if (!SS.getScopeRep()->isDependent()) {
14417  DC = computeDeclContext(SS);
14418  if (!DC) return nullptr;
14419 
14420  if (RequireCompleteDeclContext(SS, DC)) return nullptr;
14421 
14422  LookupQualifiedName(Previous, DC);
14423 
14424  // C++ [class.friend]p1: A friend of a class is a function or
14425  // class that is not a member of the class . . .
14426  if (DC->Equals(CurContext))
14427  Diag(DS.getFriendSpecLoc(),
14428  getLangOpts().CPlusPlus11 ?
14429  diag::warn_cxx98_compat_friend_is_member :
14430  diag::err_friend_is_member);
14431 
14432  if (D.isFunctionDefinition()) {
14433  // C++ [class.friend]p6:
14434  // A function can be defined in a friend declaration of a class if and
14435  // only if the class is a non-local class (9.8), the function name is
14436  // unqualified, and the function has namespace scope.
14437  //
14438  // FIXME: We should only do this if the scope specifier names the
14439  // innermost enclosing namespace; otherwise the fixit changes the
14440  // meaning of the code.
14442  = Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def);
14443 
14444  DB << SS.getScopeRep();
14445  if (DC->isFileContext())
14446  DB << FixItHint::CreateRemoval(SS.getRange());
14447  SS.clear();
14448  }
14449 
14450  // - There's a scope specifier that does not match any template
14451  // parameter lists, in which case we use some arbitrary context,
14452  // create a method or method template, and wait for instantiation.
14453  // - There's a scope specifier that does match some template
14454  // parameter lists, which we don't handle right now.
14455  } else {
14456  if (D.isFunctionDefinition()) {
14457  // C++ [class.friend]p6:
14458  // A function can be defined in a friend declaration of a class if and
14459  // only if the class is a non-local class (9.8), the function name is
14460  // unqualified, and the function has namespace scope.
14461  Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def)
14462  << SS.getScopeRep();
14463  }
14464 
14465  DC = CurContext;
14466  assert(isa<CXXRecordDecl>(DC) && "friend declaration not in class?");
14467  }
14468 
14469  if (!DC->isRecord()) {
14470  int DiagArg = -1;
14471  switch (D.getName().getKind()) {
14474  DiagArg = 0;
14475  break;
14477  DiagArg = 1;
14478  break;
14480  DiagArg = 2;
14481  break;
14483  DiagArg = 3;
14484  break;
14490  break;
14491  }
14492  // This implies that it has to be an operator or function.
14493  if (DiagArg >= 0) {
14494  Diag(Loc, diag::err_introducing_special_friend) << DiagArg;
14495  return nullptr;
14496  }
14497  }
14498 
14499  // FIXME: This is an egregious hack to cope with cases where the scope stack
14500  // does not contain the declaration context, i.e., in an out-of-line
14501  // definition of a class.
14502  Scope FakeDCScope(S, Scope::DeclScope, Diags);
14503  if (!DCScope) {
14504  FakeDCScope.setEntity(DC);
14505  DCScope = &FakeDCScope;
14506  }
14507 
14508  bool AddToScope = true;
14509  NamedDecl *ND = ActOnFunctionDeclarator(DCScope, D, DC, TInfo, Previous,
14510  TemplateParams, AddToScope);
14511  if (!ND) return nullptr;
14512 
14513  assert(ND->getLexicalDeclContext() == CurContext);
14514 
14515  // If we performed typo correction, we might have added a scope specifier
14516  // and changed the decl context.
14517  DC = ND->getDeclContext();
14518 
14519  // Add the function declaration to the appropriate lookup tables,
14520  // adjusting the redeclarations list as necessary. We don't
14521  // want to do this yet if the friending class is dependent.
14522  //
14523  // Also update the scope-based lookup if the target context's
14524  // lookup context is in lexical scope.
14525  if (!CurContext->isDependentContext()) {
14526  DC = DC->getRedeclContext();
14527  DC->makeDeclVisibleInContext(ND);
14528  if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
14529  PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
14530  }
14531 
14532  FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
14533  D.getIdentifierLoc(), ND,
14534  DS.getFriendSpecLoc());
14535  FrD->setAccess(AS_public);
14536  CurContext->addDecl(FrD);
14537 
14538  if (ND->isInvalidDecl()) {
14539  FrD->setInvalidDecl();
14540  } else {
14541  if (DC->isRecord()) CheckFriendAccess(ND);
14542 
14543  FunctionDecl *FD;
14544  if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
14545  FD = FTD->getTemplatedDecl();
14546  else
14547  FD = cast<FunctionDecl>(ND);
14548 
14549  // C++11 [dcl.fct.default]p4: If a friend declaration specifies a
14550  // default argument expression, that declaration shall be a definition
14551  // and shall be the only declaration of the function or function
14552  // template in the translation unit.
14554  // We can't look at FD->getPreviousDecl() because it may not have been set
14555  // if we're in a dependent context. If the function is known to be a
14556  // redeclaration, we will have narrowed Previous down to the right decl.
14557  if (D.isRedeclaration()) {
14558  Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
14559  Diag(Previous.getRepresentativeDecl()->getLocation(),
14560  diag::note_previous_declaration);
14561  } else if (!D.isFunctionDefinition())
14562  Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_must_be_def);
14563  }
14564 
14565  // Mark templated-scope function declarations as unsupported.
14566  if (FD->getNumTemplateParameterLists() && SS.isValid()) {
14567  Diag(FD->getLocation(), diag::warn_template_qualified_friend_unsupported)
14568  << SS.getScopeRep() << SS.getRange()
14569  << cast<CXXRecordDecl>(CurContext);
14570  FrD->setUnsupportedFriend(true);
14571  }
14572  }
14573 
14574  return ND;
14575 }
14576 
14577 void Sema::SetDeclDeleted(Decl *Dcl, SourceLocation DelLoc) {
14578  AdjustDeclIfTemplate(Dcl);
14579 
14580  FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Dcl);
14581  if (!Fn) {
14582  Diag(DelLoc, diag::err_deleted_non_function);
14583  return;
14584  }
14585 
14586  // Deleted function does not have a body.
14587  Fn->setWillHaveBody(false);
14588 
14589  if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
14590  // Don't consider the implicit declaration we generate for explicit
14591  // specializations. FIXME: Do not generate these implicit declarations.
14592  if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization ||
14593  Prev->getPreviousDecl()) &&
14594  !Prev->isDefined()) {
14595  Diag(DelLoc, diag::err_deleted_decl_not_first);
14596  Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
14597  Prev->isImplicit() ? diag::note_previous_implicit_declaration
14598  : diag::note_previous_declaration);
14599  }
14600  // If the declaration wasn't the first, we delete the function anyway for
14601  // recovery.
14602  Fn = Fn->getCanonicalDecl();
14603  }
14604 
14605  // dllimport/dllexport cannot be deleted.
14606  if (const InheritableAttr *DLLAttr = getDLLAttr(Fn)) {
14607  Diag(Fn->getLocation(), diag::err_attribute_dll_deleted) << DLLAttr;
14608  Fn->setInvalidDecl();
14609  }
14610 
14611  if (Fn->isDeleted())
14612  return;
14613 
14614  // See if we're deleting a function which is already known to override a
14615  // non-deleted virtual function.
14616  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn)) {
14617  bool IssuedDiagnostic = false;
14618  for (const CXXMethodDecl *O : MD->overridden_methods()) {
14619  if (!(*MD->begin_overridden_methods())->isDeleted()) {
14620  if (!IssuedDiagnostic) {
14621  Diag(DelLoc, diag::err_deleted_override) << MD->getDeclName();
14622  IssuedDiagnostic = true;
14623  }
14624  Diag(O->getLocation(), diag::note_overridden_virtual_function);
14625  }
14626  }
14627  // If this function was implicitly deleted because it was defaulted,
14628  // explain why it was deleted.
14629  if (IssuedDiagnostic && MD->isDefaulted())
14630  ShouldDeleteSpecialMember(MD, getSpecialMember(MD), nullptr,
14631  /*Diagnose*/true);
14632  }
14633 
14634  // C++11 [basic.start.main]p3:
14635  // A program that defines main as deleted [...] is ill-formed.
14636  if (Fn->isMain())
14637  Diag(DelLoc, diag::err_deleted_main);
14638 
14639  // C++11 [dcl.fct.def.delete]p4:
14640  // A deleted function is implicitly inline.
14641  Fn->setImplicitlyInline();
14642  Fn->setDeletedAsWritten();
14643 }
14644 
14645 void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) {
14646  CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Dcl);
14647 
14648  if (MD) {
14649  if (MD->getParent()->isDependentType()) {
14650  MD->setDefaulted();
14651  MD->setExplicitlyDefaulted();
14652  return;
14653  }
14654 
14655  CXXSpecialMember Member = getSpecialMember(MD);
14656  if (Member == CXXInvalid) {
14657  if (!MD->isInvalidDecl())
14658  Diag(DefaultLoc, diag::err_default_special_members);
14659  return;
14660  }
14661 
14662  MD->setDefaulted();
14663  MD->setExplicitlyDefaulted();
14664 
14665  // Unset that we will have a body for this function. We might not,
14666  // if it turns out to be trivial, and we don't need this marking now
14667  // that we've marked it as defaulted.
14668  MD->setWillHaveBody(false);
14669 
14670  // If this definition appears within the record, do the checking when
14671  // the record is complete.
14672  const FunctionDecl *Primary = MD;
14673  if (const FunctionDecl *Pattern = MD->getTemplateInstantiationPattern())
14674  // Ask the template instantiation pattern that actually had the
14675  // '= default' on it.
14676  Primary = Pattern;
14677 
14678  // If the method was defaulted on its first declaration, we will have
14679  // already performed the checking in CheckCompletedCXXClass. Such a
14680  // declaration doesn't trigger an implicit definition.
14681  if (Primary->getCanonicalDecl()->isDefaulted())
14682  return;
14683 
14684  CheckExplicitlyDefaultedSpecialMember(MD);
14685 
14686  if (!MD->isInvalidDecl())
14687  DefineImplicitSpecialMember(*this, MD, DefaultLoc);
14688  } else {
14689  Diag(DefaultLoc, diag::err_default_special_members);
14690  }
14691 }
14692 
14693 static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
14694  for (Stmt *SubStmt : S->children()) {
14695  if (!SubStmt)
14696  continue;
14697  if (isa<ReturnStmt>(SubStmt))
14698  Self.Diag(SubStmt->getBeginLoc(),
14699  diag::err_return_in_constructor_handler);
14700  if (!isa<Expr>(SubStmt))
14701  SearchForReturnInStmt(Self, SubStmt);
14702  }
14703 }
14704 
14706  for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
14707  CXXCatchStmt *Handler = TryBlock->getHandler(I);
14708  SearchForReturnInStmt(*this, Handler);
14709  }
14710 }
14711 
14713  const CXXMethodDecl *Old) {
14714  const auto *NewFT = New->getType()->getAs<FunctionProtoType>();
14715  const auto *OldFT = Old->getType()->getAs<FunctionProtoType>();
14716 
14717  if (OldFT->hasExtParameterInfos()) {
14718  for (unsigned I = 0, E = OldFT->getNumParams(); I != E; ++I)
14719  // A parameter of the overriding method should be annotated with noescape
14720  // if the corresponding parameter of the overridden method is annotated.
14721  if (OldFT->getExtParameterInfo(I).isNoEscape() &&
14722  !NewFT->getExtParameterInfo(I).isNoEscape()) {
14723  Diag(New->getParamDecl(I)->getLocation(),
14724  diag::warn_overriding_method_missing_noescape);
14725  Diag(Old->getParamDecl(I)->getLocation(),
14726  diag::note_overridden_marked_noescape);
14727  }
14728  }
14729 
14730  // Virtual overrides must have the same code_seg.
14731  const auto *OldCSA = Old->getAttr<CodeSegAttr>();
14732  const auto *NewCSA = New->getAttr<CodeSegAttr>();
14733  if ((NewCSA || OldCSA) &&
14734  (!OldCSA || !NewCSA || NewCSA->getName() != OldCSA->getName())) {
14735  Diag(New->getLocation(), diag::err_mismatched_code_seg_override);
14736  Diag(Old->getLocation(), diag::note_previous_declaration);
14737  return true;
14738  }
14739 
14740  CallingConv NewCC = NewFT->getCallConv(), OldCC = OldFT->getCallConv();
14741 
14742  // If the calling conventions match, everything is fine
14743  if (NewCC == OldCC)
14744  return false;
14745 
14746  // If the calling conventions mismatch because the new function is static,
14747  // suppress the calling convention mismatch error; the error about static
14748  // function override (err_static_overrides_virtual from
14749  // Sema::CheckFunctionDeclaration) is more clear.
14750  if (New->getStorageClass() == SC_Static)
14751  return false;
14752 
14753  Diag(New->getLocation(),
14754  diag::err_conflicting_overriding_cc_attributes)
14755  << New->getDeclName() << New->getType() << Old->getType();
14756  Diag(Old->getLocation(), diag::note_overridden_virtual_function);
14757  return true;
14758 }
14759 
14761  const CXXMethodDecl *Old) {
14762  QualType NewTy = New->getType()->getAs<FunctionType>()->getReturnType();
14763  QualType OldTy = Old->getType()->getAs<FunctionType>()->getReturnType();
14764 
14765  if (Context.hasSameType(NewTy, OldTy) ||
14766  NewTy->isDependentType() || OldTy->isDependentType())
14767  return false;
14768 
14769  // Check if the return types are covariant
14770  QualType NewClassTy, OldClassTy;
14771 
14772  /// Both types must be pointers or references to classes.
14773  if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
14774  if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
14775  NewClassTy = NewPT->getPointeeType();
14776  OldClassTy = OldPT->getPointeeType();
14777  }
14778  } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
14779  if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
14780  if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
14781  NewClassTy = NewRT->getPointeeType();
14782  OldClassTy = OldRT->getPointeeType();
14783  }
14784  }
14785  }
14786 
14787  // The return types aren't either both pointers or references to a class type.
14788  if (NewClassTy.isNull()) {
14789  Diag(New->getLocation(),
14790  diag::err_different_return_type_for_overriding_virtual_function)
14791  << New->getDeclName() << NewTy << OldTy
14792  << New->getReturnTypeSourceRange();
14793  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
14794  << Old->getReturnTypeSourceRange();
14795 
14796  return true;
14797  }
14798 
14799  if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
14800  // C++14 [class.virtual]p8:
14801  // If the class type in the covariant return type of D::f differs from
14802  // that of B::f, the class type in the return type of D::f shall be
14803  // complete at the point of declaration of D::f or shall be the class
14804  // type D.
14805  if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
14806  if (!RT->isBeingDefined() &&
14807  RequireCompleteType(New->getLocation(), NewClassTy,
14808  diag::err_covariant_return_incomplete,
14809  New->getDeclName()))
14810  return true;
14811  }
14812 
14813  // Check if the new class derives from the old class.
14814  if (!IsDerivedFrom(New->getLocation(), NewClassTy, OldClassTy)) {
14815  Diag(New->getLocation(), diag::err_covariant_return_not_derived)
14816  << New->getDeclName() << NewTy << OldTy
14817  << New->getReturnTypeSourceRange();
14818  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
14819  << Old->getReturnTypeSourceRange();
14820  return true;
14821  }
14822 
14823  // Check if we the conversion from derived to base is valid.
14824  if (CheckDerivedToBaseConversion(
14825  NewClassTy, OldClassTy,
14826  diag::err_covariant_return_inaccessible_base,
14827  diag::err_covariant_return_ambiguous_derived_to_base_conv,
14828  New->getLocation(), New->getReturnTypeSourceRange(),
14829  New->getDeclName(), nullptr)) {
14830  // FIXME: this note won't trigger for delayed access control
14831  // diagnostics, and it's impossible to get an undelayed error
14832  // here from access control during the original parse because
14833  // the ParsingDeclSpec/ParsingDeclarator are still in scope.
14834  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
14835  << Old->getReturnTypeSourceRange();
14836  return true;
14837  }
14838  }
14839 
14840  // The qualifiers of the return types must be the same.
14841  if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
14842  Diag(New->getLocation(),
14843  diag::err_covariant_return_type_different_qualifications)
14844  << New->getDeclName() << NewTy << OldTy
14845  << New->getReturnTypeSourceRange();
14846  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
14847  << Old->getReturnTypeSourceRange();
14848  return true;
14849  }
14850 
14851 
14852  // The new class type must have the same or less qualifiers as the old type.
14853  if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
14854  Diag(New->getLocation(),
14855  diag::err_covariant_return_type_class_type_more_qualified)
14856  << New->getDeclName() << NewTy << OldTy
14857  << New->getReturnTypeSourceRange();
14858  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
14859  << Old->getReturnTypeSourceRange();
14860  return true;
14861  }
14862 
14863  return false;
14864 }
14865 
14866 /// Mark the given method pure.
14867 ///
14868 /// \param Method the method to be marked pure.
14869 ///
14870 /// \param InitRange the source range that covers the "0" initializer.
14872  SourceLocation EndLoc = InitRange.getEnd();
14873  if (EndLoc.isValid())
14874  Method->setRangeEnd(EndLoc);
14875 
14876  if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
14877  Method->setPure();
14878  return false;
14879  }
14880 
14881  if (!Method->isInvalidDecl())
14882  Diag(Method->getLocation(), diag::err_non_virtual_pure)
14883  << Method->getDeclName() << InitRange;
14884  return true;
14885 }
14886 
14888  if (D->getFriendObjectKind())
14889  Diag(D->getLocation(), diag::err_pure_friend);
14890  else if (auto *M = dyn_cast<CXXMethodDecl>(D))
14891  CheckPureMethod(M, ZeroLoc);
14892  else
14893  Diag(D->getLocation(), diag::err_illegal_initializer);
14894 }
14895 
14896 /// Determine whether the given declaration is a global variable or
14897 /// static data member.
14898 static bool isNonlocalVariable(const Decl *D) {
14899  if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(D))
14900  return Var->hasGlobalStorage();
14901 
14902  return false;
14903 }
14904 
14905 /// Invoked when we are about to parse an initializer for the declaration
14906 /// 'Dcl'.
14907 ///
14908 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
14909 /// static data member of class X, names should be looked up in the scope of
14910 /// class X. If the declaration had a scope specifier, a scope will have
14911 /// been created and passed in for this purpose. Otherwise, S will be null.
14913  // If there is no declaration, there was an error parsing it.
14914  if (!D || D->isInvalidDecl())
14915  return;
14916 
14917  // We will always have a nested name specifier here, but this declaration
14918  // might not be out of line if the specifier names the current namespace:
14919  // extern int n;
14920  // int ::n = 0;
14921  if (S && D->isOutOfLine())
14922  EnterDeclaratorContext(S, D->getDeclContext());
14923 
14924  // If we are parsing the initializer for a static data member, push a
14925  // new expression evaluation context that is associated with this static
14926  // data member.
14927  if (isNonlocalVariable(D))
14928  PushExpressionEvaluationContext(
14929  ExpressionEvaluationContext::PotentiallyEvaluated, D);
14930 }
14931 
14932 /// Invoked after we are finished parsing an initializer for the declaration D.
14934  // If there is no declaration, there was an error parsing it.
14935  if (!D || D->isInvalidDecl())
14936  return;
14937 
14938  if (isNonlocalVariable(D))
14939  PopExpressionEvaluationContext();
14940 
14941  if (S && D->isOutOfLine())
14942  ExitDeclaratorContext(S);
14943 }
14944 
14945 /// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
14946 /// C++ if/switch/while/for statement.
14947 /// e.g: "if (int x = f()) {...}"
14949  // C++ 6.4p2:
14950  // The declarator shall not specify a function or an array.
14951  // The type-specifier-seq shall not contain typedef and shall not declare a
14952  // new class or enumeration.
14954  "Parser allowed 'typedef' as storage class of condition decl.");
14955 
14956  Decl *Dcl = ActOnDeclarator(S, D);
14957  if (!Dcl)
14958  return true;
14959 
14960  if (isa<FunctionDecl>(Dcl)) { // The declarator shall not specify a function.
14961  Diag(Dcl->getLocation(), diag::err_invalid_use_of_function_type)
14962  << D.getSourceRange();
14963  return true;
14964  }
14965 
14966  return Dcl;
14967 }
14968 
14970  if (!ExternalSource)
14971  return;
14972 
14974  ExternalSource->ReadUsedVTables(VTables);
14975  SmallVector<VTableUse, 4> NewUses;
14976  for (unsigned I = 0, N = VTables.size(); I != N; ++I) {
14977  llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
14978  = VTablesUsed.find(VTables[I].Record);
14979  // Even if a definition wasn't required before, it may be required now.
14980  if (Pos != VTablesUsed.end()) {
14981  if (!Pos->second && VTables[I].DefinitionRequired)
14982  Pos->second = true;
14983  continue;
14984  }
14985 
14986  VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
14987  NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location));
14988  }
14989 
14990  VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end());
14991 }
14992 
14994  bool DefinitionRequired) {
14995  // Ignore any vtable uses in unevaluated operands or for classes that do
14996  // not have a vtable.
14997  if (!Class->isDynamicClass() || Class->isDependentContext() ||
14998  CurContext->isDependentContext() || isUnevaluatedContext())
14999  return;
15000  // Do not mark as used if compiling for the device outside of the target
15001  // region.
15002  if (LangOpts.OpenMP && LangOpts.OpenMPIsDevice &&
15003  !isInOpenMPDeclareTargetContext() &&
15004  !isInOpenMPTargetExecutionDirective()) {
15005  if (!DefinitionRequired)
15006  MarkVirtualMembersReferenced(Loc, Class);
15007  return;
15008  }
15009 
15010  // Try to insert this class into the map.
15011  LoadExternalVTableUses();
15012  Class = Class->getCanonicalDecl();
15013  std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator, bool>
15014  Pos = VTablesUsed.insert(std::make_pair(Class, DefinitionRequired));
15015  if (!Pos.second) {
15016  // If we already had an entry, check to see if we are promoting this vtable
15017  // to require a definition. If so, we need to reappend to the VTableUses
15018  // list, since we may have already processed the first entry.
15019  if (DefinitionRequired && !Pos.first->second) {
15020  Pos.first->second = true;
15021  } else {
15022  // Otherwise, we can early exit.
15023  return;
15024  }
15025  } else {
15026  // The Microsoft ABI requires that we perform the destructor body
15027  // checks (i.e. operator delete() lookup) when the vtable is marked used, as
15028  // the deleting destructor is emitted with the vtable, not with the
15029  // destructor definition as in the Itanium ABI.
15030  if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
15031  CXXDestructorDecl *DD = Class->getDestructor();
15032  if (DD && DD->isVirtual() && !DD->isDeleted()) {
15033  if (Class->hasUserDeclaredDestructor() && !DD->isDefined()) {
15034  // If this is an out-of-line declaration, marking it referenced will
15035  // not do anything. Manually call CheckDestructor to look up operator
15036  // delete().
15037  ContextRAII SavedContext(*this, DD);
15038  CheckDestructor(DD);
15039  } else {
15040  MarkFunctionReferenced(Loc, Class->getDestructor());
15041  }
15042  }
15043  }
15044  }
15045 
15046  // Local classes need to have their virtual members marked
15047  // immediately. For all other classes, we mark their virtual members
15048  // at the end of the translation unit.
15049  if (Class->isLocalClass())
15050  MarkVirtualMembersReferenced(Loc, Class);
15051  else
15052  VTableUses.push_back(std::make_pair(Class, Loc));
15053 }
15054 
15056  LoadExternalVTableUses();
15057  if (VTableUses.empty())
15058  return false;
15059 
15060  // Note: The VTableUses vector could grow as a result of marking
15061  // the members of a class as "used", so we check the size each
15062  // time through the loop and prefer indices (which are stable) to
15063  // iterators (which are not).
15064  bool DefinedAnything = false;
15065  for (unsigned I = 0; I != VTableUses.size(); ++I) {
15066  CXXRecordDecl *Class = VTableUses[I].first->getDefinition();
15067  if (!Class)
15068  continue;
15069  TemplateSpecializationKind ClassTSK =
15071 
15072  SourceLocation Loc = VTableUses[I].second;
15073 
15074  bool DefineVTable = true;
15075 
15076  // If this class has a key function, but that key function is
15077  // defined in another translation unit, we don't need to emit the
15078  // vtable even though we're using it.
15079  const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(Class);
15080  if (KeyFunction && !KeyFunction->hasBody()) {
15081  // The key function is in another translation unit.
15082  DefineVTable = false;
15084  KeyFunction->getTemplateSpecializationKind();
15085  assert(TSK != TSK_ExplicitInstantiationDefinition &&
15086  TSK != TSK_ImplicitInstantiation &&
15087  "Instantiations don't have key functions");
15088  (void)TSK;
15089  } else if (!KeyFunction) {
15090  // If we have a class with no key function that is the subject
15091  // of an explicit instantiation declaration, suppress the
15092  // vtable; it will live with the explicit instantiation
15093  // definition.
15094  bool IsExplicitInstantiationDeclaration =
15096  for (auto R : Class->redecls()) {
15098  = cast<CXXRecordDecl>(R)->getTemplateSpecializationKind();
15100  IsExplicitInstantiationDeclaration = true;
15101  else if (TSK == TSK_ExplicitInstantiationDefinition) {
15102  IsExplicitInstantiationDeclaration = false;
15103  break;
15104  }
15105  }
15106 
15107  if (IsExplicitInstantiationDeclaration)
15108  DefineVTable = false;
15109  }
15110 
15111  // The exception specifications for all virtual members may be needed even
15112  // if we are not providing an authoritative form of the vtable in this TU.
15113  // We may choose to emit it available_externally anyway.
15114  if (!DefineVTable) {
15115  MarkVirtualMemberExceptionSpecsNeeded(Loc, Class);
15116  continue;
15117  }
15118 
15119  // Mark all of the virtual members of this class as referenced, so
15120  // that we can build a vtable. Then, tell the AST consumer that a
15121  // vtable for this class is required.
15122  DefinedAnything = true;
15123  MarkVirtualMembersReferenced(Loc, Class);
15124  CXXRecordDecl *Canonical = Class->getCanonicalDecl();
15125  if (VTablesUsed[Canonical])
15126  Consumer.HandleVTable(Class);
15127 
15128  // Warn if we're emitting a weak vtable. The vtable will be weak if there is
15129  // no key function or the key function is inlined. Don't warn in C++ ABIs
15130  // that lack key functions, since the user won't be able to make one.
15131  if (Context.getTargetInfo().getCXXABI().hasKeyFunctions() &&
15132  Class->isExternallyVisible() && ClassTSK != TSK_ImplicitInstantiation) {
15133  const FunctionDecl *KeyFunctionDef = nullptr;
15134  if (!KeyFunction || (KeyFunction->hasBody(KeyFunctionDef) &&
15135  KeyFunctionDef->isInlined())) {
15136  Diag(Class->getLocation(),
15138  ? diag::warn_weak_template_vtable
15139  : diag::warn_weak_vtable)
15140  << Class;
15141  }
15142  }
15143  }
15144  VTableUses.clear();
15145 
15146  return DefinedAnything;
15147 }
15148 
15150  const CXXRecordDecl *RD) {
15151  for (const auto *I : RD->methods())
15152  if (I->isVirtual() && !I->isPure())
15153  ResolveExceptionSpec(Loc, I->getType()->castAs<FunctionProtoType>());
15154 }
15155 
15157  const CXXRecordDecl *RD) {
15158  // Mark all functions which will appear in RD's vtable as used.
15159  CXXFinalOverriderMap FinalOverriders;
15160  RD->getFinalOverriders(FinalOverriders);
15161  for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
15162  E = FinalOverriders.end();
15163  I != E; ++I) {
15164  for (OverridingMethods::const_iterator OI = I->second.begin(),
15165  OE = I->second.end();
15166  OI != OE; ++OI) {
15167  assert(OI->second.size() > 0 && "no final overrider");
15168  CXXMethodDecl *Overrider = OI->second.front().Method;
15169 
15170  // C++ [basic.def.odr]p2:
15171  // [...] A virtual member function is used if it is not pure. [...]
15172  if (!Overrider->isPure())
15173  MarkFunctionReferenced(Loc, Overrider);
15174  }
15175  }
15176 
15177  // Only classes that have virtual bases need a VTT.
15178  if (RD->getNumVBases() == 0)
15179  return;
15180 
15181  for (const auto &I : RD->bases()) {
15182  const CXXRecordDecl *Base =
15183  cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
15184  if (Base->getNumVBases() == 0)
15185  continue;
15186  MarkVirtualMembersReferenced(Loc, Base);
15187  }
15188 }
15189 
15190 /// SetIvarInitializers - This routine builds initialization ASTs for the
15191 /// Objective-C implementation whose ivars need be initialized.
15193  if (!getLangOpts().CPlusPlus)
15194  return;
15195  if (ObjCInterfaceDecl *OID = ObjCImplementation->getClassInterface()) {
15197  CollectIvarsToConstructOrDestruct(OID, ivars);
15198  if (ivars.empty())
15199  return;
15201  for (unsigned i = 0; i < ivars.size(); i++) {
15202  FieldDecl *Field = ivars[i];
15203  if (Field->isInvalidDecl())
15204  continue;
15205 
15206  CXXCtorInitializer *Member;
15208  InitializationKind InitKind =
15209  InitializationKind::CreateDefault(ObjCImplementation->getLocation());
15210 
15211  InitializationSequence InitSeq(*this, InitEntity, InitKind, None);
15212  ExprResult MemberInit =
15213  InitSeq.Perform(*this, InitEntity, InitKind, None);
15214  MemberInit = MaybeCreateExprWithCleanups(MemberInit);
15215  // Note, MemberInit could actually come back empty if no initialization
15216  // is required (e.g., because it would call a trivial default constructor)
15217  if (!MemberInit.get() || MemberInit.isInvalid())
15218  continue;
15219 
15220  Member =
15221  new (Context) CXXCtorInitializer(Context, Field, SourceLocation(),
15222  SourceLocation(),
15223  MemberInit.getAs<Expr>(),
15224  SourceLocation());
15225  AllToInit.push_back(Member);
15226 
15227  // Be sure that the destructor is accessible and is marked as referenced.
15228  if (const RecordType *RecordTy =
15229  Context.getBaseElementType(Field->getType())
15230  ->getAs<RecordType>()) {
15231  CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
15232  if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
15233  MarkFunctionReferenced(Field->getLocation(), Destructor);
15234  CheckDestructorAccess(Field->getLocation(), Destructor,
15235  PDiag(diag::err_access_dtor_ivar)
15236  << Context.getBaseElementType(Field->getType()));
15237  }
15238  }
15239  }
15240  ObjCImplementation->setIvarInitializers(Context,
15241  AllToInit.data(), AllToInit.size());
15242  }
15243 }
15244 
15245 static
15247  llvm::SmallPtrSet<CXXConstructorDecl*, 4> &Valid,
15248  llvm::SmallPtrSet<CXXConstructorDecl*, 4> &Invalid,
15249  llvm::SmallPtrSet<CXXConstructorDecl*, 4> &Current,
15250  Sema &S) {
15251  if (Ctor->isInvalidDecl())
15252  return;
15253 
15255 
15256  // Target may not be determinable yet, for instance if this is a dependent
15257  // call in an uninstantiated template.
15258  if (Target) {
15259  const FunctionDecl *FNTarget = nullptr;
15260  (void)Target->hasBody(FNTarget);
15261  Target = const_cast<CXXConstructorDecl*>(
15262  cast_or_null<CXXConstructorDecl>(FNTarget));
15263  }
15264 
15265  CXXConstructorDecl *Canonical = Ctor->getCanonicalDecl(),
15266  // Avoid dereferencing a null pointer here.
15267  *TCanonical = Target? Target->getCanonicalDecl() : nullptr;
15268 
15269  if (!Current.insert(Canonical).second)
15270  return;
15271 
15272  // We know that beyond here, we aren't chaining into a cycle.
15273  if (!Target || !Target->isDelegatingConstructor() ||
15274  Target->isInvalidDecl() || Valid.count(TCanonical)) {
15275  Valid.insert(Current.begin(), Current.end());
15276  Current.clear();
15277  // We've hit a cycle.
15278  } else if (TCanonical == Canonical || Invalid.count(TCanonical) ||
15279  Current.count(TCanonical)) {
15280  // If we haven't diagnosed this cycle yet, do so now.
15281  if (!Invalid.count(TCanonical)) {
15282  S.Diag((*Ctor->init_begin())->getSourceLocation(),
15283  diag::warn_delegating_ctor_cycle)
15284  << Ctor;
15285 
15286  // Don't add a note for a function delegating directly to itself.
15287  if (TCanonical != Canonical)
15288  S.Diag(Target->getLocation(), diag::note_it_delegates_to);
15289 
15291  while (C->getCanonicalDecl() != Canonical) {
15292  const FunctionDecl *FNTarget = nullptr;
15293  (void)C->getTargetConstructor()->hasBody(FNTarget);
15294  assert(FNTarget && "Ctor cycle through bodiless function");
15295 
15296  C = const_cast<CXXConstructorDecl*>(
15297  cast<CXXConstructorDecl>(FNTarget));
15298  S.Diag(C->getLocation(), diag::note_which_delegates_to);
15299  }
15300  }
15301 
15302  Invalid.insert(Current.begin(), Current.end());
15303  Current.clear();
15304  } else {
15305  DelegatingCycleHelper(Target, Valid, Invalid, Current, S);
15306  }
15307 }
15308 
15309 
15311  llvm::SmallPtrSet<CXXConstructorDecl*, 4> Valid, Invalid, Current;
15312 
15313  for (DelegatingCtorDeclsType::iterator
15314  I = DelegatingCtorDecls.begin(ExternalSource),
15315  E = DelegatingCtorDecls.end();
15316  I != E; ++I)
15317  DelegatingCycleHelper(*I, Valid, Invalid, Current, *this);
15318 
15319  for (auto CI = Invalid.begin(), CE = Invalid.end(); CI != CE; ++CI)
15320  (*CI)->setInvalidDecl();
15321 }
15322 
15323 namespace {
15324  /// AST visitor that finds references to the 'this' expression.
15325  class FindCXXThisExpr : public RecursiveASTVisitor<FindCXXThisExpr> {
15326  Sema &S;
15327 
15328  public:
15329  explicit FindCXXThisExpr(Sema &S) : S(S) { }
15330 
15331  bool VisitCXXThisExpr(CXXThisExpr *E) {
15332  S.Diag(E->getLocation(), diag::err_this_static_member_func)
15333  << E->isImplicit();
15334  return false;
15335  }
15336  };
15337 }
15338 
15340  TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
15341  if (!TSInfo)
15342  return false;
15343 
15344  TypeLoc TL = TSInfo->getTypeLoc();
15346  if (!ProtoTL)
15347  return false;
15348 
15349  // C++11 [expr.prim.general]p3:
15350  // [The expression this] shall not appear before the optional
15351  // cv-qualifier-seq and it shall not appear within the declaration of a
15352  // static member function (although its type and value category are defined
15353  // within a static member function as they are within a non-static member
15354  // function). [ Note: this is because declaration matching does not occur
15355  // until the complete declarator is known. - end note ]
15356  const FunctionProtoType *Proto = ProtoTL.getTypePtr();
15357  FindCXXThisExpr Finder(*this);
15358 
15359  // If the return type came after the cv-qualifier-seq, check it now.
15360  if (Proto->hasTrailingReturn() &&
15361  !Finder.TraverseTypeLoc(ProtoTL.getReturnLoc()))
15362  return true;
15363 
15364  // Check the exception specification.
15365  if (checkThisInStaticMemberFunctionExceptionSpec(Method))
15366  return true;
15367 
15368  return checkThisInStaticMemberFunctionAttributes(Method);
15369 }
15370 
15372  TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
15373  if (!TSInfo)
15374  return false;
15375 
15376  TypeLoc TL = TSInfo->getTypeLoc();
15378  if (!ProtoTL)
15379  return false;
15380 
15381  const FunctionProtoType *Proto = ProtoTL.getTypePtr();
15382  FindCXXThisExpr Finder(*this);
15383 
15384  switch (Proto->getExceptionSpecType()) {
15385  case EST_Unparsed:
15386  case EST_Uninstantiated:
15387  case EST_Unevaluated:
15388  case EST_BasicNoexcept:
15389  case EST_DynamicNone:
15390  case EST_MSAny:
15391  case EST_None:
15392  break;
15393 
15394  case EST_DependentNoexcept:
15395  case EST_NoexceptFalse:
15396  case EST_NoexceptTrue:
15397  if (!Finder.TraverseStmt(Proto->getNoexceptExpr()))
15398  return true;
15399  LLVM_FALLTHROUGH;
15400 
15401  case EST_Dynamic:
15402  for (const auto &E : Proto->exceptions()) {
15403  if (!Finder.TraverseType(E))
15404  return true;
15405  }
15406  break;
15407  }
15408 
15409  return false;
15410 }
15411 
15413  FindCXXThisExpr Finder(*this);
15414 
15415  // Check attributes.
15416  for (const auto *A : Method->attrs()) {
15417  // FIXME: This should be emitted by tblgen.
15418  Expr *Arg = nullptr;
15419  ArrayRef<Expr *> Args;
15420  if (const auto *G = dyn_cast<GuardedByAttr>(A))
15421  Arg = G->getArg();
15422  else if (const auto *G = dyn_cast<PtGuardedByAttr>(A))
15423  Arg = G->getArg();
15424  else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
15425  Args = llvm::makeArrayRef(AA->args_begin(), AA->args_size());
15426  else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
15427  Args = llvm::makeArrayRef(AB->args_begin(), AB->args_size());
15428  else if (const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
15429  Arg = ETLF->getSuccessValue();
15430  Args = llvm::makeArrayRef(ETLF->args_begin(), ETLF->args_size());
15431  } else if (const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
15432  Arg = STLF->getSuccessValue();
15433  Args = llvm::makeArrayRef(STLF->args_begin(), STLF->args_size());
15434  } else if (const auto *LR = dyn_cast<LockReturnedAttr>(A))
15435  Arg = LR->getArg();
15436  else if (const auto *LE = dyn_cast<LocksExcludedAttr>(A))
15437  Args = llvm::makeArrayRef(LE->args_begin(), LE->args_size());
15438  else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
15439  Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());
15440  else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
15441  Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
15442  else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
15443  Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
15444  else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
15445  Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());
15446 
15447  if (Arg && !Finder.TraverseStmt(Arg))
15448  return true;
15449 
15450  for (unsigned I = 0, N = Args.size(); I != N; ++I) {
15451  if (!Finder.TraverseStmt(Args[I]))
15452  return true;
15453  }
15454  }
15455 
15456  return false;
15457 }
15458 
15460  bool IsTopLevel, ExceptionSpecificationType EST,
15461  ArrayRef<ParsedType> DynamicExceptions,
15462  ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr,
15463  SmallVectorImpl<QualType> &Exceptions,
15465  Exceptions.clear();
15466  ESI.Type = EST;
15467  if (EST == EST_Dynamic) {
15468  Exceptions.reserve(DynamicExceptions.size());
15469  for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
15470  // FIXME: Preserve type source info.
15471  QualType ET = GetTypeFromParser(DynamicExceptions[ei]);
15472 
15473  if (IsTopLevel) {
15475  collectUnexpandedParameterPacks(ET, Unexpanded);
15476  if (!Unexpanded.empty()) {
15478  DynamicExceptionRanges[ei].getBegin(), UPPC_ExceptionType,
15479  Unexpanded);
15480  continue;
15481  }
15482  }
15483 
15484  // Check that the type is valid for an exception spec, and
15485  // drop it if not.
15486  if (!CheckSpecifiedExceptionType(ET, DynamicExceptionRanges[ei]))
15487  Exceptions.push_back(ET);
15488  }
15489  ESI.Exceptions = Exceptions;
15490  return;
15491  }
15492 
15493  if (isComputedNoexcept(EST)) {
15494  assert((NoexceptExpr->isTypeDependent() ||
15495  NoexceptExpr->getType()->getCanonicalTypeUnqualified() ==
15496  Context.BoolTy) &&
15497  "Parser should have made sure that the expression is boolean");
15498  if (IsTopLevel && DiagnoseUnexpandedParameterPack(NoexceptExpr)) {
15499  ESI.Type = EST_BasicNoexcept;
15500  return;
15501  }
15502 
15503  ESI.NoexceptExpr = NoexceptExpr;
15504  return;
15505  }
15506 }
15507 
15510  SourceRange SpecificationRange,
15511  ArrayRef<ParsedType> DynamicExceptions,
15512  ArrayRef<SourceRange> DynamicExceptionRanges,
15513  Expr *NoexceptExpr) {
15514  if (!MethodD)
15515  return;
15516 
15517  // Dig out the method we're referring to.
15518  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(MethodD))
15519  MethodD = FunTmpl->getTemplatedDecl();
15520 
15521  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(MethodD);
15522  if (!Method)
15523  return;
15524 
15525  // Check the exception specification.
15526  llvm::SmallVector<QualType, 4> Exceptions;
15528  checkExceptionSpecification(/*IsTopLevel*/true, EST, DynamicExceptions,
15529  DynamicExceptionRanges, NoexceptExpr, Exceptions,
15530  ESI);
15531 
15532  // Update the exception specification on the function type.
15533  Context.adjustExceptionSpec(Method, ESI, /*AsWritten*/true);
15534 
15535  if (Method->isStatic())
15536  checkThisInStaticMemberFunctionExceptionSpec(Method);
15537 
15538  if (Method->isVirtual()) {
15539  // Check overrides, which we previously had to delay.
15540  for (const CXXMethodDecl *O : Method->overridden_methods())
15541  CheckOverridingFunctionExceptionSpec(Method, O);
15542  }
15543 }
15544 
15545 /// HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
15546 ///
15548  SourceLocation DeclStart, Declarator &D,
15549  Expr *BitWidth,
15550  InClassInitStyle InitStyle,
15551  AccessSpecifier AS,
15552  const ParsedAttr &MSPropertyAttr) {
15553  IdentifierInfo *II = D.getIdentifier();
15554  if (!II) {
15555  Diag(DeclStart, diag::err_anonymous_property);
15556  return nullptr;
15557  }
15558  SourceLocation Loc = D.getIdentifierLoc();
15559 
15560  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
15561  QualType T = TInfo->getType();
15562  if (getLangOpts().CPlusPlus) {
15563  CheckExtraCXXDefaultArguments(D);
15564 
15565  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
15566  UPPC_DataMemberType)) {
15567  D.setInvalidType();
15568  T = Context.IntTy;
15569  TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
15570  }
15571  }
15572 
15573  DiagnoseFunctionSpecifiers(D.getDeclSpec());
15574 
15575  if (D.getDeclSpec().isInlineSpecified())
15576  Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
15577  << getLangOpts().CPlusPlus17;
15580  diag::err_invalid_thread)
15581  << DeclSpec::getSpecifierName(TSCS);
15582 
15583  // Check to see if this name was declared as a member previously
15584  NamedDecl *PrevDecl = nullptr;
15585  LookupResult Previous(*this, II, Loc, LookupMemberName,
15586  ForVisibleRedeclaration);
15587  LookupName(Previous, S);
15588  switch (Previous.getResultKind()) {
15589  case LookupResult::Found:
15591  PrevDecl = Previous.getAsSingle<NamedDecl>();
15592  break;
15593 
15595  PrevDecl = Previous.getRepresentativeDecl();
15596  break;
15597 
15601  break;
15602  }
15603 
15604  if (PrevDecl && PrevDecl->isTemplateParameter()) {
15605  // Maybe we will complain about the shadowed template parameter.
15606  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
15607  // Just pretend that we didn't see the previous declaration.
15608  PrevDecl = nullptr;
15609  }
15610 
15611  if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
15612  PrevDecl = nullptr;
15613 
15614  SourceLocation TSSL = D.getBeginLoc();
15615  MSPropertyDecl *NewPD =
15616  MSPropertyDecl::Create(Context, Record, Loc, II, T, TInfo, TSSL,
15617  MSPropertyAttr.getPropertyDataGetter(),
15618  MSPropertyAttr.getPropertyDataSetter());
15619  ProcessDeclAttributes(TUScope, NewPD, D);
15620  NewPD->setAccess(AS);
15621 
15622  if (NewPD->isInvalidDecl())
15623  Record->setInvalidDecl();
15624 
15626  NewPD->setModulePrivate();
15627 
15628  if (NewPD->isInvalidDecl() && PrevDecl) {
15629  // Don't introduce NewFD into scope; there's already something
15630  // with the same name in the same scope.
15631  } else if (II) {
15632  PushOnScopeChains(NewPD, S);
15633  } else
15634  Record->addDecl(NewPD);
15635 
15636  return NewPD;
15637 }
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:1509
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:2325
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:2584
NamespaceDecl * lookupStdExperimentalNamespace()
void setSourceOrder(int Pos)
Set the source order of this initializer.
Definition: DeclCXX.h:2439
Defines the clang::ASTContext interface.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
void ActOnFinishDelayedMemberInitializers(Decl *Record)
static CXXDefaultInitExpr * Create(const ASTContext &Ctx, SourceLocation Loc, FieldDecl *Field)
Field is the non-static data member whose default initializer is used by this expression.
Definition: ExprCXX.h:1152
VariadicCallType
Definition: Sema.h:9461
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.cpp:465
bool isCallToStdMove() const
Definition: Expr.h:2650
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1583
static void collectUnexpandedParameterPacks(Sema &S, TemplateParameterList *Params, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK)
Definition: SemaExpr.cpp:16148
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Definition: DeclCXX.h:3201
SourceLocation getBeginLoc() const
Definition: ExprCXX.h:994
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void setImplicit(bool I=true)
Definition: DeclBase.h:548
Represents a function declaration or definition.
Definition: Decl.h:1738
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.
Name lookup found a set of overloaded functions that met the criteria.
Definition: Lookup.h:64
NamespaceDecl * getStdNamespace() const
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
Definition: DeclSpec.h:2268
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:2454
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
Definition: DeclSpec.h:1265
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:1079
no exception specification
static bool checkMemberDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const CXXRecordDecl *OrigRD)
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:496
PtrTy get() const
Definition: Ownership.h:81
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2537
EvaluatedExprVisitor - This class visits &#39;Expr *&#39;s.
CanQualType VoidPtrTy
Definition: ASTContext.h:1044
QualType getPointeeType() const
Definition: Type.h:2550
A (possibly-)qualified type.
Definition: Type.h:638
ASTConsumer & Consumer
Definition: Sema.h:325
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:2101
base_class_range bases()
Definition: DeclCXX.h:823
bool isArrayType() const
Definition: Type.h:6345
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:2778
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
Definition: Decl.h:2376
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2553
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:817
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:1134
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:2902
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:1162
ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val)
Definition: SemaExpr.cpp:3197
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition: DeclSpec.h:992
static unsigned NumImplicitMoveAssignmentOperatorsDeclared
The number of implicitly-declared move assignment operators for which declarations were built...
Definition: ASTContext.h:2820
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:2179
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
bool SetTypeQual(TQ T, SourceLocation Loc)
Definition: DeclSpec.cpp:891
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:3054
bool willHaveBody() const
True if this function will eventually have a body, once it&#39;s fully parsed.
Definition: Decl.h:2221
DeclarationName getCXXConstructorName(CanQualType Ty)
Returns the name of a C++ constructor for the given Type.
static bool findTrivialSpecialMember(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM, unsigned Quals, bool ConstRHS, Sema::TrivialABIHandling TAH, CXXMethodDecl **Selected)
Perform lookup for a special member of the specified kind, and determine whether it is trivial...
static DeclAccessPair 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.
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
Definition: Decl.h:2707
const Expr * getInit(unsigned Init) const
Definition: Expr.h:4238
CanQualType Char32Ty
Definition: ASTContext.h:1024
The subobject is a base class.
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Lookup.h:246
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:2763
static unsigned NumImplicitDefaultConstructors
The number of implicitly-declared default constructors.
Definition: ASTContext.h:2788
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:168
Decl * Entity
The entity that is being synthesized.
Definition: Sema.h:7237
Expr *const * semantics_iterator
Definition: Expr.h:5370
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:962
CXXRecordDecl * getCurrentClass(Scope *S, const CXXScopeSpec *SS)
Get the class that is directly named by the current context.
Filter makeFilter()
Create a filter for this result set.
Definition: Lookup.h:671
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:4289
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3355
CXXCatchStmt * getHandler(unsigned i)
Definition: StmtCXX.h:104
IfStmt - This represents an if/then/else.
Definition: Stmt.h:1687
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:505
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program...
Definition: Decl.cpp:2760
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:955
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type...
Definition: Type.h:4059
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:2631
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2786
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1937
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:838
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1020
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:807
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2094
static unsigned NumImplicitMoveAssignmentOperators
The number of implicitly-declared move assignment operators.
Definition: ASTContext.h:2816
Decl * ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc, SourceLocation NamespcLoc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *NamespcName, const ParsedAttributesView &AttrList)
bool isAscii() const
Definition: Expr.h:1685
bool isRecordType() const
Definition: Type.h:6369
static TemplateArgumentLoc getTrivialTypeTemplateArgument(Sema &S, SourceLocation Loc, QualType T)
Expr * getBase() const
Definition: Expr.h:2772
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:643
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.
NamedDecl * BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation)
Builds a using declaration.
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:1933
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:2898
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
Definition: DeclCXX.h:1514
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1308
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
void setRangeEnd(SourceLocation E)
Definition: Decl.h:1908
bool isVariadic() const
Whether this function prototype is variadic.
Definition: Type.h:4002
bool needsOverloadResolutionForDestructor() const
Determine whether we need to eagerly declare a destructor for this class.
Definition: DeclCXX.h:1191
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToMemberFunction - Build a call to a member function.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclBase.h:410
bool isVirtual() const
Definition: DeclCXX.h:2086
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.
void setArgPassingRestrictions(ArgPassingKind Kind)
Definition: Decl.h:3727
ComparisonCategoryType Kind
The Kind of the comparison category type.
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:245
ThreadStorageClassSpecifier getTSCSpec() const
Definition: Decl.h:1029
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl, bool ConsiderCudaAttrs=true)
Opcode getOpcode() const
Definition: Expr.h:3327
StringRef P
bool isTemplateParamScope() const
isTemplateParamScope - Return true if this scope is a C++ template parameter scope.
Definition: Scope.h:376
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:828
void setPure(bool P=true)
Definition: Decl.cpp:2747
static QualType RemoveAddressSpaceFromPtr(Sema &SemaRef, const PointerType *PtrTy)
void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD)
MarkVirtualMembersReferenced - Will mark all members of the given CXXRecordDecl referenced.
bool isOverrideSpecified() const
Definition: DeclSpec.h:2517
Not a friend object.
Definition: DeclBase.h:1095
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:953
NamedDecl * getDecl() const
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:6245
void AddDecl(Decl *D)
Definition: Scope.h:287
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:4487
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined...
Definition: Decl.h:2763
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:2540
The base class of the type hierarchy.
Definition: Type.h:1407
static bool checkTrivialSubobjectCall(Sema &S, SourceLocation SubobjLoc, QualType SubType, bool ConstRHS, Sema::CXXSpecialMember CSM, TrivialSubobjectKind Kind, Sema::TrivialABIHandling TAH, bool Diagnose)
Check whether the special member selected for a given type would be trivial.
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...
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:1890
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:1148
Declaration of a variable template.
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
Represent a C++ namespace.
Definition: Decl.h:515
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:1262
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:105
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.h:1169
SourceLocation getEndLoc() const LLVM_READONLY
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:521
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclBase.h:414
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:1423
QualType withConst() const
Definition: Type.h:810
std::unique_ptr< CachedTokens > DefaultArgTokens
DefaultArgTokens - When the parameter&#39;s default argument cannot be parsed immediately (because it occ...
Definition: DeclSpec.h:1234
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:690
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:98
const NestedNameSpecifier * Specifier
A container of type source information.
Definition: Decl.h:87
Floating point control options.
Definition: LangOptions.h:307
constexpr XRayInstrMask Function
Definition: XRayInstr.h:39
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 has a definition that does not need to be instantiated.
Definition: Decl.cpp:2720
TSCS getThreadStorageClassSpec() const
Definition: DeclSpec.h:452
bool needsImplicitMoveAssignment() const
Determine whether this class should get an implicit move assignment operator or if any existing speci...
Definition: DeclCXX.h:1161
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2800
static InitializedEntity InitializeMemberFromDefaultMemberInitializer(FieldDecl *Member)
Create the initialization entity for a default member initializer.
bool hasNext() const
Definition: Lookup.h:628
Abstract base class used for diagnosing integer constant expression violations.
Definition: Sema.h:9976
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:792
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2484
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
Definition: Lookup.h:543
IdentifierInfo * getPropertyDataGetter() const
Definition: ParsedAttr.h:530
CanQualType WideCharTy
Definition: ASTContext.h:1020
bool implicitCopyAssignmentHasConstParam() const
Determine whether an implicit copy assignment operator for this type would have a parameter with a co...
Definition: DeclCXX.h:1124
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
Instantiate or parse a C++ default argument expression as necessary.
Definition: SemaExpr.cpp:4652
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
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:14632
bool needsOverloadResolutionForCopyConstructor() const
Determine whether we need to eagerly declare a defaulted copy constructor for this class...
Definition: DeclCXX.h:1008
size_t param_size() const
Definition: Decl.h:2278
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
Definition: Decl.h:2714
SourceLocation getEndLoc() const
Get the end source location.
Definition: TypeLoc.cpp:227
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:2518
QualType getElementType() const
Definition: Type.h:2847
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3169
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:2356
RAII object to handle the state changes required to synthesize a function body.
Definition: Sema.h:762
IdentifierInfo * getPropertyDataSetter() const
Definition: ParsedAttr.h:536
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:3066
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
static std::vector< ComparisonCategoryResult > getPossibleResultsForType(ComparisonCategoryType Type)
Return the list of results which are valid for the specified comparison category type.
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:2291
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:3250
static CXXConstructExpr * Create(const ASTContext &Ctx, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr *> Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, ConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Create a C++ construction expression.
Definition: ExprCXX.cpp:984
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10852
void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record)
Represents a variable declaration or definition.
Definition: Decl.h:813
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:268
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:1765
QualType getReturnType() const
Definition: Decl.h:2302
DiagnosticsEngine & Diags
Definition: Sema.h:326
Wrapper for source info for member pointers.
Definition: TypeLoc.h:1232
unsigned getNumParams() const
Definition: Type.h:3888
bool isEnumeralType() const
Definition: Type.h:6373
void finishedDefaultedOrDeletedMember(CXXMethodDecl *MD)
Indicates that the declaration of a defaulted or deleted special member function is now complete...
Definition: DeclCXX.cpp:1285
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6748
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
Definition: Decl.cpp:2621
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2177
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
Extra information about a function prototype.
Definition: Type.h:3767
bool hasInheritedDefaultArg() const
Definition: Decl.h:1676
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:1997
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:1112
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
Definition: DeclCXX.cpp:2915
The "__interface" keyword.
Definition: Type.h:5036
void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD)
Check that the C++ class annoated with "trivial_abi" satisfies all the conditions that are needed for...
RAII class that determines when any errors have occurred between the time the instance was created an...
Definition: Diagnostic.h:999
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:432
SourceLocation getFinalLoc() const
Definition: DeclSpec.h:2522
bool field_empty() const
Definition: Decl.h:3792
bool isZeroLengthBitField(const ASTContext &Ctx) const
Is this a zero-length bit-field? Such bit-fields aren&#39;t really bit-fields at all and instead act as a...
Definition: Decl.cpp:3792
bool isAmbiguous() const
Definition: Lookup.h:290
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
DeclClass * getCorrectionDeclAs() const
reference front() const
Definition: DeclBase.h:1234
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
Definition: DeclCXX.h:1363
TypeLoc getNamedTypeLoc() const
Definition: TypeLoc.h:1972
bool isInvalidDecl() const
Definition: DeclBase.h:542
Stmt * getThen()
Definition: Stmt.h:1774
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:5113
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
Definition: DeclSpec.h:609
static InitializationKind CreateDirectList(SourceLocation InitLoc)
bool isInterfaceLike() const
Definition: DeclCXX.cpp:1742
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:7169
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 hasMethodTypeQualifiers() const
Determine whether this method has qualifiers.
Definition: DeclSpec.h:1452
bool isStatic() const
Definition: DeclCXX.cpp:1872
bool hasDefinition() const
Definition: DeclCXX.h:776
static StringRef getResultString(ComparisonCategoryResult Kind)
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams)
Handle a friend type declaration.
static AccessSpecDecl * Create(ASTContext &C, AccessSpecifier AS, DeclContext *DC, SourceLocation ASLoc, SourceLocation ColonLoc)
Definition: DeclCXX.h:163
Represents a parameter to a function.
Definition: Decl.h:1550
QualType CheckComparisonCategoryType(ComparisonCategoryType Kind, SourceLocation Loc)
Lookup the specified comparison category types in the standard library, an check the VarDecls possibl...
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Definition: Type.h:877
MutableArrayRef< ParmVarDecl * >::iterator param_iterator
Definition: Decl.h:2270
Defines the clang::Expr interface and subclasses for C++ expressions.
Parse and apply any fixits to the source.
void removeDecl(Decl *D)
Removes a declaration from this context.
Definition: DeclBase.cpp:1427
noexcept(expression), value-dependent
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1952
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:507
CXXConstructorDecl * getTargetConstructor() const
When this constructor delegates to another, retrieve the target.
Definition: DeclCXX.cpp:2347
The collection of all-type qualifiers we support.
Definition: Type.h:141
bool isAnonymousStructOrUnion() const
Determines whether this field is a representative for an anonymous struct or union.
Definition: Decl.cpp:3777
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:5407
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
Definition: DeclCXX.h:1647
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:3202
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
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:270
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:57
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:2124
SourceLocation getFriendSpecLoc() const
Definition: DeclSpec.h:722
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
bool isRedeclaration() const
Definition: DeclSpec.h:2485
void ActOnMemInitializers(Decl *ConstructorDecl, SourceLocation ColonLoc, ArrayRef< CXXCtorInitializer *> MemInits, bool AnyErrors)
ActOnMemInitializers - Handle the member initializers for a constructor.
Represents a struct/union/class.
Definition: Decl.h:3593
bool hasTrivialCopyConstructorForCall() const
Definition: DeclCXX.h:1404
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:1327
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:2458
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:986
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:298
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1148
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3768
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:1024
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition: Lookup.h:74
unsigned getDepth() const
Retrieve the depth of the template parameter.
Decl * ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc, SourceLocation NamespaceLoc, SourceLocation IdentLoc, IdentifierInfo *Ident, SourceLocation LBrace, const ParsedAttributesView &AttrList, UsingDirectiveDecl *&UsingDecl)
ActOnStartNamespaceDef - This is called at the start of a namespace definition.
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:2774
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:970
void setUninstantiatedDefaultArg(Expr *arg)
Definition: Decl.cpp:2610
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:155
static unsigned NumImplicitMoveConstructorsDeclared
The number of implicitly-declared move constructors for which declarations were built.
Definition: ASTContext.h:2806
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:576
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7519
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3895
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1187
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:515
TypeSourceInfo * getTypeSourceInfo() const
Definition: TemplateBase.h:507
ImplicitInitializerKind
ImplicitInitializerKind - How an implicit base or member initializer should initialize its base or me...
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:1386
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3774
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.
field_range fields() const
Definition: Decl.h:3784
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
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:288
NameKind getNameKind() const
Determine what kind of name this is.
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:981
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...
Represents a member of a struct/union/class.
Definition: Decl.h:2579
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
TypeSourceInfo * getTypeSourceInfo() const
Returns the declarator information for a base class or delegating initializer.
Definition: DeclCXX.h:2386
void removeConst()
Definition: Type.h:260
bool isAbstractType(SourceLocation Loc, QualType T)
static bool isIncrementDecrementOp(Opcode Op)
Definition: Expr.h:1969
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Lookup.h:231
bool isFunctionDefinition() const
Definition: DeclSpec.h:2462
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2127
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.h:2890
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
bool isReferenceType() const
Definition: Type.h:6308
CXXRecordDecl * getStdBadAlloc() const
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class.copy]p25)
Definition: DeclCXX.h:1463
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2002
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Definition: DeclCXX.h:2679
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:2812
static void extendLeft(SourceRange &R, SourceRange Before)
bool hasUserDeclaredDestructor() const
Determine whether this class has a user-declared destructor.
Definition: DeclCXX.h:1179
DeclarationName getCXXDestructorName(CanQualType Ty)
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:406
ParmVarDecl * getParam(unsigned i) const
Definition: TypeLoc.h:1408
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:6511
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1872
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:2633
LookupResultKind getResultKind() const
Definition: Lookup.h:310
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:2293
Expr * getSubExpr()
Definition: Expr.h:3055
Represents an access specifier followed by colon &#39;:&#39;.
Definition: DeclCXX.h:132
void ClearStorageClassSpecs()
Definition: DeclSpec.h:465
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:739
void addShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:2711
ComparisonCategoryResult
An enumeration representing the possible results of a three-way comparison.
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:56
A user-defined literal name, e.g., operator "" _i.
IdentifierTable & Idents
Definition: ASTContext.h:566
SpecialMemberOverloadResult - The overloading result for a special member function.
Definition: Sema.h:1063
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
Definition: SemaExpr.cpp:100
void setImplicitCopyConstructorIsDeleted()
Set that we attempted to declare an implicit copy constructor, but overload resolution failed so we d...
Definition: DeclCXX.h:1061
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:110
bool isInvalidType() const
Definition: DeclSpec.h:2443
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2262
UnsupportedSTLSelect
DeclClass * getAsSingle() const
Definition: Lookup.h:496
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:2521
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr *> Exprs, SourceLocation RParenLoc)
Create a paren list.
Definition: Expr.cpp:4051
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:978
Describes an C or C++ initializer list.
Definition: Expr.h:4190
Represents a C++ using-declaration.
Definition: DeclCXX.h:3352
The argument of this type can be passed directly in registers.
Definition: Decl.h:3604
ArrayRef< BindingDecl * > bindings() const
Definition: DeclCXX.h:3875
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:934
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2738
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1654
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
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:469
NamespaceDecl * getOrCreateStdNamespace()
Retrieve the special "std" namespace, which may require us to implicitly define the namespace...
static void ReferenceDllExportedMembers(Sema &S, CXXRecordDecl *Class)
Represents the results of name lookup.
Definition: Lookup.h:47
PtrTy get() const
Definition: Ownership.h:174
bool isDelegatingConstructor() const
Determine whether this constructor is a delegating constructor.
Definition: DeclCXX.h:2594
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:3243
Microsoft throw(...) extension.
A convenient class for passing around template argument information.
Definition: TemplateBase.h:555
void setParamDestroyedInCallee(bool V)
Definition: Decl.h:3735
AccessSpecifier getAccessSpecifier() const
Returns the access specifier for this base specifier.
Definition: DeclCXX.h:272
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2205
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:1118
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:3354
bool CheckConstexprFunctionDecl(const FunctionDecl *FD)
void DefineInheritingConstructor(SourceLocation UseLoc, CXXConstructorDecl *Constructor)
Define the specified inheriting constructor.
ArrayRef< NamedDecl * > chain() const
Definition: Decl.h:2847
An x-value expression is a reference to an object with independent storage but which can be "moved"...
Definition: Specifiers.h:119
A friend of a previously-undeclared entity.
Definition: DeclBase.h:1097
bool hasNonTrivialDestructorForCall() const
Definition: DeclCXX.h:1492
child_range children()
Definition: Stmt.cpp:237
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:2175
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:15753
StmtResult StmtError()
Definition: Ownership.h:284
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:654
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1831
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:5378
void ActOnBaseSpecifiers(Decl *ClassDecl, MutableArrayRef< CXXBaseSpecifier *> Bases)
ActOnBaseSpecifiers - Attach the given base specifiers to the class, after checking whether there are...
Represents a declaration of a type.
Definition: Decl.h:2874
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3292
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:6142
LangAS getAddressSpace() const
Definition: Type.h:352
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
Definition: Sema.h:7234
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt *> Stmts, SourceLocation LB, SourceLocation RB)
Definition: Stmt.cpp:332
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...
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
Definition: Ownership.h:281
bool isRValueReferenceType() const
Definition: Type.h:6316
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:119
child_range children()
Definition: Expr.h:4373
void setExceptionVariable(bool EV)
Definition: Decl.h:1310
The argument of this type cannot be passed directly in registers.
Definition: Decl.h:3618
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1382
ActionResult< ParsedType > TypeResult
Definition: Ownership.h:269
DeclContextLookupResult slice(size_t N) const
Definition: DeclBase.h:1239
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1196
CanQualType LongDoubleTy
Definition: ASTContext.h:1028
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:41
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:7284
bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6072
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:728
field_iterator field_begin() const
Definition: Decl.cpp:4145
param_type_iterator param_type_begin() const
Definition: Type.h:4034
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1158
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
Definition: Decl.h:1660
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:2027
ExprResult ActOnCXXThis(SourceLocation loc)
bool isAnyMemberInitializer() const
Definition: DeclCXX.h:2333
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:2792
void setNumCtorInitializers(unsigned numCtorInitializers)
Definition: DeclCXX.h:2575
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:821
FieldDecl * getAnyMember() const
Definition: DeclCXX.h:2398
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1649
Preprocessor & PP
Definition: Sema.h:323
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1478
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1918
const LangOptions & getLangOpts() const
Definition: Sema.h:1231
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
Definition: DeclCXX.cpp:2639
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:792
TemplateArgumentLoc getArgLoc(unsigned i) const
Definition: TypeLoc.h:1592
void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don&#39;t have one.
bool isInstance() const
Definition: DeclCXX.h:2069
SourceLocation getConstSpecLoc() const
Definition: DeclSpec.h:548
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:1869
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 ...
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:126
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:1697
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:1172
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
Definition: DeclCXX.h:2392
Represents a linkage specification.
Definition: DeclCXX.h:2826
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)
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Lookup.h:415
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:3062
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:1392
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:507
bool isAbstract() const
Determine whether this class has a pure virtual function.
Definition: DeclCXX.h:1344
void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc, Decl *TagDecl, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
Definition: SemaExpr.cpp:2784
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
Definition: CanonicalType.h:84
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.cpp:325
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:3753
void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init)
Check that the lifetime of the initializer (and its subobjects) is sufficient for initializing the en...
Definition: SemaInit.cpp:6918
A binding in a decomposition declaration.
Definition: DeclCXX.h:3795
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
Qualifiers getTypeQuals() const
Definition: Type.h:4015
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:143
bool hasConst() const
Definition: Type.h:258
init_iterator init_begin()
Retrieve an iterator to the first initializer.
Definition: DeclCXX.h:2533
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:2127
void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var)
Mark a variable referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3).
Definition: SemaExpr.cpp:15714
Ordinary names.
Definition: DeclBase.h:145
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:870
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)
ArgPassingKind getArgPassingRestrictions() const
Definition: Decl.h:3723
bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM, TrivialABIHandling TAH=TAH_IgnoreTrivialABI, bool Diagnose=false)
Determine whether a defaulted or deleted special member function is trivial, as specified in C++11 [c...
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
Definition: Decl.h:3666
param_iterator param_begin()
Definition: Decl.h:2274
Represents the this expression in C++.
Definition: ExprCXX.h:976
UsingShadowDecl * BuildUsingShadowDecl(Scope *S, UsingDecl *UD, NamedDecl *Target, UsingShadowDecl *PrevDecl)
Builds a shadow declaration corresponding to a &#39;using&#39; declaration.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprCXX.h:1857
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:1595
Class that aids in the construction of nested-name-specifiers along with source-location information ...
ExtInfo withCallingConv(CallingConv cc) const
Definition: Type.h:3571
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()
Remove the C++11 in-class initializer from this member.
Definition: Decl.h:2740
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3455
static bool canPassInRegisters(Sema &S, CXXRecordDecl *D, TargetInfo::CallingConvKind CCK)
Determine whether a type is permitted to be passed or returned in registers, per C++ [class...
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1235
static bool checkArrayDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const ConstantArrayType *CAT)
bool isFinalSpecified() const
Definition: DeclSpec.h:2520
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:1167
NodeId Parent
Definition: ASTDiff.cpp:192
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:218
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:185
bool isDeclspecPropertyAttribute() const
Is this the Microsoft __declspec(property) attribute?
Definition: ParsedAttr.h:394
bool hasAttr() const
Definition: DeclBase.h:531
CXXConstructorDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2684
bool hasUserProvidedDefaultConstructor() const
Whether this class has a user-provided default constructor per C++11.
Definition: DeclCXX.h:989
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3587
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1861
bool isTriviallyCopyable() const
Determine whether this class is considered trivially copyable per (C++11 [class]p6).
Definition: DeclCXX.cpp:533
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:278
StringRef getString() const
Definition: Expr.h:1649
enum clang::DeclaratorChunk::@215 Kind
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3038
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1241
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1613
SourceLocation getUnalignedSpecLoc() const
Definition: DeclSpec.h:552
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3687
virtual CallingConvKind getCallingConvKind(bool ClangABICompat4) const
Definition: TargetInfo.cpp:399
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:789
void ClearConstexprSpec()
Definition: DeclSpec.h:730
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
Definition: Decl.h:2351
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:12259
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:1137
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:3300
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1334
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:2795
bool isDeclarationOfFunction() const
Determine whether the declaration that will be produced from this declaration will be a function...
Definition: DeclSpec.cpp:313
A RAII object to enter scope of a compound statement.
Definition: Sema.h:3713
bool isMoreQualifiedThan(QualType Other) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
Definition: Type.h:6216
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:1627
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:689
SourceRange getLocalSourceRange() const
Get the local source range.
Definition: TypeLoc.h:157
static StringRef getCategoryString(ComparisonCategoryType Kind)
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:2353
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1844
DeclSpec * MethodQualifiers
DeclSpec for the function with the qualifier related info.
Definition: DeclSpec.h:1316
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:569
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1288
llvm::FoldingSet< SpecialMemberOverloadResultEntry > SpecialMemberCache
A cache of special member function overload resolution results for C++ records.
Definition: Sema.h:1097
bool hasTrivialMoveConstructorForCall() const
Definition: DeclCXX.h:1428
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:6147
void NoteHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl< CXXMethodDecl *> &OverloadedMethods)
bool mayHaveDecompositionDeclarator() const
Return true if the context permits a C++17 decomposition declarator.
Definition: DeclSpec.h:2012
static EmptyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
Definition: Decl.cpp:4616
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:1367
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:2833
bool isLiteral() const
Determine whether this class is a literal type.
Definition: DeclCXX.h:1566
void setInClassInitializer(Expr *Init)
Set the C++11 in-class initializer for this member.
Definition: Decl.h:2731
const CXXRecordDecl * getParent() const
Returns the parent of this using shadow declaration, which is the class in which this is declared...
Definition: DeclCXX.h:3296
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:483
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclCXX.h:236
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:227
bool hasInheritedConstructor() const
Determine whether this class has a using-declaration that names a user-declared base class constructo...
Definition: DeclCXX.h:1526
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:3101
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isInline, bool isImplicitlyDeclared)
Definition: DeclCXX.cpp:2465
llvm::PointerIntPair< CXXRecordDecl *, 3, CXXSpecialMember > SpecialMemberDecl
Definition: Sema.h:1178
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:4162
bool isUsualDeallocationFunction(const CXXMethodDecl *FD)
void setTrivialForCall(bool IT)
Definition: Decl.h:2030
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:2490
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:2342
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3240
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition: Decl.h:3220
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:637
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:2376
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3392
StringRef getKindName() const
Definition: Decl.h:3239
QualType getPointeeType() const
Definition: Type.h:2694
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:107
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2689
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2034
llvm::StringRef getAsString(SyncScope S)
Definition: SyncScope.h:51
bool isDeclScope(Decl *D)
isDeclScope - Return true if this is the scope that the specified decl is declared in...
Definition: Scope.h:321
Helper class that collects exception specifications for implicitly-declared special member functions...
Definition: Sema.h:4749
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:2123
void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath)
StateNode * Previous
Declaration of a template type parameter.
unsigned getIndex() const
Definition: Type.h:4566
DeclContext * getEntity() const
Definition: Scope.h:325
bool defaultedMoveConstructorIsDeleted() const
true if a defaulted move constructor for this class would be deleted.
Definition: DeclCXX.h:921
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:3399
void setHideTags(bool Hide)
Sets whether tag declarations should be hidden by non-tag declarations during resolution.
Definition: Lookup.h:286
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:6811
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:5050
void getFinalOverriders(CXXFinalOverriderMap &FinaOverriders) const
Retrieve the final overriders for each virtual member function in the class hierarchy where this clas...
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
void setRBraceLoc(SourceLocation L)
Definition: Decl.h:621
Inits[]
Definition: OpenMPClause.h:151
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:105
static UnresolvedUsingValueDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, SourceLocation EllipsisLoc)
Definition: DeclCXX.cpp:2784
SourceLocation getLocation() const
Definition: ExprCXX.h:991
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:87
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2706
void freeParams()
Reset the parameter list to having zero parameters.
Definition: DeclSpec.h:1348
void setInit(Expr *I)
Definition: Decl.cpp:2205
Expr * getCallee()
Definition: Expr.h:2514
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
std::string getAsString() const
Retrieve the human-readable string for this name.
unsigned getNumInits() const
Definition: Expr.h:4220
static unsigned NumImplicitMoveConstructors
The number of implicitly-declared move constructors.
Definition: ASTContext.h:2802
AccessResult CheckStructuredBindingMemberAccess(SourceLocation UseLoc, CXXRecordDecl *DecomposedClass, DeclAccessPair Field)
Checks implicit access to a member in a structured binding.
SourceLocation getVolatileSpecLoc() const
Definition: DeclSpec.h:550
SourceLocation getThreadStorageClassSpecLoc() const
Definition: DeclSpec.h:461
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:547
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
Definition: DeclCXX.cpp:1652
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3475
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir)
void setRBraceLoc(SourceLocation L)
Definition: DeclCXX.h:2877
Defines the clang::Preprocessor interface.
bool CheckInheritingConstructorUsingDecl(UsingDecl *UD)
Additional checks for a using declaration referring to a constructor name.
bool hasUserDeclaredMoveAssignment() const
Determine whether this class has had a move assignment declared by the user.
Definition: DeclCXX.h:1139
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:14237
field_iterator field_end() const
Definition: Decl.h:3787
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD)
overridden_method_range overridden_methods() const
Definition: DeclCXX.cpp:2170
bool isLocalExternDecl()
Determine whether this is a block-scope declaration with linkage.
Definition: DeclBase.h:1053
bool isFileContext() const
Definition: DeclBase.h:1818
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:72
DeclContext * getDeclContext()
Definition: DeclBase.h:427
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:769
bool isConstexprSpecified() const
Definition: DeclSpec.h:727
A parsed C++17 decomposition declarator of the form &#39;[&#39; identifier-list &#39;]&#39;.
Definition: DeclSpec.h:1664
ExprResult BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, TypeSourceInfo *Ty, Expr *E, SourceRange AngleBrackets, SourceRange Parens)
Definition: SemaCast.cpp:258
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition: Type.cpp:2527
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:526
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
Decl * ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList, SourceLocation SemiLoc)
Handle a C++11 empty-declaration and attribute-declaration.
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:2331
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:2422
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:179
bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc, SourceLocation ColonLoc, const ParsedAttributesView &Attrs)
ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
bool needsImplicitDestructor() const
Determine whether this class needs an implicit destructor to be lazily declared.
Definition: DeclCXX.h:1185
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7603
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:460
Defines the clang::TypeLoc interface and its subclasses.
int Depth
Definition: ASTDiff.cpp:191
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:1016
void DiscardCleanupsInEvaluationContext()
Definition: SemaExpr.cpp:14555
The argument of this type cannot be passed directly in registers.
Definition: Decl.h:3613
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn&#39;t...
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined...
Definition: DeclBase.h:614
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:1337
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:2800
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Definition: Decl.cpp:2695
void setInheritConstructors(bool Inherit=true)
Set that this base class&#39;s constructors should be inherited.
Definition: DeclCXX.h:258
bool isInvalid() const
QualType getType() const
Definition: Expr.h:128
bool isFunctionOrMethod() const
Definition: DeclBase.h:1800
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:206
bool hasNonTrivialDestructor() const
Determine whether this class has a non-trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1488
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...
Qualifiers getTypeQualifiers() const
Definition: DeclCXX.h:2188
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:297
InClassInitStyle
In-class initialization styles for non-static data members.
Definition: Specifiers.h:229
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
Get the name of the overloadable C++ operator corresponding to Op.
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:1752
static bool checkTrivialClassMembers(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM, bool ConstArg, Sema::TrivialABIHandling TAH, bool Diagnose)
Check whether the members of a class type allow a special member to be trivial.
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:170
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:1896
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:652
void setHasTrivialSpecialMemberForCall()
Definition: DeclCXX.h:1496
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:1380
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
Definition: SemaType.cpp:7953
Represents a GCC generic vector type.
Definition: Type.h:3168
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2720
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1078
bool isFriendSpecified() const
Definition: DeclSpec.h:721
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:6688
void addContextNote(SourceLocation UseLoc)
Definition: Sema.h:779
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class...
Definition: DeclCXX.h:1400
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:2477
ValueDecl * getDecl()
Definition: Expr.h:1114
Represents a C++ deduction guide declaration.
Definition: DeclCXX.h:1988
bool needsImplicitDefaultConstructor() const
Determine if we need to declare a default constructor for this class.
Definition: DeclCXX.h:974
bool isUsable() const
Definition: Ownership.h:171
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2768
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:1396
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:152
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2026
bool isUnionType() const
Definition: Type.cpp:475
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2011
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:703
bool hasNonTrivialMoveAssignment() const
Determine whether this class has a non-trivial move assignment operator (C++11 [class.copy]p25)
Definition: DeclCXX.h:1470
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:170
bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New, const CXXMethodDecl *Old)
The triviality of a method affected by "trivial_abi".
Definition: Sema.h:2293
static bool CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S, SmallVectorImpl< SourceLocation > &ReturnStmts, SourceLocation &Cxx1yLoc, SourceLocation &Cxx2aLoc)
Check the provided statement is allowed in a constexpr function definition.
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:236
TypeLoc getReturnLoc() const
Definition: TypeLoc.h:1411
static bool RefersToRValueRef(Expr *MemRef)
bool hasValidIntValue() const
True iff we&#39;ve successfully evaluated the variable as a constant expression and extracted its integer...
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:1104
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:301
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:6105
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
ExprResult ActOnFinishFullExpr(Expr *Expr)
Definition: Sema.h:5347
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:1416
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6131
bool hasGroupingParens() const
Definition: DeclSpec.h:2448
void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow)
Hides a using shadow declaration.
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
Definition: Type.h:4013
RecordDecl * getDecl() const
Definition: Type.h:4380
bool hasVariantMembers() const
Determine whether this class has any variant members.
Definition: DeclCXX.h:1359
noexcept(expression), evals to &#39;false&#39;
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
Definition: Decl.cpp:4126
unsigned size_overridden_methods() const
Definition: DeclCXX.cpp:2164
static void SearchForReturnInStmt(Sema &Self, Stmt *S)
Wrapper for source info for arrays.
Definition: TypeLoc.h:1460
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
static bool DiagnoseUnexpandedParameterPacks(Sema &S, TemplateTemplateParmDecl *TTP)
Check for unexpanded parameter packs within the template parameters of a template template parameter...
void checkClassLevelCodeSegAttribute(CXXRecordDecl *Class)
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:1745
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
static bool CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef, const FunctionDecl *FnDecl)
UnqualifiedIdKind Kind
Describes the kind of unqualified-id parsed.
Definition: DeclSpec.h:941
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:945
static unsigned NumImplicitDestructorsDeclared
The number of implicitly-declared destructors for which declarations were built.
Definition: ASTContext.h:2827
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1785
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
We are declaring an implicit special member function.
Definition: Sema.h:7217
CXXSpecialMember SpecialMember
The special member being declared or defined.
Definition: Sema.h:7255
CanQualType BuiltinFnTy
Definition: ASTContext.h:1046
The "struct" keyword.
Definition: Type.h:5033
Kind
static CXXConstructorDecl * findUserDeclaredCtor(CXXRecordDecl *RD)
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1448
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:157
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3743
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:5304
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1127
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2558
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:204
ExtParameterInfo getExtParameterInfo(unsigned I) const
Definition: Type.h:4078
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3899
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:218
SCS getStorageClassSpec() const
Definition: DeclSpec.h:451
ASTContext & getASTContext() const
Definition: Sema.h:1238
SourceRange getSourceRange() const LLVM_READONLY
Determine the source range covering the entire initializer.
Definition: DeclCXX.cpp:2286
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, ArrayRef< TemplateParameterList *> FriendTypeTPLists=None)
Definition: DeclFriend.cpp:35
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:295
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:1450
Encodes a location in the source.
void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record)
body_range body()
Definition: Stmt.h:1274
QualType getReturnType() const
Definition: Type.h:3613
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
We are computing the exception specification for a defaulted special member function.
Definition: Sema.h:7210
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4396
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:1371
Expr * getSubExpr() const
Definition: Expr.h:1926
bool hasErrorOccurred() const
Determine whether any errors have occurred since this object instance was created.
Definition: Diagnostic.h:1010
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:2095
void setTrivialForCallFlags(CXXMethodDecl *MD)
Definition: DeclCXX.cpp:1321
Attr * clone(ASTContext &C) const
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
Definition: DeclSpec.h:1873
CastKind getCastKind() const
Definition: Expr.h:3049
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:2660
static unsigned NumImplicitCopyAssignmentOperatorsDeclared
The number of implicitly-declared copy assignment operators for which declarations were built...
Definition: ASTContext.h:2813
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.
static ConstantExpr * Create(const ASTContext &Context, Expr *E)
Definition: Expr.h:909
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3064
SourceLocation getUsingLoc() const
Return the source location of the &#39;using&#39; keyword.
Definition: DeclCXX.h:3385
void referenceDLLExportedClassMethods()
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:277
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:171
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:376
FunctionTypeInfo Fun
Definition: DeclSpec.h:1520
bool isModulePrivateSpecified() const
Definition: DeclSpec.h:724
InheritedConstructorInfo(Sema &S, SourceLocation UseLoc, ConstructorUsingShadowDecl *Shadow)
Attempt to be ABI-compatible with code generated by Clang 4.0.x (SVN r291814).
static bool CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl, CanQualType ExpectedResultType, CanQualType ExpectedFirstParamType, unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag)
Stmt * getElse()
Definition: Stmt.h:1783
QualType getElementType() const
Definition: Type.h:3203
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:1143
void setReferenced(bool R=true)
Definition: DeclBase.h:577
unsigned getSpellingListIndex() const
Definition: Attr.h:91
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:823
ParsedAttr - Represents a syntactic attribute.
Definition: ParsedAttr.h:117
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:580
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:3571
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3866
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set...
Definition: Decl.h:2721
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
Definition: Type.h:765
const DecompositionDeclarator & getDecompositionDeclarator() const
Definition: DeclSpec.h:1875
void removeShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:2721
void setCtorInitializers(CXXCtorInitializer **Initializers)
Definition: DeclCXX.h:2584
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:2041
void setDefaulted(bool D=true)
Definition: Decl.h:2035
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2413
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3928
paths_iterator begin()
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:183
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:1078
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:553
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
No ref-qualifier was provided.
Definition: Type.h:1360
void setEntity(DeclContext *E)
Definition: Scope.h:326
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:584
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2285
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:1070
SourceLocation getLocation() const
Definition: Attr.h:94
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3860
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition: Lookup.h:69
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
Definition: Type.h:3963
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:1016
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:1348
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:6112
arg_range arguments()
Definition: Expr.h:2590
AccessSpecifier getAccess() const
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
Definition: SemaType.cpp:1727
bool isObjCObjectPointerType() const
Definition: Type.h:6393
A class for iterating through a result set and possibly filtering out results.
Definition: Lookup.h:606
Direct list-initialization.
Definition: Specifiers.h:232
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2499
static ConstructorUsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, UsingDecl *Using, NamedDecl *Target, bool IsVirtual)
Definition: DeclCXX.cpp:2693
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3120
bool isFunctionProtoType() const
Definition: Type.h:1947
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:805
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1664
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:51
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:3076
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:164
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:149
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.
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
Definition: SemaType.cpp:1980
SourceLocation getRAngleLoc() const
Definition: DeclTemplate.h:174
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted per C++0x.
Definition: Decl.h:2039
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
SourceLocation getInlineSpecLoc() const
Definition: DeclSpec.h:570
NamedDecl * next()
Definition: Lookup.h:632
void setExplicitlyDefaulted(bool ED=true)
State that this function is explicitly defaulted per C++0x.
Definition: Decl.h:2045
void setHasInheritedDefaultArg(bool I=true)
Definition: Decl.h:1680
bool hasFlexibleArrayMember() const
Definition: Decl.h:3647
bool defaultedCopyConstructorIsDeleted() const
true if a defaulted copy constructor for this class would be deleted.
Definition: DeclCXX.h:912
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
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 isTrivialForCall() const
Definition: Decl.h:2029
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2293
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:595
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Definition: Decl.cpp:99
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3922
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:215
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
TypeLoc getElementLoc() const
Definition: TypeLoc.h:1493
bool hasInClassInitializer() const
Whether this class has any in-class initializers for non-static data members (including those in anon...
Definition: DeclCXX.h:1289
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
getSpecialMember - get the special member enum for a method.
Definition: SemaDecl.cpp:2807
SourceLocation getLastLocation() const
Definition: DeclSpec.h:2529
CXXDestructorDecl * DeclareImplicitDestructor(CXXRecordDecl *ClassDecl)
Declare the implicit destructor for the given class.
Expr * getLHS() const
Definition: Expr.h:3332
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:4571
A POD class for pairing a NamedDecl* with an access specifier.
CXXConstructorDecl * getConstructor() const
Definition: DeclCXX.h:2471
StringRef getName() const
Return the actual identifier string.
MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, CXXRecordDecl *ClassDecl)
SourceRange getRange() const
Definition: Attr.h:95
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1889
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:2916
const ComparisonCategoryInfo * lookupInfo(ComparisonCategoryType Kind) const
Return the cached comparison category information for the specified &#39;Kind&#39;.
ast_type_traits::DynTypedNode Node
CanQualType CharTy
Definition: ASTContext.h:1018
TLS with a dynamic initializer.
Definition: Decl.h:836
Represents a template argument.
Definition: TemplateBase.h:51
void setBody(Stmt *B)
Definition: Decl.cpp:2741
TagTypeKind
The kind of a tag type.
Definition: Type.h:5031
static bool isInvalid(LocType Loc, bool *Invalid)
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2440
bool hasNonTrivialCopyConstructorForCall() const
Definition: DeclCXX.h:1415
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2535
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LanguageIDs Lang, bool HasBraces)
Definition: DeclCXX.cpp:2528
Dataflow Directional Tag Classes.
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Definition: Decl.h:3056
bool isExplicit() const
Whether this function is explicit.
Definition: DeclCXX.h:2589
static void DelegatingCycleHelper(CXXConstructorDecl *Ctor, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Valid, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Invalid, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Current, Sema &S)
bool isValid() const
Return true if this is a valid SourceLocation object.
CXXConstructorDecl * DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit copy constructor for the given class.
MSPropertyDecl * HandleMSProperty(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS, const ParsedAttr &MSPropertyAttr)
HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:499
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:1262
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:303
method_iterator begin_overridden_methods() const
Definition: DeclCXX.cpp:2154
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:226
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:475
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:131
StmtResult ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, ConditionResult Second, FullExprArg Third, SourceLocation RParenLoc, Stmt *Body)
Definition: SemaStmt.cpp:1743
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with &#39;,...)&#39;, this is true.
Definition: DeclSpec.h:1258
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3558
bool isImplicit() const
Definition: ExprCXX.h:997
SourceRange getSourceRange(const SourceRange &Range)
Returns the SourceRange of a SourceRange.
Definition: FixIt.h:34
bool isRecord() const
Definition: DeclBase.h:1827
attr_range attrs() const
Definition: DeclBase.h:490
SourceLocation RAngleLoc
The location of the &#39;>&#39; after the template argument list.
static bool InitializationHasSideEffects(const FieldDecl &FD)
bool hasTrivialDestructorForCall() const
Definition: DeclCXX.h:1482
Represents a field injected from an anonymous union/struct into the parent scope. ...
Definition: Decl.h:2825
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:2365
SourceLocation getSourceLocation() const
Determine the source location of the initializer.
Definition: DeclCXX.cpp:2273
QualType getUnderlyingType() const
Definition: Decl.h:2971
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1027
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:118
AccessSpecifier getAccess() const
Definition: DeclBase.h:462
const Expr * getInit() const
Definition: Decl.h:1220
A decomposition declaration.
Definition: DeclCXX.h:3843
MapType::iterator iterator
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
Definition: DeclBase.cpp:1756
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:160
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:983
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:3667
FunctionDecl * getTemplateInstantiationPattern() const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition: Decl.cpp:3414
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Definition: DeclCXX.cpp:2545
bool areArgsDestroyedLeftToRightInCallee() const
Are arguments to a call destroyed left to right in the callee? This is a fundamental language change...
Definition: TargetCXXABI.h:209
void setWillHaveBody(bool V=true)
Definition: Decl.h:2222
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
The name of a declaration.
StmtClass getStmtClass() const
Definition: Stmt.h:1029
ArrayRef< QualType > exceptions() const
Definition: Type.h:4044
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Lookup.h:506
Expr * getDefaultArg()
Definition: Decl.cpp:2573
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Definition: Decl.h:346
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2166
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:2370
llvm::SmallPtrSet< SpecialMemberDecl, 4 > SpecialMembersBeingDeclared
The C++ special members which we are currently in the process of declaring.
Definition: Sema.h:1183
const Type * getBaseClass() const
If this is a base class initializer, returns the type of the base class.
Definition: DeclCXX.cpp:2266
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:5843
A mapping from each virtual member function to its set of final overriders.
unsigned getNumTemplateParameterLists() const
Definition: Decl.h:760
Represents an enum.
Definition: Decl.h:3326
CXXRecordDecl * Record
The declaration for the comparison category type from the standard library.
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:2756
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:146
semantics_iterator semantics_begin()
Definition: Expr.h:5372
bool isDestroyingOperatorDelete() const
Determine whether this is a destroying operator delete.
Definition: Decl.cpp:2884
Expr * get() const
Definition: Sema.h:3672
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration...
Definition: DeclCXX.h:2144
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:583
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:1083
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:508
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:2017
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:6663
static unsigned NumImplicitCopyAssignmentOperators
The number of implicitly-declared copy assignment operators.
Definition: ASTContext.h:2809
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:2693
void PushUsingDirective(UsingDirectiveDecl *UDir)
Definition: Scope.h:458
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...
void forEachQualifier(llvm::function_ref< void(TQ, StringRef, SourceLocation)> Handle)
This method calls the passed in handler on each qual being set.
Definition: DeclSpec.cpp:422
unsigned getNumParams() const
Definition: TypeLoc.h:1402
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2022
SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D, CXXSpecialMember SM, bool ConstArg, bool VolatileArg, bool RValueThis, bool ConstThis, bool VolatileThis)
const FunctionDecl * getOperatorDelete() const
Definition: DeclCXX.h:2738
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:151
static FunctionProtoType::ExtProtoInfo getImplicitMethodEPI(Sema &S, CXXMethodDecl *MD)
UsingDecl * getUsingDecl() const
Gets the using declaration to which this declaration is tied.
Definition: DeclCXX.cpp:2682
void RemoveDecl(Decl *D)
Definition: Scope.h:291
Name lookup found a single declaration that met the criteria.
Definition: Lookup.h:60
bool needsOverloadResolutionForMoveConstructor() const
Determine whether we need to eagerly declare a defaulted move constructor for this class...
Definition: DeclCXX.h:1098
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:2552
static AccessSpecifier MergeAccess(AccessSpecifier PathAccess, AccessSpecifier DeclAccess)
Calculates the access of a decl that is reached along a path.
Definition: DeclCXX.h:1864
bool isIncompleteArrayType() const
Definition: Type.h:6353
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:4370
Complex values, per C99 6.2.5p11.
Definition: Type.h:2477
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
static bool CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl)
MapType::const_iterator const_iterator
void setUnparsedDefaultArg()
Specify that this parameter has an unparsed default argument.
Definition: Decl.h:1672
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:2615
bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl)
CheckLiteralOperatorDeclaration - Check whether the declaration of this literal operator function is ...
bool checkInitIsICE() const
Determine whether the value of the initializer attached to this declaration is an integral constant e...
Definition: Decl.cpp:2330
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:547
static void extendRight(SourceRange &R, SourceRange After)
QualType getCanonicalTypeInternal() const
Definition: Type.h:2355
SourceLocation getVirtualSpecLoc() const
Definition: DeclSpec.h:575
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2256
LanguageIDs
Represents the language in a linkage specification.
Definition: DeclCXX.h:2837
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6578
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:156
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:1172
bool hasNonTrivialObjCLifetime() const
Definition: Type.h:1062
IndirectFieldDecl * getIndirectMember() const
Definition: DeclCXX.h:2406
T * getAttr() const
Definition: DeclBase.h:527
type_object_range type_objects() const
Returns the range of type objects, from the identifier outwards.
Definition: DeclSpec.h:2192
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
const llvm::APInt & getSize() const
Definition: Type.h:2890
CanQualType DependentTy
Definition: ASTContext.h:1045
bool isFunctionType() const
Definition: Type.h:6292
TrivialSubobjectKind
The kind of subobject we are checking for triviality.
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1060
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:716
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
CXXBasePath & front()
Opcode getOpcode() const
Definition: Expr.h:1921
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1413
bool isImplicitlyDeleted(FunctionDecl *FD)
Determine whether the given function is an implicitly-deleted special member function.
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2673
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1730
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2269
decl_range decls()
Definition: Stmt.h:1186
static UsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, UsingDecl *Using, NamedDecl *Target)
Definition: DeclCXX.h:3174
TypeLocClass getTypeLocClass() const
Definition: TypeLoc.h:114
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:12871
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:1935
The template argument is a type.
Definition: TemplateBase.h:60
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
Holds information about the various types of exception specification.
Definition: Type.h:3741
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:92
const LinkageSpecDecl * getExternCContext() const
Retrieve the nearest enclosing C linkage specification context.
Definition: DeclBase.cpp:1133
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1507
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
void setInherited(bool I)
Definition: Attr.h:152
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:251
The "class" keyword.
Definition: Type.h:5042
Represents a base class of a C++ class.
Definition: DeclCXX.h:192
bool hasTypename() const
Return true if the using declaration has &#39;typename&#39;.
Definition: DeclCXX.h:3407
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:412
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2070
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3746
This is a scope that can contain a declaration.
Definition: Scope.h:60
bool isObjCObjectType() const
Definition: Type.h:6397
static BindingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id)
Definition: DeclCXX.cpp:2851
CanQualType Char8Ty
Definition: ASTContext.h:1022
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2356
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:2133
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2253
TrivialABIHandling
Definition: Sema.h:2288
static const void * GetKeyForMember(ASTContext &Context, CXXCtorInitializer *Member)
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1137
EnumDecl * getStdAlignValT() const
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
bool isLValueReferenceType() const
Definition: Type.h:6312
bool needsImplicitCopyConstructor() const
Determine whether this class needs an implicit copy constructor to be lazily declared.
Definition: DeclCXX.h:1002
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:238
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1619
void setInvalidType(bool Val=true)
Definition: DeclSpec.h:2442
Reading or writing from this object requires a barrier call.
Definition: Type.h:172
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Definition: Type.h:3749
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:4565
static void BuildBasePathArray(const CXXBasePath &Path, CXXCastPath &BasePathArray)
QualType getParamType(unsigned i) const
Definition: Type.h:3890
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:1687
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\, const ASTContext *Context=nullptr) const
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1009
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:675
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2687
static bool functionDeclHasDefaultArgument(const FunctionDecl *FD)
void CheckOverrideControl(NamedDecl *D)
CheckOverrideControl - Check C++11 override control semantics.
CallingConv getCallConv() const
Definition: Type.h:3623
ThreadStorageClassSpecifier
Thread storage-class-specifier.
Definition: Specifiers.h:193
void setImplicitMoveAssignmentIsDeleted()
Set that we attempted to declare an implicit move assignment operator, but overload resolution failed...
Definition: DeclCXX.h:1151
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
ActionResult< Expr * > ExprResult
Definition: Ownership.h:267
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:6152
SourceLocation getRestrictSpecLoc() const
Definition: DeclSpec.h:549
static bool CheckConstexprParameterTypes(Sema &SemaRef, const FunctionDecl *FD)
void setDefaultArg(Expr *defarg)
Definition: Decl.cpp:2585
bool isMutable() const
Determines whether this field is mutable (C++ only).
Definition: Decl.h:2654
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:300
static bool isCompoundAssignmentOp(Opcode Opc)
Definition: Expr.h:3420
void setIvarInitializers(ASTContext &C, CXXCtorInitializer **initializers, unsigned numInitializers)
Definition: DeclObjC.cpp:2170
bool isValid() const
bool hasUserDeclaredMoveConstructor() const
Determine whether this class has had a move constructor declared by the user.
Definition: DeclCXX.h:1049
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:6544
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:3660
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:29
void CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD)
void setConstexpr(bool IC)
Definition: Decl.h:2095
void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6099
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.
static IsTupleLike isTupleLike(Sema &S, SourceLocation Loc, QualType T, llvm::APSInt &Size)
void setParam(unsigned i, ParmVarDecl *VD)
Definition: TypeLoc.h:1409
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:191
CanQualType Char16Ty
Definition: ASTContext.h:1023
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that&#39;s ...
bool isInherited() const
Definition: Attr.h:98
static bool hasOneRealArgument(MultiExprArg Args)
Determine whether the given list arguments contains exactly one "real" (non-default) argument...
AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, QualType Derived, const CXXBasePath &Path, unsigned DiagID, bool ForceCheck=false, bool ForceUnprivileged=false)
Checks access for a hierarchy conversion.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1854
static unsigned NumImplicitCopyConstructorsDeclared
The number of implicitly-declared copy constructors for which declarations were built.
Definition: ASTContext.h:2799
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:336
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:2742
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:574
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:129
void addAttr(Attr *A)
Definition: DeclBase.cpp:840
bool lambdaIsDefaultConstructibleAndAssignable() const
Determine whether this lambda should have an implicit default constructor and copy and move assignmen...
Definition: DeclCXX.cpp:631
NamedDecl * getAcceptableDecl(NamedDecl *D) const
Retrieve the accepted (re)declaration of the given declaration, if there is one.
Definition: Lookup.h:350
SourceManager & getSourceManager() const
Definition: Sema.h:1236
SourceRange getDefaultArgRange() const
Retrieve the source range that covers the entire default argument.
Definition: Decl.cpp:2590
iterator end() const
Definition: Lookup.h:325
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.
bool hasInheritedAssignment() const
Determine whether this class has a using-declaration that names a base class assignment operator...
Definition: DeclCXX.h:1532
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:276
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1316
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1566
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2396
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:567
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:3637
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
Definition: Decl.h:1989
SourceLocation getAtomicSpecLoc() const
Definition: DeclSpec.h:551
ExprResult ExprError()
Definition: Ownership.h:283
bool hasVolatile() const
Definition: Type.h:263
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:1158
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:3395
NameKind getKind() const
CanQualType IntTy
Definition: ASTContext.h:1025
unsigned getNumElements() const
Definition: Type.h:3204
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:226
The top declaration context.
Definition: Decl.h:108
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2079
SourceLocation getConstexprSpecLoc() const
Definition: DeclSpec.h:728
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:1041
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:230
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
Definition: DeclSpec.h:1445
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:819
bool isUnion() const
Definition: Decl.h:3252
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4841
NamedDecl * getMostRecentDecl()
Definition: Decl.h:446
Expr * getRHS() const
Definition: Expr.h:3334
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:2136
bool isPointerType() const
Definition: Type.h:6296
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:3316
bool implicitCopyConstructorHasConstParam() const
Determine whether an implicit copy constructor for this type would have a parameter with a const-qual...
Definition: DeclCXX.h:1023
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 addAddressSpace(LangAS space)
Definition: Type.h:378
void setBaseObjectType(QualType T)
Sets the base object type for this lookup.
Definition: Lookup.h:409
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:66
bool needsImplicitMoveConstructor() const
Determine whether this class should get an implicit move constructor or if any existing special membe...
Definition: DeclCXX.h:1088
ArrayRef< Binding > bindings() const
Definition: DeclSpec.h:1701
bool CheckDestructor(CXXDestructorDecl *Destructor)
CheckDestructor - Checks a fully-formed destructor definition for well-formedness, issuing any diagnostics required.
DeclaratorContext getContext() const
Definition: DeclSpec.h:1879
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1135
SourceLocation getInnerLocStart() const
Return SourceLocation representing start of source range ignoring outer template declarations.
Definition: Decl.h:3150
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:572
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace nested inside this namespace, if any.
Definition: Decl.h:598
bool hasDirectFields() const
Determine whether this class has direct non-static data members.
Definition: DeclCXX.h:1330
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:3912
IdentifierInfo * getCXXLiteralIdentifier() const
If this name is the name of a literal operator, retrieve the identifier associated with it...
QualType getType() const
Definition: Decl.h:648
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:114
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:328
A trivial tuple used to represent a source range.
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:299
ASTContext & Context
Definition: Sema.h:324
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:2983
paths_iterator end()
This represents a decl that may have a name.
Definition: Decl.h:249
virtual void diagnose(Sema &S, SourceLocation Loc, QualType T)=0
void dropAttr()
Definition: DeclBase.h:502
bool isTranslationUnit() const
Definition: DeclBase.h:1823
Expr * getRepAsExpr() const
Definition: DeclSpec.h:500
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:76
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:457
CanQualType BoolTy
Definition: ASTContext.h:1017
Represents a C++ namespace alias.
Definition: DeclCXX.h:3020
Decl * ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc, unsigned TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, MultiTemplateParamsArg TempParamLists)
Handle a friend tag declaration where the scope specifier was templated.
No keyword precedes the qualified type name.
Definition: Type.h:5071
SourceRange getSourceRange() const LLVM_READONLY
Retrieves the source range that contains the entire base specifier.
Definition: DeclCXX.h:235
FullExprArg MakeFullDiscardedValueExpr(Expr *Arg)
Definition: Sema.h:3694
iterator begin() const
Definition: Lookup.h:324
Represents C++ using-directive.
Definition: DeclCXX.h:2916
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:1284
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:87
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:513
ComparisonCategoryType
An enumeration representing the different comparison categories types.
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.
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:3055
void setType(QualType newType)
Definition: Decl.h:649
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:2326
ctor_range ctors() const
Definition: DeclCXX.h:885
Decl * ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS, MultiTemplateParamsArg TemplateParams, SourceLocation UsingLoc, UnqualifiedId &Name, const ParsedAttributesView &AttrList, TypeResult Type, Decl *DeclFromDeclSpec)
bool hasInit() const
Definition: Decl.cpp:2164
Wrapper for source info for pointers.
Definition: TypeLoc.h:1202
SourceLocation getBegin() const
ParsedAttributes - A collection of parsed attributes.
Definition: ParsedAttr.h:855
SourceLocation ColonLoc
Location of &#39;:&#39;.
Definition: OpenMPClause.h:108
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclTemplate.h:176
const LangOptions & getLangOpts() const
Definition: ASTContext.h:707
void WillReplaceSpecifier(bool ForceReplacement)
bool isParameterPack() const
Determine whether this parameter is actually a function parameter pack.
Definition: Decl.cpp:2629
Wrapper for source info for block pointers.
Definition: TypeLoc.h:1215
void setDeletedAsWritten(bool D=true)
Definition: Decl.h:2144
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:230
base_class_range vbases()
Definition: DeclCXX.h:840
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2872
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3773
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:969
Decl * ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList)
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:4898
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:1313
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1943
Comparison
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:569
static bool checkLiteralOperatorTemplateParameterList(Sema &SemaRef, FunctionTemplateDecl *TpDecl)
static const ParsedAttr * getMSPropertyAttr(const ParsedAttributesView &list)
Attr - This represents one attribute.
Definition: Attr.h:44
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:762
SourceLocation getLocation() const
Definition: DeclBase.h:418
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3139
bool isExternallyVisible() const
Definition: Decl.h:380
LangStandard::Kind Std
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:98
A single template declaration.
Definition: TemplateName.h:192
bool isBeingDefined() const
Return true if this decl is currently being defined.
Definition: Decl.h:3189
ConstructorUsingShadowDecl * getShadowDecl() const
Definition: DeclCXX.h:2470
noexcept(expression), evals to &#39;true&#39;
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1261
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2560
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:1999
The triviality of a method unaffected by "trivial_abi".
Definition: Sema.h:2290
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:1058
static unsigned NumImplicitDestructors
The number of implicitly-declared destructors.
Definition: ASTContext.h:2823
static bool isVisible(Sema &SemaRef, NamedDecl *D)
Determine whether the given declaration is visible to the program.
Definition: Lookup.h:338
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:1110
param_type_iterator param_type_end() const
Definition: Type.h:4038
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:728
method_range methods() const
Definition: DeclCXX.h:865
The subobject is a non-static data member.
bool isNoDestroy(const ASTContext &) const
Do we need to emit an exit-time destructor for this variable?
Definition: Decl.cpp:2480
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:291
ComparisonCategories CompCategories
Types and expressions required to build C++2a three-way comparisons using operator<=>, including the values return by builtin <=> operators.
Definition: ASTContext.h:2026
bool defaultedDestructorIsDeleted() const
true if a defaulted destructor for this class would be deleted.
Definition: DeclCXX.h:929