clang  3.8.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 
15 #include "clang/AST/ASTConsumer.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/ASTLambda.h"
20 #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"
39 #include "clang/Sema/Template.h"
40 #include "llvm/ADT/STLExtras.h"
41 #include "llvm/ADT/SmallString.h"
42 #include <map>
43 #include <set>
44 
45 using namespace clang;
46 
47 //===----------------------------------------------------------------------===//
48 // CheckDefaultArgumentVisitor
49 //===----------------------------------------------------------------------===//
50 
51 namespace {
52  /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
53  /// the default argument of a parameter to determine whether it
54  /// contains any ill-formed subexpressions. For example, this will
55  /// diagnose the use of local variables or parameters within the
56  /// default argument expression.
57  class CheckDefaultArgumentVisitor
58  : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
59  Expr *DefaultArg;
60  Sema *S;
61 
62  public:
63  CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
64  : DefaultArg(defarg), S(s) {}
65 
66  bool VisitExpr(Expr *Node);
67  bool VisitDeclRefExpr(DeclRefExpr *DRE);
68  bool VisitCXXThisExpr(CXXThisExpr *ThisE);
69  bool VisitLambdaExpr(LambdaExpr *Lambda);
70  bool VisitPseudoObjectExpr(PseudoObjectExpr *POE);
71  };
72 
73  /// VisitExpr - Visit all of the children of this expression.
74  bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
75  bool IsInvalid = false;
76  for (Stmt *SubStmt : Node->children())
77  IsInvalid |= Visit(SubStmt);
78  return IsInvalid;
79  }
80 
81  /// VisitDeclRefExpr - Visit a reference to a declaration, to
82  /// determine whether this declaration can be used in the default
83  /// argument expression.
84  bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
85  NamedDecl *Decl = DRE->getDecl();
86  if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
87  // C++ [dcl.fct.default]p9
88  // Default arguments are evaluated each time the function is
89  // called. The order of evaluation of function arguments is
90  // unspecified. Consequently, parameters of a function shall not
91  // be used in default argument expressions, even if they are not
92  // evaluated. Parameters of a function declared before a default
93  // argument expression are in scope and can hide namespace and
94  // class member names.
95  return S->Diag(DRE->getLocStart(),
96  diag::err_param_default_argument_references_param)
97  << Param->getDeclName() << DefaultArg->getSourceRange();
98  } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
99  // C++ [dcl.fct.default]p7
100  // Local variables shall not be used in default argument
101  // expressions.
102  if (VDecl->isLocalVarDecl())
103  return S->Diag(DRE->getLocStart(),
104  diag::err_param_default_argument_references_local)
105  << VDecl->getDeclName() << DefaultArg->getSourceRange();
106  }
107 
108  return false;
109  }
110 
111  /// VisitCXXThisExpr - Visit a C++ "this" expression.
112  bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
113  // C++ [dcl.fct.default]p8:
114  // The keyword this shall not be used in a default argument of a
115  // member function.
116  return S->Diag(ThisE->getLocStart(),
117  diag::err_param_default_argument_references_this)
118  << ThisE->getSourceRange();
119  }
120 
121  bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(PseudoObjectExpr *POE) {
122  bool Invalid = false;
124  i = POE->semantics_begin(), e = POE->semantics_end(); i != e; ++i) {
125  Expr *E = *i;
126 
127  // Look through bindings.
128  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
129  E = OVE->getSourceExpr();
130  assert(E && "pseudo-object binding without source expression?");
131  }
132 
133  Invalid |= Visit(E);
134  }
135  return Invalid;
136  }
137 
138  bool CheckDefaultArgumentVisitor::VisitLambdaExpr(LambdaExpr *Lambda) {
139  // C++11 [expr.lambda.prim]p13:
140  // A lambda-expression appearing in a default argument shall not
141  // implicitly or explicitly capture any entity.
142  if (Lambda->capture_begin() == Lambda->capture_end())
143  return false;
144 
145  return S->Diag(Lambda->getLocStart(),
146  diag::err_lambda_capture_default_arg);
147  }
148 }
149 
150 void
152  const CXXMethodDecl *Method) {
153  // If we have an MSAny spec already, don't bother.
154  if (!Method || ComputedEST == EST_MSAny)
155  return;
156 
157  const FunctionProtoType *Proto
158  = Method->getType()->getAs<FunctionProtoType>();
159  Proto = Self->ResolveExceptionSpec(CallLoc, Proto);
160  if (!Proto)
161  return;
162 
164 
165  // If we have a throw-all spec at this point, ignore the function.
166  if (ComputedEST == EST_None)
167  return;
168 
169  switch(EST) {
170  // If this function can throw any exceptions, make a note of that.
171  case EST_MSAny:
172  case EST_None:
173  ClearExceptions();
174  ComputedEST = EST;
175  return;
176  // FIXME: If the call to this decl is using any of its default arguments, we
177  // need to search them for potentially-throwing calls.
178  // If this function has a basic noexcept, it doesn't affect the outcome.
179  case EST_BasicNoexcept:
180  return;
181  // If we're still at noexcept(true) and there's a nothrow() callee,
182  // change to that specification.
183  case EST_DynamicNone:
184  if (ComputedEST == EST_BasicNoexcept)
185  ComputedEST = EST_DynamicNone;
186  return;
187  // Check out noexcept specs.
189  {
191  Proto->getNoexceptSpec(Self->Context);
192  assert(NR != FunctionProtoType::NR_NoNoexcept &&
193  "Must have noexcept result for EST_ComputedNoexcept.");
194  assert(NR != FunctionProtoType::NR_Dependent &&
195  "Should not generate implicit declarations for dependent cases, "
196  "and don't know how to handle them anyway.");
197  // noexcept(false) -> no spec on the new function
198  if (NR == FunctionProtoType::NR_Throw) {
199  ClearExceptions();
200  ComputedEST = EST_None;
201  }
202  // noexcept(true) won't change anything either.
203  return;
204  }
205  default:
206  break;
207  }
208  assert(EST == EST_Dynamic && "EST case not considered earlier.");
209  assert(ComputedEST != EST_None &&
210  "Shouldn't collect exceptions when throw-all is guaranteed.");
211  ComputedEST = EST_Dynamic;
212  // Record the exceptions in this function's exception specification.
213  for (const auto &E : Proto->exceptions())
214  if (ExceptionsSeen.insert(Self->Context.getCanonicalType(E)).second)
215  Exceptions.push_back(E);
216 }
217 
219  if (!E || ComputedEST == EST_MSAny)
220  return;
221 
222  // FIXME:
223  //
224  // C++0x [except.spec]p14:
225  // [An] implicit exception-specification specifies the type-id T if and
226  // only if T is allowed by the exception-specification of a function directly
227  // invoked by f's implicit definition; f shall allow all exceptions if any
228  // function it directly invokes allows all exceptions, and f shall allow no
229  // exceptions if every function it directly invokes allows no exceptions.
230  //
231  // Note in particular that if an implicit exception-specification is generated
232  // for a function containing a throw-expression, that specification can still
233  // be noexcept(true).
234  //
235  // Note also that 'directly invoked' is not defined in the standard, and there
236  // is no indication that we should only consider potentially-evaluated calls.
237  //
238  // Ultimately we should implement the intent of the standard: the exception
239  // specification should be the set of exceptions which can be thrown by the
240  // implicit definition. For now, we assume that any non-nothrow expression can
241  // throw any exception.
242 
243  if (Self->canThrow(E))
244  ComputedEST = EST_None;
245 }
246 
247 bool
249  SourceLocation EqualLoc) {
250  if (RequireCompleteType(Param->getLocation(), Param->getType(),
251  diag::err_typecheck_decl_incomplete_type)) {
252  Param->setInvalidDecl();
253  return true;
254  }
255 
256  // C++ [dcl.fct.default]p5
257  // A default argument expression is implicitly converted (clause
258  // 4) to the parameter type. The default argument expression has
259  // the same semantic constraints as the initializer expression in
260  // a declaration of a variable of the parameter type, using the
261  // copy-initialization semantics (8.5).
263  Param);
265  EqualLoc);
266  InitializationSequence InitSeq(*this, Entity, Kind, Arg);
267  ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg);
268  if (Result.isInvalid())
269  return true;
270  Arg = Result.getAs<Expr>();
271 
272  CheckCompletedExpr(Arg, EqualLoc);
273  Arg = MaybeCreateExprWithCleanups(Arg);
274 
275  // Okay: add the default argument to the parameter
276  Param->setDefaultArg(Arg);
277 
278  // We have already instantiated this parameter; provide each of the
279  // instantiations with the uninstantiated default argument.
281  = UnparsedDefaultArgInstantiations.find(Param);
282  if (InstPos != UnparsedDefaultArgInstantiations.end()) {
283  for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
284  InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
285 
286  // We're done tracking this parameter's instantiations.
287  UnparsedDefaultArgInstantiations.erase(InstPos);
288  }
289 
290  return false;
291 }
292 
293 /// ActOnParamDefaultArgument - Check whether the default argument
294 /// provided for a function parameter is well-formed. If so, attach it
295 /// to the parameter declaration.
296 void
298  Expr *DefaultArg) {
299  if (!param || !DefaultArg)
300  return;
301 
302  ParmVarDecl *Param = cast<ParmVarDecl>(param);
303  UnparsedDefaultArgLocs.erase(Param);
304 
305  // Default arguments are only permitted in C++
306  if (!getLangOpts().CPlusPlus) {
307  Diag(EqualLoc, diag::err_param_default_argument)
308  << DefaultArg->getSourceRange();
309  Param->setInvalidDecl();
310  return;
311  }
312 
313  // Check for unexpanded parameter packs.
315  Param->setInvalidDecl();
316  return;
317  }
318 
319  // C++11 [dcl.fct.default]p3
320  // A default argument expression [...] shall not be specified for a
321  // parameter pack.
322  if (Param->isParameterPack()) {
323  Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
324  << DefaultArg->getSourceRange();
325  return;
326  }
327 
328  // Check that the default argument is well-formed
329  CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg, this);
330  if (DefaultArgChecker.Visit(DefaultArg)) {
331  Param->setInvalidDecl();
332  return;
333  }
334 
335  SetParamDefaultArgument(Param, DefaultArg, EqualLoc);
336 }
337 
338 /// ActOnParamUnparsedDefaultArgument - We've seen a default
339 /// argument for a function parameter, but we can't parse it yet
340 /// because we're inside a class definition. Note that this default
341 /// argument will be parsed later.
343  SourceLocation EqualLoc,
344  SourceLocation ArgLoc) {
345  if (!param)
346  return;
347 
348  ParmVarDecl *Param = cast<ParmVarDecl>(param);
349  Param->setUnparsedDefaultArg();
350  UnparsedDefaultArgLocs[Param] = ArgLoc;
351 }
352 
353 /// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
354 /// the default argument for the parameter param failed.
356  SourceLocation EqualLoc) {
357  if (!param)
358  return;
359 
360  ParmVarDecl *Param = cast<ParmVarDecl>(param);
361  Param->setInvalidDecl();
362  UnparsedDefaultArgLocs.erase(Param);
363  Param->setDefaultArg(new(Context)
364  OpaqueValueExpr(EqualLoc,
365  Param->getType().getNonReferenceType(),
366  VK_RValue));
367 }
368 
369 /// CheckExtraCXXDefaultArguments - Check for any extra default
370 /// arguments in the declarator, which is not a function declaration
371 /// or definition and therefore is not permitted to have default
372 /// arguments. This routine should be invoked for every declarator
373 /// that is not a function declaration or definition.
375  // C++ [dcl.fct.default]p3
376  // A default argument expression shall be specified only in the
377  // parameter-declaration-clause of a function declaration or in a
378  // template-parameter (14.1). It shall not be specified for a
379  // parameter pack. If it is specified in a
380  // parameter-declaration-clause, it shall not occur within a
381  // declarator or abstract-declarator of a parameter-declaration.
382  bool MightBeFunction = D.isFunctionDeclarationContext();
383  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
384  DeclaratorChunk &chunk = D.getTypeObject(i);
385  if (chunk.Kind == DeclaratorChunk::Function) {
386  if (MightBeFunction) {
387  // This is a function declaration. It can have default arguments, but
388  // keep looking in case its return type is a function type with default
389  // arguments.
390  MightBeFunction = false;
391  continue;
392  }
393  for (unsigned argIdx = 0, e = chunk.Fun.NumParams; argIdx != e;
394  ++argIdx) {
395  ParmVarDecl *Param = cast<ParmVarDecl>(chunk.Fun.Params[argIdx].Param);
396  if (Param->hasUnparsedDefaultArg()) {
397  CachedTokens *Toks = chunk.Fun.Params[argIdx].DefaultArgTokens;
398  SourceRange SR;
399  if (Toks->size() > 1)
400  SR = SourceRange((*Toks)[1].getLocation(),
401  Toks->back().getLocation());
402  else
403  SR = UnparsedDefaultArgLocs[Param];
404  Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
405  << SR;
406  delete Toks;
407  chunk.Fun.Params[argIdx].DefaultArgTokens = nullptr;
408  } else if (Param->getDefaultArg()) {
409  Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
410  << Param->getDefaultArg()->getSourceRange();
411  Param->setDefaultArg(nullptr);
412  }
413  }
414  } else if (chunk.Kind != DeclaratorChunk::Paren) {
415  MightBeFunction = false;
416  }
417  }
418 }
419 
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  // sufficent, and if neither is local, then they are in the same scope.)
471  continue;
472  }
473 
474  // We found our guy.
475  break;
476  }
477 
478  // C++ [dcl.fct.default]p4:
479  // For non-template functions, default arguments can be added in
480  // later declarations of a function in the same
481  // scope. Declarations in different scopes have completely
482  // distinct sets of default arguments. That is, declarations in
483  // inner scopes do not acquire default arguments from
484  // declarations in outer scopes, and vice versa. In a given
485  // function declaration, all parameters subsequent to a
486  // parameter with a default argument shall have default
487  // arguments supplied in this or previous declarations. A
488  // default argument shall not be redefined by a later
489  // declaration (not even to the same value).
490  //
491  // C++ [dcl.fct.default]p6:
492  // Except for member functions of class templates, the default arguments
493  // in a member function definition that appears outside of the class
494  // definition are added to the set of default arguments provided by the
495  // member function declaration in the class definition.
496  for (unsigned p = 0, NumParams = PrevForDefaultArgs
497  ? PrevForDefaultArgs->getNumParams()
498  : 0;
499  p < NumParams; ++p) {
500  ParmVarDecl *OldParam = PrevForDefaultArgs->getParamDecl(p);
501  ParmVarDecl *NewParam = New->getParamDecl(p);
502 
503  bool OldParamHasDfl = OldParam ? OldParam->hasDefaultArg() : false;
504  bool NewParamHasDfl = NewParam->hasDefaultArg();
505 
506  if (OldParamHasDfl && NewParamHasDfl) {
507  unsigned DiagDefaultParamID =
508  diag::err_param_default_argument_redefinition;
509 
510  // MSVC accepts that default parameters be redefined for member functions
511  // of template class. The new default parameter's value is ignored.
512  Invalid = true;
513  if (getLangOpts().MicrosoftExt) {
514  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(New);
515  if (MD && MD->getParent()->getDescribedClassTemplate()) {
516  // Merge the old default argument into the new parameter.
517  NewParam->setHasInheritedDefaultArg();
518  if (OldParam->hasUninstantiatedDefaultArg())
519  NewParam->setUninstantiatedDefaultArg(
520  OldParam->getUninstantiatedDefaultArg());
521  else
522  NewParam->setDefaultArg(OldParam->getInit());
523  DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
524  Invalid = false;
525  }
526  }
527 
528  // FIXME: If we knew where the '=' was, we could easily provide a fix-it
529  // hint here. Alternatively, we could walk the type-source information
530  // for NewParam to find the last source location in the type... but it
531  // isn't worth the effort right now. This is the kind of test case that
532  // is hard to get right:
533  // int f(int);
534  // void g(int (*fp)(int) = f);
535  // void g(int (*fp)(int) = &f);
536  Diag(NewParam->getLocation(), DiagDefaultParamID)
537  << NewParam->getDefaultArgRange();
538 
539  // Look for the function declaration where the default argument was
540  // actually written, which may be a declaration prior to Old.
541  for (auto Older = PrevForDefaultArgs;
542  OldParam->hasInheritedDefaultArg(); /**/) {
543  Older = Older->getPreviousDecl();
544  OldParam = Older->getParamDecl(p);
545  }
546 
547  Diag(OldParam->getLocation(), diag::note_previous_definition)
548  << OldParam->getDefaultArgRange();
549  } else if (OldParamHasDfl) {
550  // Merge the old default argument into the new parameter.
551  // It's important to use getInit() here; getDefaultArg()
552  // strips off any top-level ExprWithCleanups.
553  NewParam->setHasInheritedDefaultArg();
554  if (OldParam->hasUnparsedDefaultArg())
555  NewParam->setUnparsedDefaultArg();
556  else if (OldParam->hasUninstantiatedDefaultArg())
557  NewParam->setUninstantiatedDefaultArg(
558  OldParam->getUninstantiatedDefaultArg());
559  else
560  NewParam->setDefaultArg(OldParam->getInit());
561  } else if (NewParamHasDfl) {
562  if (New->getDescribedFunctionTemplate()) {
563  // Paragraph 4, quoted above, only applies to non-template functions.
564  Diag(NewParam->getLocation(),
565  diag::err_param_default_argument_template_redecl)
566  << NewParam->getDefaultArgRange();
567  Diag(PrevForDefaultArgs->getLocation(),
568  diag::note_template_prev_declaration)
569  << false;
570  } else if (New->getTemplateSpecializationKind()
573  // C++ [temp.expr.spec]p21:
574  // Default function arguments shall not be specified in a declaration
575  // or a definition for one of the following explicit specializations:
576  // - the explicit specialization of a function template;
577  // - the explicit specialization of a member function template;
578  // - the explicit specialization of a member function of a class
579  // template where the class template specialization to which the
580  // member function specialization belongs is implicitly
581  // instantiated.
582  Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
584  << New->getDeclName()
585  << NewParam->getDefaultArgRange();
586  } else if (New->getDeclContext()->isDependentContext()) {
587  // C++ [dcl.fct.default]p6 (DR217):
588  // Default arguments for a member function of a class template shall
589  // be specified on the initial declaration of the member function
590  // within the class template.
591  //
592  // Reading the tea leaves a bit in DR217 and its reference to DR205
593  // leads me to the conclusion that one cannot add default function
594  // arguments for an out-of-line definition of a member function of a
595  // dependent type.
596  int WhichKind = 2;
597  if (CXXRecordDecl *Record
598  = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
599  if (Record->getDescribedClassTemplate())
600  WhichKind = 0;
601  else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
602  WhichKind = 1;
603  else
604  WhichKind = 2;
605  }
606 
607  Diag(NewParam->getLocation(),
608  diag::err_param_default_argument_member_template_redecl)
609  << WhichKind
610  << NewParam->getDefaultArgRange();
611  }
612  }
613  }
614 
615  // DR1344: If a default argument is added outside a class definition and that
616  // default argument makes the function a special member function, the program
617  // is ill-formed. This can only happen for constructors.
618  if (isa<CXXConstructorDecl>(New) &&
620  CXXSpecialMember NewSM = getSpecialMember(cast<CXXMethodDecl>(New)),
621  OldSM = getSpecialMember(cast<CXXMethodDecl>(Old));
622  if (NewSM != OldSM) {
623  ParmVarDecl *NewParam = New->getParamDecl(New->getMinRequiredArguments());
624  assert(NewParam->hasDefaultArg());
625  Diag(NewParam->getLocation(), diag::err_default_arg_makes_ctor_special)
626  << NewParam->getDefaultArgRange() << NewSM;
627  Diag(Old->getLocation(), diag::note_previous_declaration);
628  }
629  }
630 
631  const FunctionDecl *Def;
632  // C++11 [dcl.constexpr]p1: If any declaration of a function or function
633  // template has a constexpr specifier then all its declarations shall
634  // contain the constexpr specifier.
635  if (New->isConstexpr() != Old->isConstexpr()) {
636  Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
637  << New << New->isConstexpr();
638  Diag(Old->getLocation(), diag::note_previous_declaration);
639  Invalid = true;
640  } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
641  Old->isDefined(Def)) {
642  // C++11 [dcl.fcn.spec]p4:
643  // If the definition of a function appears in a translation unit before its
644  // first declaration as inline, the program is ill-formed.
645  Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
646  Diag(Def->getLocation(), diag::note_previous_definition);
647  Invalid = true;
648  }
649 
650  // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
651  // argument expression, that declaration shall be a definition and shall be
652  // the only declaration of the function or function template in the
653  // translation unit.
656  Diag(New->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
657  Diag(Old->getLocation(), diag::note_previous_declaration);
658  Invalid = true;
659  }
660 
661  if (CheckEquivalentExceptionSpec(Old, New))
662  Invalid = true;
663 
664  return Invalid;
665 }
666 
667 /// \brief Merge the exception specifications of two variable declarations.
668 ///
669 /// This is called when there's a redeclaration of a VarDecl. The function
670 /// checks if the redeclaration might have an exception specification and
671 /// validates compatibility and merges the specs if necessary.
673  // Shortcut if exceptions are disabled.
674  if (!getLangOpts().CXXExceptions)
675  return;
676 
677  assert(Context.hasSameType(New->getType(), Old->getType()) &&
678  "Should only be called if types are otherwise the same.");
679 
680  QualType NewType = New->getType();
681  QualType OldType = Old->getType();
682 
683  // We're only interested in pointers and references to functions, as well
684  // as pointers to member functions.
685  if (const ReferenceType *R = NewType->getAs<ReferenceType>()) {
686  NewType = R->getPointeeType();
687  OldType = OldType->getAs<ReferenceType>()->getPointeeType();
688  } else if (const PointerType *P = NewType->getAs<PointerType>()) {
689  NewType = P->getPointeeType();
690  OldType = OldType->getAs<PointerType>()->getPointeeType();
691  } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) {
692  NewType = M->getPointeeType();
693  OldType = OldType->getAs<MemberPointerType>()->getPointeeType();
694  }
695 
696  if (!NewType->isFunctionProtoType())
697  return;
698 
699  // There's lots of special cases for functions. For function pointers, system
700  // libraries are hopefully not as broken so that we don't need these
701  // workarounds.
703  OldType->getAs<FunctionProtoType>(), Old->getLocation(),
704  NewType->getAs<FunctionProtoType>(), New->getLocation())) {
705  New->setInvalidDecl();
706  }
707 }
708 
709 /// CheckCXXDefaultArguments - Verify that the default arguments for a
710 /// function declaration are well-formed according to C++
711 /// [dcl.fct.default].
713  unsigned NumParams = FD->getNumParams();
714  unsigned p;
715 
716  // Find first parameter with a default argument
717  for (p = 0; p < NumParams; ++p) {
718  ParmVarDecl *Param = FD->getParamDecl(p);
719  if (Param->hasDefaultArg())
720  break;
721  }
722 
723  // C++11 [dcl.fct.default]p4:
724  // In a given function declaration, each parameter subsequent to a parameter
725  // with a default argument shall have a default argument supplied in this or
726  // a previous declaration or shall be a function parameter pack. A default
727  // argument shall not be redefined by a later declaration (not even to the
728  // same value).
729  unsigned LastMissingDefaultArg = 0;
730  for (; p < NumParams; ++p) {
731  ParmVarDecl *Param = FD->getParamDecl(p);
732  if (!Param->hasDefaultArg() && !Param->isParameterPack()) {
733  if (Param->isInvalidDecl())
734  /* We already complained about this parameter. */;
735  else if (Param->getIdentifier())
736  Diag(Param->getLocation(),
737  diag::err_param_default_argument_missing_name)
738  << Param->getIdentifier();
739  else
740  Diag(Param->getLocation(),
741  diag::err_param_default_argument_missing);
742 
743  LastMissingDefaultArg = p;
744  }
745  }
746 
747  if (LastMissingDefaultArg > 0) {
748  // Some default arguments were missing. Clear out all of the
749  // default arguments up to (and including) the last missing
750  // default argument, so that we leave the function parameters
751  // in a semantically valid state.
752  for (p = 0; p <= LastMissingDefaultArg; ++p) {
753  ParmVarDecl *Param = FD->getParamDecl(p);
754  if (Param->hasDefaultArg()) {
755  Param->setDefaultArg(nullptr);
756  }
757  }
758  }
759 }
760 
761 // CheckConstexprParameterTypes - Check whether a function's parameter types
762 // are all literal types. If so, return true. If not, produce a suitable
763 // diagnostic and return false.
764 static bool CheckConstexprParameterTypes(Sema &SemaRef,
765  const FunctionDecl *FD) {
766  unsigned ArgIndex = 0;
767  const FunctionProtoType *FT = FD->getType()->getAs<FunctionProtoType>();
769  e = FT->param_type_end();
770  i != e; ++i, ++ArgIndex) {
771  const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
772  SourceLocation ParamLoc = PD->getLocation();
773  if (!(*i)->isDependentType() &&
774  SemaRef.RequireLiteralType(ParamLoc, *i,
775  diag::err_constexpr_non_literal_param,
776  ArgIndex+1, PD->getSourceRange(),
777  isa<CXXConstructorDecl>(FD)))
778  return false;
779  }
780  return true;
781 }
782 
783 /// \brief Get diagnostic %select index for tag kind for
784 /// record diagnostic message.
785 /// WARNING: Indexes apply to particular diagnostics only!
786 ///
787 /// \returns diagnostic %select index.
788 static unsigned getRecordDiagFromTagKind(TagTypeKind Tag) {
789  switch (Tag) {
790  case TTK_Struct: return 0;
791  case TTK_Interface: return 1;
792  case TTK_Class: return 2;
793  default: llvm_unreachable("Invalid tag kind for record diagnostic!");
794  }
795 }
796 
797 // CheckConstexprFunctionDecl - Check whether a function declaration satisfies
798 // the requirements of a constexpr function definition or a constexpr
799 // constructor definition. If so, return true. If not, produce appropriate
800 // diagnostics and return false.
801 //
802 // This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360.
804  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
805  if (MD && MD->isInstance()) {
806  // C++11 [dcl.constexpr]p4:
807  // The definition of a constexpr constructor shall satisfy the following
808  // constraints:
809  // - the class shall not have any virtual base classes;
810  const CXXRecordDecl *RD = MD->getParent();
811  if (RD->getNumVBases()) {
812  Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base)
813  << isa<CXXConstructorDecl>(NewFD)
815  for (const auto &I : RD->vbases())
816  Diag(I.getLocStart(),
817  diag::note_constexpr_virtual_base_here) << I.getSourceRange();
818  return false;
819  }
820  }
821 
822  if (!isa<CXXConstructorDecl>(NewFD)) {
823  // C++11 [dcl.constexpr]p3:
824  // The definition of a constexpr function shall satisfy the following
825  // constraints:
826  // - it shall not be virtual;
827  const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
828  if (Method && Method->isVirtual()) {
829  Method = Method->getCanonicalDecl();
830  Diag(Method->getLocation(), diag::err_constexpr_virtual);
831 
832  // If it's not obvious why this function is virtual, find an overridden
833  // function which uses the 'virtual' keyword.
834  const CXXMethodDecl *WrittenVirtual = Method;
835  while (!WrittenVirtual->isVirtualAsWritten())
836  WrittenVirtual = *WrittenVirtual->begin_overridden_methods();
837  if (WrittenVirtual != Method)
838  Diag(WrittenVirtual->getLocation(),
839  diag::note_overridden_virtual_function);
840  return false;
841  }
842 
843  // - its return type shall be a literal type;
844  QualType RT = NewFD->getReturnType();
845  if (!RT->isDependentType() &&
846  RequireLiteralType(NewFD->getLocation(), RT,
847  diag::err_constexpr_non_literal_return))
848  return false;
849  }
850 
851  // - each of its parameter types shall be a literal type;
852  if (!CheckConstexprParameterTypes(*this, NewFD))
853  return false;
854 
855  return true;
856 }
857 
858 /// Check the given declaration statement is legal within a constexpr function
859 /// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.
860 ///
861 /// \return true if the body is OK (maybe only as an extension), false if we
862 /// have diagnosed a problem.
863 static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
864  DeclStmt *DS, SourceLocation &Cxx1yLoc) {
865  // C++11 [dcl.constexpr]p3 and p4:
866  // The definition of a constexpr function(p3) or constructor(p4) [...] shall
867  // contain only
868  for (const auto *DclIt : DS->decls()) {
869  switch (DclIt->getKind()) {
870  case Decl::StaticAssert:
871  case Decl::Using:
872  case Decl::UsingShadow:
873  case Decl::UsingDirective:
874  case Decl::UnresolvedUsingTypename:
875  case Decl::UnresolvedUsingValue:
876  // - static_assert-declarations
877  // - using-declarations,
878  // - using-directives,
879  continue;
880 
881  case Decl::Typedef:
882  case Decl::TypeAlias: {
883  // - typedef declarations and alias-declarations that do not define
884  // classes or enumerations,
885  const auto *TN = cast<TypedefNameDecl>(DclIt);
886  if (TN->getUnderlyingType()->isVariablyModifiedType()) {
887  // Don't allow variably-modified types in constexpr functions.
888  TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
889  SemaRef.Diag(TL.getBeginLoc(), diag::err_constexpr_vla)
890  << TL.getSourceRange() << TL.getType()
891  << isa<CXXConstructorDecl>(Dcl);
892  return false;
893  }
894  continue;
895  }
896 
897  case Decl::Enum:
898  case Decl::CXXRecord:
899  // C++1y allows types to be defined, not just declared.
900  if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition())
901  SemaRef.Diag(DS->getLocStart(),
902  SemaRef.getLangOpts().CPlusPlus14
903  ? diag::warn_cxx11_compat_constexpr_type_definition
904  : diag::ext_constexpr_type_definition)
905  << isa<CXXConstructorDecl>(Dcl);
906  continue;
907 
908  case Decl::EnumConstant:
909  case Decl::IndirectField:
910  case Decl::ParmVar:
911  // These can only appear with other declarations which are banned in
912  // C++11 and permitted in C++1y, so ignore them.
913  continue;
914 
915  case Decl::Var: {
916  // C++1y [dcl.constexpr]p3 allows anything except:
917  // a definition of a variable of non-literal type or of static or
918  // thread storage duration or for which no initialization is performed.
919  const auto *VD = cast<VarDecl>(DclIt);
920  if (VD->isThisDeclarationADefinition()) {
921  if (VD->isStaticLocal()) {
922  SemaRef.Diag(VD->getLocation(),
923  diag::err_constexpr_local_var_static)
924  << isa<CXXConstructorDecl>(Dcl)
925  << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
926  return false;
927  }
928  if (!VD->getType()->isDependentType() &&
929  SemaRef.RequireLiteralType(
930  VD->getLocation(), VD->getType(),
931  diag::err_constexpr_local_var_non_literal_type,
932  isa<CXXConstructorDecl>(Dcl)))
933  return false;
934  if (!VD->getType()->isDependentType() &&
935  !VD->hasInit() && !VD->isCXXForRangeDecl()) {
936  SemaRef.Diag(VD->getLocation(),
937  diag::err_constexpr_local_var_no_init)
938  << isa<CXXConstructorDecl>(Dcl);
939  return false;
940  }
941  }
942  SemaRef.Diag(VD->getLocation(),
943  SemaRef.getLangOpts().CPlusPlus14
944  ? diag::warn_cxx11_compat_constexpr_local_var
945  : diag::ext_constexpr_local_var)
946  << isa<CXXConstructorDecl>(Dcl);
947  continue;
948  }
949 
950  case Decl::NamespaceAlias:
951  case Decl::Function:
952  // These are disallowed in C++11 and permitted in C++1y. Allow them
953  // everywhere as an extension.
954  if (!Cxx1yLoc.isValid())
955  Cxx1yLoc = DS->getLocStart();
956  continue;
957 
958  default:
959  SemaRef.Diag(DS->getLocStart(), diag::err_constexpr_body_invalid_stmt)
960  << isa<CXXConstructorDecl>(Dcl);
961  return false;
962  }
963  }
964 
965  return true;
966 }
967 
968 /// Check that the given field is initialized within a constexpr constructor.
969 ///
970 /// \param Dcl The constexpr constructor being checked.
971 /// \param Field The field being checked. This may be a member of an anonymous
972 /// struct or union nested within the class being checked.
973 /// \param Inits All declarations, including anonymous struct/union members and
974 /// indirect members, for which any initialization was provided.
975 /// \param Diagnosed Set to true if an error is produced.
976 static void CheckConstexprCtorInitializer(Sema &SemaRef,
977  const FunctionDecl *Dcl,
978  FieldDecl *Field,
979  llvm::SmallSet<Decl*, 16> &Inits,
980  bool &Diagnosed) {
981  if (Field->isInvalidDecl())
982  return;
983 
984  if (Field->isUnnamedBitfield())
985  return;
986 
987  // Anonymous unions with no variant members and empty anonymous structs do not
988  // need to be explicitly initialized. FIXME: Anonymous structs that contain no
989  // indirect fields don't need initializing.
990  if (Field->isAnonymousStructOrUnion() &&
991  (Field->getType()->isUnionType()
993  : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
994  return;
995 
996  if (!Inits.count(Field)) {
997  if (!Diagnosed) {
998  SemaRef.Diag(Dcl->getLocation(), diag::err_constexpr_ctor_missing_init);
999  Diagnosed = true;
1000  }
1001  SemaRef.Diag(Field->getLocation(), diag::note_constexpr_ctor_missing_init);
1002  } else if (Field->isAnonymousStructOrUnion()) {
1003  const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
1004  for (auto *I : RD->fields())
1005  // If an anonymous union contains an anonymous struct of which any member
1006  // is initialized, all members must be initialized.
1007  if (!RD->isUnion() || Inits.count(I))
1008  CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed);
1009  }
1010 }
1011 
1012 /// Check the provided statement is allowed in a constexpr function
1013 /// definition.
1014 static bool
1016  SmallVectorImpl<SourceLocation> &ReturnStmts,
1017  SourceLocation &Cxx1yLoc) {
1018  // - its function-body shall be [...] a compound-statement that contains only
1019  switch (S->getStmtClass()) {
1020  case Stmt::NullStmtClass:
1021  // - null statements,
1022  return true;
1023 
1024  case Stmt::DeclStmtClass:
1025  // - static_assert-declarations
1026  // - using-declarations,
1027  // - using-directives,
1028  // - typedef declarations and alias-declarations that do not define
1029  // classes or enumerations,
1030  if (!CheckConstexprDeclStmt(SemaRef, Dcl, cast<DeclStmt>(S), Cxx1yLoc))
1031  return false;
1032  return true;
1033 
1034  case Stmt::ReturnStmtClass:
1035  // - and exactly one return statement;
1036  if (isa<CXXConstructorDecl>(Dcl)) {
1037  // C++1y allows return statements in constexpr constructors.
1038  if (!Cxx1yLoc.isValid())
1039  Cxx1yLoc = S->getLocStart();
1040  return true;
1041  }
1042 
1043  ReturnStmts.push_back(S->getLocStart());
1044  return true;
1045 
1046  case Stmt::CompoundStmtClass: {
1047  // C++1y allows compound-statements.
1048  if (!Cxx1yLoc.isValid())
1049  Cxx1yLoc = S->getLocStart();
1050 
1051  CompoundStmt *CompStmt = cast<CompoundStmt>(S);
1052  for (auto *BodyIt : CompStmt->body()) {
1053  if (!CheckConstexprFunctionStmt(SemaRef, Dcl, BodyIt, ReturnStmts,
1054  Cxx1yLoc))
1055  return false;
1056  }
1057  return true;
1058  }
1059 
1060  case Stmt::AttributedStmtClass:
1061  if (!Cxx1yLoc.isValid())
1062  Cxx1yLoc = S->getLocStart();
1063  return true;
1064 
1065  case Stmt::IfStmtClass: {
1066  // C++1y allows if-statements.
1067  if (!Cxx1yLoc.isValid())
1068  Cxx1yLoc = S->getLocStart();
1069 
1070  IfStmt *If = cast<IfStmt>(S);
1071  if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
1072  Cxx1yLoc))
1073  return false;
1074  if (If->getElse() &&
1075  !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
1076  Cxx1yLoc))
1077  return false;
1078  return true;
1079  }
1080 
1081  case Stmt::WhileStmtClass:
1082  case Stmt::DoStmtClass:
1083  case Stmt::ForStmtClass:
1084  case Stmt::CXXForRangeStmtClass:
1085  case Stmt::ContinueStmtClass:
1086  // C++1y allows all of these. We don't allow them as extensions in C++11,
1087  // because they don't make sense without variable mutation.
1088  if (!SemaRef.getLangOpts().CPlusPlus14)
1089  break;
1090  if (!Cxx1yLoc.isValid())
1091  Cxx1yLoc = S->getLocStart();
1092  for (Stmt *SubStmt : S->children())
1093  if (SubStmt &&
1094  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
1095  Cxx1yLoc))
1096  return false;
1097  return true;
1098 
1099  case Stmt::SwitchStmtClass:
1100  case Stmt::CaseStmtClass:
1101  case Stmt::DefaultStmtClass:
1102  case Stmt::BreakStmtClass:
1103  // C++1y allows switch-statements, and since they don't need variable
1104  // mutation, we can reasonably allow them in C++11 as an extension.
1105  if (!Cxx1yLoc.isValid())
1106  Cxx1yLoc = S->getLocStart();
1107  for (Stmt *SubStmt : S->children())
1108  if (SubStmt &&
1109  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
1110  Cxx1yLoc))
1111  return false;
1112  return true;
1113 
1114  default:
1115  if (!isa<Expr>(S))
1116  break;
1117 
1118  // C++1y allows expression-statements.
1119  if (!Cxx1yLoc.isValid())
1120  Cxx1yLoc = S->getLocStart();
1121  return true;
1122  }
1123 
1124  SemaRef.Diag(S->getLocStart(), diag::err_constexpr_body_invalid_stmt)
1125  << isa<CXXConstructorDecl>(Dcl);
1126  return false;
1127 }
1128 
1129 /// Check the body for the given constexpr function declaration only contains
1130 /// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.
1131 ///
1132 /// \return true if the body is OK, false if we have diagnosed a problem.
1134  if (isa<CXXTryStmt>(Body)) {
1135  // C++11 [dcl.constexpr]p3:
1136  // The definition of a constexpr function shall satisfy the following
1137  // constraints: [...]
1138  // - its function-body shall be = delete, = default, or a
1139  // compound-statement
1140  //
1141  // C++11 [dcl.constexpr]p4:
1142  // In the definition of a constexpr constructor, [...]
1143  // - its function-body shall not be a function-try-block;
1144  Diag(Body->getLocStart(), diag::err_constexpr_function_try_block)
1145  << isa<CXXConstructorDecl>(Dcl);
1146  return false;
1147  }
1148 
1149  SmallVector<SourceLocation, 4> ReturnStmts;
1150 
1151  // - its function-body shall be [...] a compound-statement that contains only
1152  // [... list of cases ...]
1153  CompoundStmt *CompBody = cast<CompoundStmt>(Body);
1154  SourceLocation Cxx1yLoc;
1155  for (auto *BodyIt : CompBody->body()) {
1156  if (!CheckConstexprFunctionStmt(*this, Dcl, BodyIt, ReturnStmts, Cxx1yLoc))
1157  return false;
1158  }
1159 
1160  if (Cxx1yLoc.isValid())
1161  Diag(Cxx1yLoc,
1162  getLangOpts().CPlusPlus14
1163  ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
1164  : diag::ext_constexpr_body_invalid_stmt)
1165  << isa<CXXConstructorDecl>(Dcl);
1166 
1167  if (const CXXConstructorDecl *Constructor
1168  = dyn_cast<CXXConstructorDecl>(Dcl)) {
1169  const CXXRecordDecl *RD = Constructor->getParent();
1170  // DR1359:
1171  // - every non-variant non-static data member and base class sub-object
1172  // shall be initialized;
1173  // DR1460:
1174  // - if the class is a union having variant members, exactly one of them
1175  // shall be initialized;
1176  if (RD->isUnion()) {
1177  if (Constructor->getNumCtorInitializers() == 0 &&
1178  RD->hasVariantMembers()) {
1179  Diag(Dcl->getLocation(), diag::err_constexpr_union_ctor_no_init);
1180  return false;
1181  }
1182  } else if (!Constructor->isDependentContext() &&
1183  !Constructor->isDelegatingConstructor()) {
1184  assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases");
1185 
1186  // Skip detailed checking if we have enough initializers, and we would
1187  // allow at most one initializer per member.
1188  bool AnyAnonStructUnionMembers = false;
1189  unsigned Fields = 0;
1191  E = RD->field_end(); I != E; ++I, ++Fields) {
1192  if (I->isAnonymousStructOrUnion()) {
1193  AnyAnonStructUnionMembers = true;
1194  break;
1195  }
1196  }
1197  // DR1460:
1198  // - if the class is a union-like class, but is not a union, for each of
1199  // its anonymous union members having variant members, exactly one of
1200  // them shall be initialized;
1201  if (AnyAnonStructUnionMembers ||
1202  Constructor->getNumCtorInitializers() != RD->getNumBases() + Fields) {
1203  // Check initialization of non-static data members. Base classes are
1204  // always initialized so do not need to be checked. Dependent bases
1205  // might not have initializers in the member initializer list.
1206  llvm::SmallSet<Decl*, 16> Inits;
1207  for (const auto *I: Constructor->inits()) {
1208  if (FieldDecl *FD = I->getMember())
1209  Inits.insert(FD);
1210  else if (IndirectFieldDecl *ID = I->getIndirectMember())
1211  Inits.insert(ID->chain_begin(), ID->chain_end());
1212  }
1213 
1214  bool Diagnosed = false;
1215  for (auto *I : RD->fields())
1216  CheckConstexprCtorInitializer(*this, Dcl, I, Inits, Diagnosed);
1217  if (Diagnosed)
1218  return false;
1219  }
1220  }
1221  } else {
1222  if (ReturnStmts.empty()) {
1223  // C++1y doesn't require constexpr functions to contain a 'return'
1224  // statement. We still do, unless the return type might be void, because
1225  // otherwise if there's no return statement, the function cannot
1226  // be used in a core constant expression.
1227  bool OK = getLangOpts().CPlusPlus14 &&
1228  (Dcl->getReturnType()->isVoidType() ||
1229  Dcl->getReturnType()->isDependentType());
1230  Diag(Dcl->getLocation(),
1231  OK ? diag::warn_cxx11_compat_constexpr_body_no_return
1232  : diag::err_constexpr_body_no_return);
1233  if (!OK)
1234  return false;
1235  } else if (ReturnStmts.size() > 1) {
1236  Diag(ReturnStmts.back(),
1237  getLangOpts().CPlusPlus14
1238  ? diag::warn_cxx11_compat_constexpr_body_multiple_return
1239  : diag::ext_constexpr_body_multiple_return);
1240  for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
1241  Diag(ReturnStmts[I], diag::note_constexpr_body_previous_return);
1242  }
1243  }
1244 
1245  // C++11 [dcl.constexpr]p5:
1246  // if no function argument values exist such that the function invocation
1247  // substitution would produce a constant expression, the program is
1248  // ill-formed; no diagnostic required.
1249  // C++11 [dcl.constexpr]p3:
1250  // - every constructor call and implicit conversion used in initializing the
1251  // return value shall be one of those allowed in a constant expression.
1252  // C++11 [dcl.constexpr]p4:
1253  // - every constructor involved in initializing non-static data members and
1254  // base class sub-objects shall be a constexpr constructor.
1256  if (!Expr::isPotentialConstantExpr(Dcl, Diags)) {
1257  Diag(Dcl->getLocation(), diag::ext_constexpr_function_never_constant_expr)
1258  << isa<CXXConstructorDecl>(Dcl);
1259  for (size_t I = 0, N = Diags.size(); I != N; ++I)
1260  Diag(Diags[I].first, Diags[I].second);
1261  // Don't return false here: we allow this for compatibility in
1262  // system headers.
1263  }
1264 
1265  return true;
1266 }
1267 
1268 /// isCurrentClassName - Determine whether the identifier II is the
1269 /// name of the class type currently being defined. In the case of
1270 /// nested classes, this will only return true if II is the name of
1271 /// the innermost class.
1273  const CXXScopeSpec *SS) {
1274  assert(getLangOpts().CPlusPlus && "No class names in C!");
1275 
1276  CXXRecordDecl *CurDecl;
1277  if (SS && SS->isSet() && !SS->isInvalid()) {
1278  DeclContext *DC = computeDeclContext(*SS, true);
1279  CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
1280  } else
1281  CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
1282 
1283  if (CurDecl && CurDecl->getIdentifier())
1284  return &II == CurDecl->getIdentifier();
1285  return false;
1286 }
1287 
1288 /// \brief Determine whether the identifier II is a typo for the name of
1289 /// the class type currently being defined. If so, update it to the identifier
1290 /// that should have been used.
1292  assert(getLangOpts().CPlusPlus && "No class names in C!");
1293 
1294  if (!getLangOpts().SpellChecking)
1295  return false;
1296 
1297  CXXRecordDecl *CurDecl;
1298  if (SS && SS->isSet() && !SS->isInvalid()) {
1299  DeclContext *DC = computeDeclContext(*SS, true);
1300  CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
1301  } else
1302  CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
1303 
1304  if (CurDecl && CurDecl->getIdentifier() && II != CurDecl->getIdentifier() &&
1305  3 * II->getName().edit_distance(CurDecl->getIdentifier()->getName())
1306  < II->getLength()) {
1307  II = CurDecl->getIdentifier();
1308  return true;
1309  }
1310 
1311  return false;
1312 }
1313 
1314 /// \brief Determine whether the given class is a base class of the given
1315 /// class, including looking at dependent bases.
1316 static bool findCircularInheritance(const CXXRecordDecl *Class,
1317  const CXXRecordDecl *Current) {
1319 
1320  Class = Class->getCanonicalDecl();
1321  while (true) {
1322  for (const auto &I : Current->bases()) {
1323  CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl();
1324  if (!Base)
1325  continue;
1326 
1327  Base = Base->getDefinition();
1328  if (!Base)
1329  continue;
1330 
1331  if (Base->getCanonicalDecl() == Class)
1332  return true;
1333 
1334  Queue.push_back(Base);
1335  }
1336 
1337  if (Queue.empty())
1338  return false;
1339 
1340  Current = Queue.pop_back_val();
1341  }
1342 
1343  return false;
1344 }
1345 
1346 /// \brief Check the validity of a C++ base class specifier.
1347 ///
1348 /// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
1349 /// and returns NULL otherwise.
1352  SourceRange SpecifierRange,
1353  bool Virtual, AccessSpecifier Access,
1354  TypeSourceInfo *TInfo,
1355  SourceLocation EllipsisLoc) {
1356  QualType BaseType = TInfo->getType();
1357 
1358  // C++ [class.union]p1:
1359  // A union shall not have base classes.
1360  if (Class->isUnion()) {
1361  Diag(Class->getLocation(), diag::err_base_clause_on_union)
1362  << SpecifierRange;
1363  return nullptr;
1364  }
1365 
1366  if (EllipsisLoc.isValid() &&
1368  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
1369  << TInfo->getTypeLoc().getSourceRange();
1370  EllipsisLoc = SourceLocation();
1371  }
1372 
1373  SourceLocation BaseLoc = TInfo->getTypeLoc().getBeginLoc();
1374 
1375  if (BaseType->isDependentType()) {
1376  // Make sure that we don't have circular inheritance among our dependent
1377  // bases. For non-dependent bases, the check for completeness below handles
1378  // this.
1379  if (CXXRecordDecl *BaseDecl = BaseType->getAsCXXRecordDecl()) {
1380  if (BaseDecl->getCanonicalDecl() == Class->getCanonicalDecl() ||
1381  ((BaseDecl = BaseDecl->getDefinition()) &&
1382  findCircularInheritance(Class, BaseDecl))) {
1383  Diag(BaseLoc, diag::err_circular_inheritance)
1384  << BaseType << Context.getTypeDeclType(Class);
1385 
1386  if (BaseDecl->getCanonicalDecl() != Class->getCanonicalDecl())
1387  Diag(BaseDecl->getLocation(), diag::note_previous_decl)
1388  << BaseType;
1389 
1390  return nullptr;
1391  }
1392  }
1393 
1394  return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
1395  Class->getTagKind() == TTK_Class,
1396  Access, TInfo, EllipsisLoc);
1397  }
1398 
1399  // Base specifiers must be record types.
1400  if (!BaseType->isRecordType()) {
1401  Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
1402  return nullptr;
1403  }
1404 
1405  // C++ [class.union]p1:
1406  // A union shall not be used as a base class.
1407  if (BaseType->isUnionType()) {
1408  Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
1409  return nullptr;
1410  }
1411 
1412  // For the MS ABI, propagate DLL attributes to base class templates.
1414  if (Attr *ClassAttr = getDLLAttr(Class)) {
1415  if (auto *BaseTemplate = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
1416  BaseType->getAsCXXRecordDecl())) {
1417  propagateDLLAttrToBaseClassTemplate(Class, ClassAttr, BaseTemplate,
1418  BaseLoc);
1419  }
1420  }
1421  }
1422 
1423  // C++ [class.derived]p2:
1424  // The class-name in a base-specifier shall not be an incompletely
1425  // defined class.
1426  if (RequireCompleteType(BaseLoc, BaseType,
1427  diag::err_incomplete_base_class, SpecifierRange)) {
1428  Class->setInvalidDecl();
1429  return nullptr;
1430  }
1431 
1432  // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
1433  RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl();
1434  assert(BaseDecl && "Record type has no declaration");
1435  BaseDecl = BaseDecl->getDefinition();
1436  assert(BaseDecl && "Base type is not incomplete, but has no definition");
1437  CXXRecordDecl *CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
1438  assert(CXXBaseDecl && "Base type is not a C++ type");
1439 
1440  // A class which contains a flexible array member is not suitable for use as a
1441  // base class:
1442  // - If the layout determines that a base comes before another base,
1443  // the flexible array member would index into the subsequent base.
1444  // - If the layout determines that base comes before the derived class,
1445  // the flexible array member would index into the derived class.
1446  if (CXXBaseDecl->hasFlexibleArrayMember()) {
1447  Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
1448  << CXXBaseDecl->getDeclName();
1449  return nullptr;
1450  }
1451 
1452  // C++ [class]p3:
1453  // If a class is marked final and it appears as a base-type-specifier in
1454  // base-clause, the program is ill-formed.
1455  if (FinalAttr *FA = CXXBaseDecl->getAttr<FinalAttr>()) {
1456  Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
1457  << CXXBaseDecl->getDeclName()
1458  << FA->isSpelledAsSealed();
1459  Diag(CXXBaseDecl->getLocation(), diag::note_entity_declared_at)
1460  << CXXBaseDecl->getDeclName() << FA->getRange();
1461  return nullptr;
1462  }
1463 
1464  if (BaseDecl->isInvalidDecl())
1465  Class->setInvalidDecl();
1466 
1467  // Create the base specifier.
1468  return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
1469  Class->getTagKind() == TTK_Class,
1470  Access, TInfo, EllipsisLoc);
1471 }
1472 
1473 /// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
1474 /// one entry in the base class list of a class specifier, for
1475 /// example:
1476 /// class foo : public bar, virtual private baz {
1477 /// 'public bar' and 'virtual private baz' are each base-specifiers.
1478 BaseResult
1479 Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange,
1480  ParsedAttributes &Attributes,
1481  bool Virtual, AccessSpecifier Access,
1482  ParsedType basetype, SourceLocation BaseLoc,
1483  SourceLocation EllipsisLoc) {
1484  if (!classdecl)
1485  return true;
1486 
1487  AdjustDeclIfTemplate(classdecl);
1488  CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl);
1489  if (!Class)
1490  return true;
1491 
1492  // We haven't yet attached the base specifiers.
1493  Class->setIsParsingBaseSpecifiers();
1494 
1495  // We do not support any C++11 attributes on base-specifiers yet.
1496  // Diagnose any attributes we see.
1497  if (!Attributes.empty()) {
1498  for (AttributeList *Attr = Attributes.getList(); Attr;
1499  Attr = Attr->getNext()) {
1500  if (Attr->isInvalid() ||
1502  continue;
1503  Diag(Attr->getLoc(),
1505  ? diag::warn_unknown_attribute_ignored
1506  : diag::err_base_specifier_attribute)
1507  << Attr->getName();
1508  }
1509  }
1510 
1511  TypeSourceInfo *TInfo = nullptr;
1512  GetTypeFromParser(basetype, &TInfo);
1513 
1514  if (EllipsisLoc.isInvalid() &&
1515  DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo,
1516  UPPC_BaseType))
1517  return true;
1518 
1519  if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
1520  Virtual, Access, TInfo,
1521  EllipsisLoc))
1522  return BaseSpec;
1523  else
1524  Class->setInvalidDecl();
1525 
1526  return true;
1527 }
1528 
1529 /// Use small set to collect indirect bases. As this is only used
1530 /// locally, there's no need to abstract the small size parameter.
1531 typedef llvm::SmallPtrSet<QualType, 4> IndirectBaseSet;
1532 
1533 /// \brief Recursively add the bases of Type. Don't add Type itself.
1534 static void
1536  const QualType &Type)
1537 {
1538  // Even though the incoming type is a base, it might not be
1539  // a class -- it could be a template parm, for instance.
1540  if (auto Rec = Type->getAs<RecordType>()) {
1541  auto Decl = Rec->getAsCXXRecordDecl();
1542 
1543  // Iterate over its bases.
1544  for (const auto &BaseSpec : Decl->bases()) {
1545  QualType Base = Context.getCanonicalType(BaseSpec.getType())
1546  .getUnqualifiedType();
1547  if (Set.insert(Base).second)
1548  // If we've not already seen it, recurse.
1549  NoteIndirectBases(Context, Set, Base);
1550  }
1551  }
1552 }
1553 
1554 /// \brief Performs the actual work of attaching the given base class
1555 /// specifiers to a C++ class.
1558  if (Bases.empty())
1559  return false;
1560 
1561  // Used to keep track of which base types we have already seen, so
1562  // that we can properly diagnose redundant direct base types. Note
1563  // that the key is always the unqualified canonical type of the base
1564  // class.
1565  std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
1566 
1567  // Used to track indirect bases so we can see if a direct base is
1568  // ambiguous.
1569  IndirectBaseSet IndirectBaseTypes;
1570 
1571  // Copy non-redundant base specifiers into permanent storage.
1572  unsigned NumGoodBases = 0;
1573  bool Invalid = false;
1574  for (unsigned idx = 0; idx < Bases.size(); ++idx) {
1575  QualType NewBaseType
1576  = Context.getCanonicalType(Bases[idx]->getType());
1577  NewBaseType = NewBaseType.getLocalUnqualifiedType();
1578 
1579  CXXBaseSpecifier *&KnownBase = KnownBaseTypes[NewBaseType];
1580  if (KnownBase) {
1581  // C++ [class.mi]p3:
1582  // A class shall not be specified as a direct base class of a
1583  // derived class more than once.
1584  Diag(Bases[idx]->getLocStart(),
1585  diag::err_duplicate_base_class)
1586  << KnownBase->getType()
1587  << Bases[idx]->getSourceRange();
1588 
1589  // Delete the duplicate base class specifier; we're going to
1590  // overwrite its pointer later.
1591  Context.Deallocate(Bases[idx]);
1592 
1593  Invalid = true;
1594  } else {
1595  // Okay, add this new base class.
1596  KnownBase = Bases[idx];
1597  Bases[NumGoodBases++] = Bases[idx];
1598 
1599  // Note this base's direct & indirect bases, if there could be ambiguity.
1600  if (Bases.size() > 1)
1601  NoteIndirectBases(Context, IndirectBaseTypes, NewBaseType);
1602 
1603  if (const RecordType *Record = NewBaseType->getAs<RecordType>()) {
1604  const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
1605  if (Class->isInterface() &&
1606  (!RD->isInterface() ||
1607  KnownBase->getAccessSpecifier() != AS_public)) {
1608  // The Microsoft extension __interface does not permit bases that
1609  // are not themselves public interfaces.
1610  Diag(KnownBase->getLocStart(), diag::err_invalid_base_in_interface)
1611  << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getName()
1612  << RD->getSourceRange();
1613  Invalid = true;
1614  }
1615  if (RD->hasAttr<WeakAttr>())
1616  Class->addAttr(WeakAttr::CreateImplicit(Context));
1617  }
1618  }
1619  }
1620 
1621  // Attach the remaining base class specifiers to the derived class.
1622  Class->setBases(Bases.data(), NumGoodBases);
1623 
1624  for (unsigned idx = 0; idx < NumGoodBases; ++idx) {
1625  // Check whether this direct base is inaccessible due to ambiguity.
1626  QualType BaseType = Bases[idx]->getType();
1627  CanQualType CanonicalBase = Context.getCanonicalType(BaseType)
1628  .getUnqualifiedType();
1629 
1630  if (IndirectBaseTypes.count(CanonicalBase)) {
1631  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1632  /*DetectVirtual=*/true);
1633  bool found
1634  = Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
1635  assert(found);
1636  (void)found;
1637 
1638  if (Paths.isAmbiguous(CanonicalBase))
1639  Diag(Bases[idx]->getLocStart (), diag::warn_inaccessible_base_class)
1640  << BaseType << getAmbiguousPathsDisplayString(Paths)
1641  << Bases[idx]->getSourceRange();
1642  else
1643  assert(Bases[idx]->isVirtual());
1644  }
1645 
1646  // Delete the base class specifier, since its data has been copied
1647  // into the CXXRecordDecl.
1648  Context.Deallocate(Bases[idx]);
1649  }
1650 
1651  return Invalid;
1652 }
1653 
1654 /// ActOnBaseSpecifiers - Attach the given base specifiers to the
1655 /// class, after checking whether there are any duplicate base
1656 /// classes.
1657 void Sema::ActOnBaseSpecifiers(Decl *ClassDecl,
1659  if (!ClassDecl || Bases.empty())
1660  return;
1661 
1662  AdjustDeclIfTemplate(ClassDecl);
1663  AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), Bases);
1664 }
1665 
1666 /// \brief Determine whether the type \p Derived is a C++ class that is
1667 /// derived from the type \p Base.
1669  if (!getLangOpts().CPlusPlus)
1670  return false;
1671 
1672  CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
1673  if (!DerivedRD)
1674  return false;
1675 
1676  CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
1677  if (!BaseRD)
1678  return false;
1679 
1680  // If either the base or the derived type is invalid, don't try to
1681  // check whether one is derived from the other.
1682  if (BaseRD->isInvalidDecl() || DerivedRD->isInvalidDecl())
1683  return false;
1684 
1685  // FIXME: In a modules build, do we need the entire path to be visible for us
1686  // to be able to use the inheritance relationship?
1687  if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
1688  return false;
1689 
1690  return DerivedRD->isDerivedFrom(BaseRD);
1691 }
1692 
1693 /// \brief Determine whether the type \p Derived is a C++ class that is
1694 /// derived from the type \p Base.
1696  CXXBasePaths &Paths) {
1697  if (!getLangOpts().CPlusPlus)
1698  return false;
1699 
1700  CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
1701  if (!DerivedRD)
1702  return false;
1703 
1704  CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
1705  if (!BaseRD)
1706  return false;
1707 
1708  if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
1709  return false;
1710 
1711  return DerivedRD->isDerivedFrom(BaseRD, Paths);
1712 }
1713 
1715  CXXCastPath &BasePathArray) {
1716  assert(BasePathArray.empty() && "Base path array must be empty!");
1717  assert(Paths.isRecordingPaths() && "Must record paths!");
1718 
1719  const CXXBasePath &Path = Paths.front();
1720 
1721  // We first go backward and check if we have a virtual base.
1722  // FIXME: It would be better if CXXBasePath had the base specifier for
1723  // the nearest virtual base.
1724  unsigned Start = 0;
1725  for (unsigned I = Path.size(); I != 0; --I) {
1726  if (Path[I - 1].Base->isVirtual()) {
1727  Start = I - 1;
1728  break;
1729  }
1730  }
1731 
1732  // Now add all bases.
1733  for (unsigned I = Start, E = Path.size(); I != E; ++I)
1734  BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
1735 }
1736 
1737 /// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
1738 /// conversion (where Derived and Base are class types) is
1739 /// well-formed, meaning that the conversion is unambiguous (and
1740 /// that all of the base classes are accessible). Returns true
1741 /// and emits a diagnostic if the code is ill-formed, returns false
1742 /// otherwise. Loc is the location where this routine should point to
1743 /// if there is an error, and Range is the source range to highlight
1744 /// if there is an error.
1745 ///
1746 /// If either InaccessibleBaseID or AmbigiousBaseConvID are 0, then the
1747 /// diagnostic for the respective type of error will be suppressed, but the
1748 /// check for ill-formed code will still be performed.
1749 bool
1751  unsigned InaccessibleBaseID,
1752  unsigned AmbigiousBaseConvID,
1753  SourceLocation Loc, SourceRange Range,
1755  CXXCastPath *BasePath,
1756  bool IgnoreAccess) {
1757  // First, determine whether the path from Derived to Base is
1758  // ambiguous. This is slightly more expensive than checking whether
1759  // the Derived to Base conversion exists, because here we need to
1760  // explore multiple paths to determine if there is an ambiguity.
1761  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1762  /*DetectVirtual=*/false);
1763  bool DerivationOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
1764  assert(DerivationOkay &&
1765  "Can only be used with a derived-to-base conversion");
1766  (void)DerivationOkay;
1767 
1769  if (!IgnoreAccess) {
1770  // Check that the base class can be accessed.
1771  switch (CheckBaseClassAccess(Loc, Base, Derived, Paths.front(),
1772  InaccessibleBaseID)) {
1773  case AR_inaccessible:
1774  return true;
1775  case AR_accessible:
1776  case AR_dependent:
1777  case AR_delayed:
1778  break;
1779  }
1780  }
1781 
1782  // Build a base path if necessary.
1783  if (BasePath)
1784  BuildBasePathArray(Paths, *BasePath);
1785  return false;
1786  }
1787 
1788  if (AmbigiousBaseConvID) {
1789  // We know that the derived-to-base conversion is ambiguous, and
1790  // we're going to produce a diagnostic. Perform the derived-to-base
1791  // search just one more time to compute all of the possible paths so
1792  // that we can print them out. This is more expensive than any of
1793  // the previous derived-to-base checks we've done, but at this point
1794  // performance isn't as much of an issue.
1795  Paths.clear();
1796  Paths.setRecordingPaths(true);
1797  bool StillOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
1798  assert(StillOkay && "Can only be used with a derived-to-base conversion");
1799  (void)StillOkay;
1800 
1801  // Build up a textual representation of the ambiguous paths, e.g.,
1802  // D -> B -> A, that will be used to illustrate the ambiguous
1803  // conversions in the diagnostic. We only print one of the paths
1804  // to each base class subobject.
1805  std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
1806 
1807  Diag(Loc, AmbigiousBaseConvID)
1808  << Derived << Base << PathDisplayStr << Range << Name;
1809  }
1810  return true;
1811 }
1812 
1813 bool
1815  SourceLocation Loc, SourceRange Range,
1816  CXXCastPath *BasePath,
1817  bool IgnoreAccess) {
1819  Derived, Base, diag::err_upcast_to_inaccessible_base,
1820  diag::err_ambiguous_derived_to_base_conv, Loc, Range, DeclarationName(),
1821  BasePath, IgnoreAccess);
1822 }
1823 
1824 
1825 /// @brief Builds a string representing ambiguous paths from a
1826 /// specific derived class to different subobjects of the same base
1827 /// class.
1828 ///
1829 /// This function builds a string that can be used in error messages
1830 /// to show the different paths that one can take through the
1831 /// inheritance hierarchy to go from the derived class to different
1832 /// subobjects of a base class. The result looks something like this:
1833 /// @code
1834 /// struct D -> struct B -> struct A
1835 /// struct D -> struct C -> struct A
1836 /// @endcode
1838  std::string PathDisplayStr;
1839  std::set<unsigned> DisplayedPaths;
1840  for (CXXBasePaths::paths_iterator Path = Paths.begin();
1841  Path != Paths.end(); ++Path) {
1842  if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
1843  // We haven't displayed a path to this particular base
1844  // class subobject yet.
1845  PathDisplayStr += "\n ";
1846  PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
1847  for (CXXBasePath::const_iterator Element = Path->begin();
1848  Element != Path->end(); ++Element)
1849  PathDisplayStr += " -> " + Element->Base->getType().getAsString();
1850  }
1851  }
1852 
1853  return PathDisplayStr;
1854 }
1855 
1856 //===----------------------------------------------------------------------===//
1857 // C++ class member Handling
1858 //===----------------------------------------------------------------------===//
1859 
1860 /// ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
1862  SourceLocation ASLoc,
1864  AttributeList *Attrs) {
1865  assert(Access != AS_none && "Invalid kind for syntactic access specifier!");
1867  ASLoc, ColonLoc);
1868  CurContext->addHiddenDecl(ASDecl);
1869  return ProcessAccessDeclAttributeList(ASDecl, Attrs);
1870 }
1871 
1872 /// CheckOverrideControl - Check C++11 override control semantics.
1874  if (D->isInvalidDecl())
1875  return;
1876 
1877  // We only care about "override" and "final" declarations.
1878  if (!D->hasAttr<OverrideAttr>() && !D->hasAttr<FinalAttr>())
1879  return;
1880 
1881  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
1882 
1883  // We can't check dependent instance methods.
1884  if (MD && MD->isInstance() &&
1885  (MD->getParent()->hasAnyDependentBases() ||
1886  MD->getType()->isDependentType()))
1887  return;
1888 
1889  if (MD && !MD->isVirtual()) {
1890  // If we have a non-virtual method, check if if hides a virtual method.
1891  // (In that case, it's most likely the method has the wrong type.)
1892  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
1893  FindHiddenVirtualMethods(MD, OverloadedMethods);
1894 
1895  if (!OverloadedMethods.empty()) {
1896  if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
1897  Diag(OA->getLocation(),
1898  diag::override_keyword_hides_virtual_member_function)
1899  << "override" << (OverloadedMethods.size() > 1);
1900  } else if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
1901  Diag(FA->getLocation(),
1902  diag::override_keyword_hides_virtual_member_function)
1903  << (FA->isSpelledAsSealed() ? "sealed" : "final")
1904  << (OverloadedMethods.size() > 1);
1905  }
1906  NoteHiddenVirtualMethods(MD, OverloadedMethods);
1907  MD->setInvalidDecl();
1908  return;
1909  }
1910  // Fall through into the general case diagnostic.
1911  // FIXME: We might want to attempt typo correction here.
1912  }
1913 
1914  if (!MD || !MD->isVirtual()) {
1915  if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
1916  Diag(OA->getLocation(),
1917  diag::override_keyword_only_allowed_on_virtual_member_functions)
1918  << "override" << FixItHint::CreateRemoval(OA->getLocation());
1919  D->dropAttr<OverrideAttr>();
1920  }
1921  if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
1922  Diag(FA->getLocation(),
1923  diag::override_keyword_only_allowed_on_virtual_member_functions)
1924  << (FA->isSpelledAsSealed() ? "sealed" : "final")
1925  << FixItHint::CreateRemoval(FA->getLocation());
1926  D->dropAttr<FinalAttr>();
1927  }
1928  return;
1929  }
1930 
1931  // C++11 [class.virtual]p5:
1932  // If a function is marked with the virt-specifier override and
1933  // does not override a member function of a base class, the program is
1934  // ill-formed.
1935  bool HasOverriddenMethods =
1937  if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)
1938  Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding)
1939  << MD->getDeclName();
1940 }
1941 
1943  if (D->isInvalidDecl() || D->hasAttr<OverrideAttr>())
1944  return;
1945  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
1946  if (!MD || MD->isImplicit() || MD->hasAttr<FinalAttr>() ||
1947  isa<CXXDestructorDecl>(MD))
1948  return;
1949 
1950  SourceLocation Loc = MD->getLocation();
1951  SourceLocation SpellingLoc = Loc;
1952  if (getSourceManager().isMacroArgExpansion(Loc))
1953  SpellingLoc = getSourceManager().getImmediateExpansionRange(Loc).first;
1954  SpellingLoc = getSourceManager().getSpellingLoc(SpellingLoc);
1955  if (SpellingLoc.isValid() && getSourceManager().isInSystemHeader(SpellingLoc))
1956  return;
1957 
1958  if (MD->size_overridden_methods() > 0) {
1959  Diag(MD->getLocation(), diag::warn_function_marked_not_override_overriding)
1960  << MD->getDeclName();
1961  const CXXMethodDecl *OMD = *MD->begin_overridden_methods();
1962  Diag(OMD->getLocation(), diag::note_overridden_virtual_function);
1963  }
1964 }
1965 
1966 /// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member
1967 /// function overrides a virtual member function marked 'final', according to
1968 /// C++11 [class.virtual]p4.
1970  const CXXMethodDecl *Old) {
1971  FinalAttr *FA = Old->getAttr<FinalAttr>();
1972  if (!FA)
1973  return false;
1974 
1975  Diag(New->getLocation(), diag::err_final_function_overridden)
1976  << New->getDeclName()
1977  << FA->isSpelledAsSealed();
1978  Diag(Old->getLocation(), diag::note_overridden_virtual_function);
1979  return true;
1980 }
1981 
1982 static bool InitializationHasSideEffects(const FieldDecl &FD) {
1983  const Type *T = FD.getType()->getBaseElementTypeUnsafe();
1984  // FIXME: Destruction of ObjC lifetime types has side-effects.
1985  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1986  return !RD->isCompleteDefinition() ||
1987  !RD->hasTrivialDefaultConstructor() ||
1988  !RD->hasTrivialDestructor();
1989  return false;
1990 }
1991 
1993  for (AttributeList *it = list; it != nullptr; it = it->getNext())
1994  if (it->isDeclspecPropertyAttribute())
1995  return it;
1996  return nullptr;
1997 }
1998 
1999 /// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
2000 /// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
2001 /// bitfield width if there is one, 'InitExpr' specifies the initializer if
2002 /// one has been parsed, and 'InitStyle' is set if an in-class initializer is
2003 /// present (but parsing it has been deferred).
2004 NamedDecl *
2006  MultiTemplateParamsArg TemplateParameterLists,
2007  Expr *BW, const VirtSpecifiers &VS,
2008  InClassInitStyle InitStyle) {
2009  const DeclSpec &DS = D.getDeclSpec();
2011  DeclarationName Name = NameInfo.getName();
2012  SourceLocation Loc = NameInfo.getLoc();
2013 
2014  // For anonymous bitfields, the location should point to the type.
2015  if (Loc.isInvalid())
2016  Loc = D.getLocStart();
2017 
2018  Expr *BitWidth = static_cast<Expr*>(BW);
2019 
2020  assert(isa<CXXRecordDecl>(CurContext));
2021  assert(!DS.isFriendSpecified());
2022 
2023  bool isFunc = D.isDeclarationOfFunction();
2024 
2025  if (cast<CXXRecordDecl>(CurContext)->isInterface()) {
2026  // The Microsoft extension __interface only permits public member functions
2027  // and prohibits constructors, destructors, operators, non-public member
2028  // functions, static methods and data members.
2029  unsigned InvalidDecl;
2030  bool ShowDeclName = true;
2031  if (!isFunc)
2032  InvalidDecl = (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) ? 0 : 1;
2033  else if (AS != AS_public)
2034  InvalidDecl = 2;
2035  else if (DS.getStorageClassSpec() == DeclSpec::SCS_static)
2036  InvalidDecl = 3;
2037  else switch (Name.getNameKind()) {
2039  InvalidDecl = 4;
2040  ShowDeclName = false;
2041  break;
2042 
2044  InvalidDecl = 5;
2045  ShowDeclName = false;
2046  break;
2047 
2050  InvalidDecl = 6;
2051  break;
2052 
2053  default:
2054  InvalidDecl = 0;
2055  break;
2056  }
2057 
2058  if (InvalidDecl) {
2059  if (ShowDeclName)
2060  Diag(Loc, diag::err_invalid_member_in_interface)
2061  << (InvalidDecl-1) << Name;
2062  else
2063  Diag(Loc, diag::err_invalid_member_in_interface)
2064  << (InvalidDecl-1) << "";
2065  return nullptr;
2066  }
2067  }
2068 
2069  // C++ 9.2p6: A member shall not be declared to have automatic storage
2070  // duration (auto, register) or with the extern storage-class-specifier.
2071  // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
2072  // data members and cannot be applied to names declared const or static,
2073  // and cannot be applied to reference members.
2074  switch (DS.getStorageClassSpec()) {
2076  case DeclSpec::SCS_typedef:
2077  case DeclSpec::SCS_static:
2078  break;
2079  case DeclSpec::SCS_mutable:
2080  if (isFunc) {
2081  Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
2082 
2083  // FIXME: It would be nicer if the keyword was ignored only for this
2084  // declarator. Otherwise we could get follow-up errors.
2086  }
2087  break;
2088  default:
2090  diag::err_storageclass_invalid_for_member);
2092  break;
2093  }
2094 
2095  bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
2097  !isFunc);
2098 
2099  if (DS.isConstexprSpecified() && isInstField) {
2101  Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr_member);
2102  SourceLocation ConstexprLoc = DS.getConstexprSpecLoc();
2103  if (InitStyle == ICIS_NoInit) {
2104  B << 0 << 0;
2106  B << FixItHint::CreateRemoval(ConstexprLoc);
2107  else {
2108  B << FixItHint::CreateReplacement(ConstexprLoc, "const");
2110  const char *PrevSpec;
2111  unsigned DiagID;
2112  bool Failed = D.getMutableDeclSpec().SetTypeQual(
2113  DeclSpec::TQ_const, ConstexprLoc, PrevSpec, DiagID, getLangOpts());
2114  (void)Failed;
2115  assert(!Failed && "Making a constexpr member const shouldn't fail");
2116  }
2117  } else {
2118  B << 1;
2119  const char *PrevSpec;
2120  unsigned DiagID;
2122  *this, DeclSpec::SCS_static, ConstexprLoc, PrevSpec, DiagID,
2124  assert(DS.getStorageClassSpec() == DeclSpec::SCS_mutable &&
2125  "This is the only DeclSpec that should fail to be applied");
2126  B << 1;
2127  } else {
2128  B << 0 << FixItHint::CreateInsertion(ConstexprLoc, "static ");
2129  isInstField = false;
2130  }
2131  }
2132  }
2133 
2134  NamedDecl *Member;
2135  if (isInstField) {
2136  CXXScopeSpec &SS = D.getCXXScopeSpec();
2137 
2138  // Data members must have identifiers for names.
2139  if (!Name.isIdentifier()) {
2140  Diag(Loc, diag::err_bad_variable_name)
2141  << Name;
2142  return nullptr;
2143  }
2144 
2145  IdentifierInfo *II = Name.getAsIdentifierInfo();
2146 
2147  // Member field could not be with "template" keyword.
2148  // So TemplateParameterLists should be empty in this case.
2149  if (TemplateParameterLists.size()) {
2150  TemplateParameterList* TemplateParams = TemplateParameterLists[0];
2151  if (TemplateParams->size()) {
2152  // There is no such thing as a member field template.
2153  Diag(D.getIdentifierLoc(), diag::err_template_member)
2154  << II
2155  << SourceRange(TemplateParams->getTemplateLoc(),
2156  TemplateParams->getRAngleLoc());
2157  } else {
2158  // There is an extraneous 'template<>' for this member.
2159  Diag(TemplateParams->getTemplateLoc(),
2160  diag::err_template_member_noparams)
2161  << II
2162  << SourceRange(TemplateParams->getTemplateLoc(),
2163  TemplateParams->getRAngleLoc());
2164  }
2165  return nullptr;
2166  }
2167 
2168  if (SS.isSet() && !SS.isInvalid()) {
2169  // The user provided a superfluous scope specifier inside a class
2170  // definition:
2171  //
2172  // class X {
2173  // int X::member;
2174  // };
2175  if (DeclContext *DC = computeDeclContext(SS, false))
2177  else
2178  Diag(D.getIdentifierLoc(), diag::err_member_qualification)
2179  << Name << SS.getRange();
2180 
2181  SS.clear();
2182  }
2183 
2184  AttributeList *MSPropertyAttr =
2186  if (MSPropertyAttr) {
2187  Member = HandleMSProperty(S, cast<CXXRecordDecl>(CurContext), Loc, D,
2188  BitWidth, InitStyle, AS, MSPropertyAttr);
2189  if (!Member)
2190  return nullptr;
2191  isInstField = false;
2192  } else {
2193  Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D,
2194  BitWidth, InitStyle, AS);
2195  assert(Member && "HandleField never returns null");
2196  }
2197  } else {
2198  Member = HandleDeclarator(S, D, TemplateParameterLists);
2199  if (!Member)
2200  return nullptr;
2201 
2202  // Non-instance-fields can't have a bitfield.
2203  if (BitWidth) {
2204  if (Member->isInvalidDecl()) {
2205  // don't emit another diagnostic.
2206  } else if (isa<VarDecl>(Member) || isa<VarTemplateDecl>(Member)) {
2207  // C++ 9.6p3: A bit-field shall not be a static member.
2208  // "static member 'A' cannot be a bit-field"
2209  Diag(Loc, diag::err_static_not_bitfield)
2210  << Name << BitWidth->getSourceRange();
2211  } else if (isa<TypedefDecl>(Member)) {
2212  // "typedef member 'x' cannot be a bit-field"
2213  Diag(Loc, diag::err_typedef_not_bitfield)
2214  << Name << BitWidth->getSourceRange();
2215  } else {
2216  // A function typedef ("typedef int f(); f a;").
2217  // C++ 9.6p3: A bit-field shall have integral or enumeration type.
2218  Diag(Loc, diag::err_not_integral_type_bitfield)
2219  << Name << cast<ValueDecl>(Member)->getType()
2220  << BitWidth->getSourceRange();
2221  }
2222 
2223  BitWidth = nullptr;
2224  Member->setInvalidDecl();
2225  }
2226 
2227  Member->setAccess(AS);
2228 
2229  // If we have declared a member function template or static data member
2230  // template, set the access of the templated declaration as well.
2231  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
2232  FunTmpl->getTemplatedDecl()->setAccess(AS);
2233  else if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(Member))
2234  VarTmpl->getTemplatedDecl()->setAccess(AS);
2235  }
2236 
2237  if (VS.isOverrideSpecified())
2238  Member->addAttr(new (Context) OverrideAttr(VS.getOverrideLoc(), Context, 0));
2239  if (VS.isFinalSpecified())
2240  Member->addAttr(new (Context) FinalAttr(VS.getFinalLoc(), Context,
2241  VS.isFinalSpelledSealed()));
2242 
2243  if (VS.getLastLocation().isValid()) {
2244  // Update the end location of a method that has a virt-specifiers.
2245  if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member))
2246  MD->setRangeEnd(VS.getLastLocation());
2247  }
2248 
2249  CheckOverrideControl(Member);
2250 
2251  assert((Name || isInstField) && "No identifier for non-field ?");
2252 
2253  if (isInstField) {
2254  FieldDecl *FD = cast<FieldDecl>(Member);
2255  FieldCollector->Add(FD);
2256 
2257  if (!Diags.isIgnored(diag::warn_unused_private_field, FD->getLocation())) {
2258  // Remember all explicit private FieldDecls that have a name, no side
2259  // effects and are not part of a dependent type declaration.
2260  if (!FD->isImplicit() && FD->getDeclName() &&
2261  FD->getAccess() == AS_private &&
2262  !FD->hasAttr<UnusedAttr>() &&
2263  !FD->getParent()->isDependentContext() &&
2265  UnusedPrivateFields.insert(FD);
2266  }
2267  }
2268 
2269  return Member;
2270 }
2271 
2272 namespace {
2273  class UninitializedFieldVisitor
2274  : public EvaluatedExprVisitor<UninitializedFieldVisitor> {
2275  Sema &S;
2276  // List of Decls to generate a warning on. Also remove Decls that become
2277  // initialized.
2278  llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
2279  // List of base classes of the record. Classes are removed after their
2280  // initializers.
2281  llvm::SmallPtrSetImpl<QualType> &BaseClasses;
2282  // Vector of decls to be removed from the Decl set prior to visiting the
2283  // nodes. These Decls may have been initialized in the prior initializer.
2284  llvm::SmallVector<ValueDecl*, 4> DeclsToRemove;
2285  // If non-null, add a note to the warning pointing back to the constructor.
2286  const CXXConstructorDecl *Constructor;
2287  // Variables to hold state when processing an initializer list. When
2288  // InitList is true, special case initialization of FieldDecls matching
2289  // InitListFieldDecl.
2290  bool InitList;
2291  FieldDecl *InitListFieldDecl;
2292  llvm::SmallVector<unsigned, 4> InitFieldIndex;
2293 
2294  public:
2296  UninitializedFieldVisitor(Sema &S,
2297  llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
2298  llvm::SmallPtrSetImpl<QualType> &BaseClasses)
2299  : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
2300  Constructor(nullptr), InitList(false), InitListFieldDecl(nullptr) {}
2301 
2302  // Returns true if the use of ME is not an uninitialized use.
2303  bool IsInitListMemberExprInitialized(MemberExpr *ME,
2304  bool CheckReferenceOnly) {
2306  bool ReferenceField = false;
2307  while (ME) {
2308  FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
2309  if (!FD)
2310  return false;
2311  Fields.push_back(FD);
2312  if (FD->getType()->isReferenceType())
2313  ReferenceField = true;
2314  ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParenImpCasts());
2315  }
2316 
2317  // Binding a reference to an unintialized field is not an
2318  // uninitialized use.
2319  if (CheckReferenceOnly && !ReferenceField)
2320  return true;
2321 
2322  llvm::SmallVector<unsigned, 4> UsedFieldIndex;
2323  // Discard the first field since it is the field decl that is being
2324  // initialized.
2325  for (auto I = Fields.rbegin() + 1, E = Fields.rend(); I != E; ++I) {
2326  UsedFieldIndex.push_back((*I)->getFieldIndex());
2327  }
2328 
2329  for (auto UsedIter = UsedFieldIndex.begin(),
2330  UsedEnd = UsedFieldIndex.end(),
2331  OrigIter = InitFieldIndex.begin(),
2332  OrigEnd = InitFieldIndex.end();
2333  UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
2334  if (*UsedIter < *OrigIter)
2335  return true;
2336  if (*UsedIter > *OrigIter)
2337  break;
2338  }
2339 
2340  return false;
2341  }
2342 
2343  void HandleMemberExpr(MemberExpr *ME, bool CheckReferenceOnly,
2344  bool AddressOf) {
2345  if (isa<EnumConstantDecl>(ME->getMemberDecl()))
2346  return;
2347 
2348  // FieldME is the inner-most MemberExpr that is not an anonymous struct
2349  // or union.
2350  MemberExpr *FieldME = ME;
2351 
2352  bool AllPODFields = FieldME->getType().isPODType(S.Context);
2353 
2354  Expr *Base = ME;
2355  while (MemberExpr *SubME =
2356  dyn_cast<MemberExpr>(Base->IgnoreParenImpCasts())) {
2357 
2358  if (isa<VarDecl>(SubME->getMemberDecl()))
2359  return;
2360 
2361  if (FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
2362  if (!FD->isAnonymousStructOrUnion())
2363  FieldME = SubME;
2364 
2365  if (!FieldME->getType().isPODType(S.Context))
2366  AllPODFields = false;
2367 
2368  Base = SubME->getBase();
2369  }
2370 
2371  if (!isa<CXXThisExpr>(Base->IgnoreParenImpCasts()))
2372  return;
2373 
2374  if (AddressOf && AllPODFields)
2375  return;
2376 
2377  ValueDecl* FoundVD = FieldME->getMemberDecl();
2378 
2379  if (ImplicitCastExpr *BaseCast = dyn_cast<ImplicitCastExpr>(Base)) {
2380  while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
2381  BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
2382  }
2383 
2384  if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
2385  QualType T = BaseCast->getType();
2386  if (T->isPointerType() &&
2387  BaseClasses.count(T->getPointeeType())) {
2388  S.Diag(FieldME->getExprLoc(), diag::warn_base_class_is_uninit)
2389  << T->getPointeeType() << FoundVD;
2390  }
2391  }
2392  }
2393 
2394  if (!Decls.count(FoundVD))
2395  return;
2396 
2397  const bool IsReference = FoundVD->getType()->isReferenceType();
2398 
2399  if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
2400  // Special checking for initializer lists.
2401  if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
2402  return;
2403  }
2404  } else {
2405  // Prevent double warnings on use of unbounded references.
2406  if (CheckReferenceOnly && !IsReference)
2407  return;
2408  }
2409 
2410  unsigned diag = IsReference
2411  ? diag::warn_reference_field_is_uninit
2412  : diag::warn_field_is_uninit;
2413  S.Diag(FieldME->getExprLoc(), diag) << FoundVD;
2414  if (Constructor)
2415  S.Diag(Constructor->getLocation(),
2416  diag::note_uninit_in_this_constructor)
2417  << (Constructor->isDefaultConstructor() && Constructor->isImplicit());
2418 
2419  }
2420 
2421  void HandleValue(Expr *E, bool AddressOf) {
2422  E = E->IgnoreParens();
2423 
2424  if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
2425  HandleMemberExpr(ME, false /*CheckReferenceOnly*/,
2426  AddressOf /*AddressOf*/);
2427  return;
2428  }
2429 
2430  if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
2431  Visit(CO->getCond());
2432  HandleValue(CO->getTrueExpr(), AddressOf);
2433  HandleValue(CO->getFalseExpr(), AddressOf);
2434  return;
2435  }
2436 
2437  if (BinaryConditionalOperator *BCO =
2438  dyn_cast<BinaryConditionalOperator>(E)) {
2439  Visit(BCO->getCond());
2440  HandleValue(BCO->getFalseExpr(), AddressOf);
2441  return;
2442  }
2443 
2444  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
2445  HandleValue(OVE->getSourceExpr(), AddressOf);
2446  return;
2447  }
2448 
2449  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
2450  switch (BO->getOpcode()) {
2451  default:
2452  break;
2453  case(BO_PtrMemD):
2454  case(BO_PtrMemI):
2455  HandleValue(BO->getLHS(), AddressOf);
2456  Visit(BO->getRHS());
2457  return;
2458  case(BO_Comma):
2459  Visit(BO->getLHS());
2460  HandleValue(BO->getRHS(), AddressOf);
2461  return;
2462  }
2463  }
2464 
2465  Visit(E);
2466  }
2467 
2468  void CheckInitListExpr(InitListExpr *ILE) {
2469  InitFieldIndex.push_back(0);
2470  for (auto Child : ILE->children()) {
2471  if (InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
2472  CheckInitListExpr(SubList);
2473  } else {
2474  Visit(Child);
2475  }
2476  ++InitFieldIndex.back();
2477  }
2478  InitFieldIndex.pop_back();
2479  }
2480 
2481  void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor,
2482  FieldDecl *Field, const Type *BaseClass) {
2483  // Remove Decls that may have been initialized in the previous
2484  // initializer.
2485  for (ValueDecl* VD : DeclsToRemove)
2486  Decls.erase(VD);
2487  DeclsToRemove.clear();
2488 
2489  Constructor = FieldConstructor;
2490  InitListExpr *ILE = dyn_cast<InitListExpr>(E);
2491 
2492  if (ILE && Field) {
2493  InitList = true;
2494  InitListFieldDecl = Field;
2495  InitFieldIndex.clear();
2496  CheckInitListExpr(ILE);
2497  } else {
2498  InitList = false;
2499  Visit(E);
2500  }
2501 
2502  if (Field)
2503  Decls.erase(Field);
2504  if (BaseClass)
2505  BaseClasses.erase(BaseClass->getCanonicalTypeInternal());
2506  }
2507 
2508  void VisitMemberExpr(MemberExpr *ME) {
2509  // All uses of unbounded reference fields will warn.
2510  HandleMemberExpr(ME, true /*CheckReferenceOnly*/, false /*AddressOf*/);
2511  }
2512 
2513  void VisitImplicitCastExpr(ImplicitCastExpr *E) {
2514  if (E->getCastKind() == CK_LValueToRValue) {
2515  HandleValue(E->getSubExpr(), false /*AddressOf*/);
2516  return;
2517  }
2518 
2519  Inherited::VisitImplicitCastExpr(E);
2520  }
2521 
2522  void VisitCXXConstructExpr(CXXConstructExpr *E) {
2523  if (E->getConstructor()->isCopyConstructor()) {
2524  Expr *ArgExpr = E->getArg(0);
2525  if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
2526  if (ILE->getNumInits() == 1)
2527  ArgExpr = ILE->getInit(0);
2528  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
2529  if (ICE->getCastKind() == CK_NoOp)
2530  ArgExpr = ICE->getSubExpr();
2531  HandleValue(ArgExpr, false /*AddressOf*/);
2532  return;
2533  }
2534  Inherited::VisitCXXConstructExpr(E);
2535  }
2536 
2537  void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
2538  Expr *Callee = E->getCallee();
2539  if (isa<MemberExpr>(Callee)) {
2540  HandleValue(Callee, false /*AddressOf*/);
2541  for (auto Arg : E->arguments())
2542  Visit(Arg);
2543  return;
2544  }
2545 
2546  Inherited::VisitCXXMemberCallExpr(E);
2547  }
2548 
2549  void VisitCallExpr(CallExpr *E) {
2550  // Treat std::move as a use.
2551  if (E->getNumArgs() == 1) {
2552  if (FunctionDecl *FD = E->getDirectCallee()) {
2553  if (FD->isInStdNamespace() && FD->getIdentifier() &&
2554  FD->getIdentifier()->isStr("move")) {
2555  HandleValue(E->getArg(0), false /*AddressOf*/);
2556  return;
2557  }
2558  }
2559  }
2560 
2561  Inherited::VisitCallExpr(E);
2562  }
2563 
2564  void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
2565  Expr *Callee = E->getCallee();
2566 
2567  if (isa<UnresolvedLookupExpr>(Callee))
2568  return Inherited::VisitCXXOperatorCallExpr(E);
2569 
2570  Visit(Callee);
2571  for (auto Arg : E->arguments())
2572  HandleValue(Arg->IgnoreParenImpCasts(), false /*AddressOf*/);
2573  }
2574 
2575  void VisitBinaryOperator(BinaryOperator *E) {
2576  // If a field assignment is detected, remove the field from the
2577  // uninitiailized field set.
2578  if (E->getOpcode() == BO_Assign)
2579  if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getLHS()))
2580  if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
2581  if (!FD->getType()->isReferenceType())
2582  DeclsToRemove.push_back(FD);
2583 
2584  if (E->isCompoundAssignmentOp()) {
2585  HandleValue(E->getLHS(), false /*AddressOf*/);
2586  Visit(E->getRHS());
2587  return;
2588  }
2589 
2590  Inherited::VisitBinaryOperator(E);
2591  }
2592 
2593  void VisitUnaryOperator(UnaryOperator *E) {
2594  if (E->isIncrementDecrementOp()) {
2595  HandleValue(E->getSubExpr(), false /*AddressOf*/);
2596  return;
2597  }
2598  if (E->getOpcode() == UO_AddrOf) {
2599  if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getSubExpr())) {
2600  HandleValue(ME->getBase(), true /*AddressOf*/);
2601  return;
2602  }
2603  }
2604 
2605  Inherited::VisitUnaryOperator(E);
2606  }
2607  };
2608 
2609  // Diagnose value-uses of fields to initialize themselves, e.g.
2610  // foo(foo)
2611  // where foo is not also a parameter to the constructor.
2612  // Also diagnose across field uninitialized use such as
2613  // x(y), y(x)
2614  // TODO: implement -Wuninitialized and fold this into that framework.
2615  static void DiagnoseUninitializedFields(
2616  Sema &SemaRef, const CXXConstructorDecl *Constructor) {
2617 
2618  if (SemaRef.getDiagnostics().isIgnored(diag::warn_field_is_uninit,
2619  Constructor->getLocation())) {
2620  return;
2621  }
2622 
2623  if (Constructor->isInvalidDecl())
2624  return;
2625 
2626  const CXXRecordDecl *RD = Constructor->getParent();
2627 
2628  if (RD->getDescribedClassTemplate())
2629  return;
2630 
2631  // Holds fields that are uninitialized.
2632  llvm::SmallPtrSet<ValueDecl*, 4> UninitializedFields;
2633 
2634  // At the beginning, all fields are uninitialized.
2635  for (auto *I : RD->decls()) {
2636  if (auto *FD = dyn_cast<FieldDecl>(I)) {
2637  UninitializedFields.insert(FD);
2638  } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
2639  UninitializedFields.insert(IFD->getAnonField());
2640  }
2641  }
2642 
2643  llvm::SmallPtrSet<QualType, 4> UninitializedBaseClasses;
2644  for (auto I : RD->bases())
2645  UninitializedBaseClasses.insert(I.getType().getCanonicalType());
2646 
2647  if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
2648  return;
2649 
2650  UninitializedFieldVisitor UninitializedChecker(SemaRef,
2651  UninitializedFields,
2652  UninitializedBaseClasses);
2653 
2654  for (const auto *FieldInit : Constructor->inits()) {
2655  if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
2656  break;
2657 
2658  Expr *InitExpr = FieldInit->getInit();
2659  if (!InitExpr)
2660  continue;
2661 
2662  if (CXXDefaultInitExpr *Default =
2663  dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
2664  InitExpr = Default->getExpr();
2665  if (!InitExpr)
2666  continue;
2667  // In class initializers will point to the constructor.
2668  UninitializedChecker.CheckInitializer(InitExpr, Constructor,
2669  FieldInit->getAnyMember(),
2670  FieldInit->getBaseClass());
2671  } else {
2672  UninitializedChecker.CheckInitializer(InitExpr, nullptr,
2673  FieldInit->getAnyMember(),
2674  FieldInit->getBaseClass());
2675  }
2676  }
2677  }
2678 } // namespace
2679 
2680 /// \brief Enter a new C++ default initializer scope. After calling this, the
2681 /// caller must call \ref ActOnFinishCXXInClassMemberInitializer, even if
2682 /// parsing or instantiating the initializer failed.
2684  // Create a synthetic function scope to represent the call to the constructor
2685  // that notionally surrounds a use of this initializer.
2687 }
2688 
2689 /// \brief This is invoked after parsing an in-class initializer for a
2690 /// non-static C++ class member, and after instantiating an in-class initializer
2691 /// in a class template. Such actions are deferred until the class is complete.
2693  SourceLocation InitLoc,
2694  Expr *InitExpr) {
2695  // Pop the notional constructor scope we created earlier.
2696  PopFunctionScopeInfo(nullptr, D);
2697 
2698  FieldDecl *FD = dyn_cast<FieldDecl>(D);
2699  assert((isa<MSPropertyDecl>(D) || FD->getInClassInitStyle() != ICIS_NoInit) &&
2700  "must set init style when field is created");
2701 
2702  if (!InitExpr) {
2703  D->setInvalidDecl();
2704  if (FD)
2706  return;
2707  }
2708 
2710  FD->setInvalidDecl();
2712  return;
2713  }
2714 
2715  ExprResult Init = InitExpr;
2716  if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent()) {
2719  ? InitializationKind::CreateDirectList(InitExpr->getLocStart())
2720  : InitializationKind::CreateCopy(InitExpr->getLocStart(), InitLoc);
2721  InitializationSequence Seq(*this, Entity, Kind, InitExpr);
2722  Init = Seq.Perform(*this, Entity, Kind, InitExpr);
2723  if (Init.isInvalid()) {
2724  FD->setInvalidDecl();
2725  return;
2726  }
2727  }
2728 
2729  // C++11 [class.base.init]p7:
2730  // The initialization of each base and member constitutes a
2731  // full-expression.
2732  Init = ActOnFinishFullExpr(Init.get(), InitLoc);
2733  if (Init.isInvalid()) {
2734  FD->setInvalidDecl();
2735  return;
2736  }
2737 
2738  InitExpr = Init.get();
2739 
2740  FD->setInClassInitializer(InitExpr);
2741 }
2742 
2743 /// \brief Find the direct and/or virtual base specifiers that
2744 /// correspond to the given base type, for use in base initialization
2745 /// within a constructor.
2746 static bool FindBaseInitializer(Sema &SemaRef,
2747  CXXRecordDecl *ClassDecl,
2748  QualType BaseType,
2749  const CXXBaseSpecifier *&DirectBaseSpec,
2750  const CXXBaseSpecifier *&VirtualBaseSpec) {
2751  // First, check for a direct base class.
2752  DirectBaseSpec = nullptr;
2753  for (const auto &Base : ClassDecl->bases()) {
2754  if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base.getType())) {
2755  // We found a direct base of this type. That's what we're
2756  // initializing.
2757  DirectBaseSpec = &Base;
2758  break;
2759  }
2760  }
2761 
2762  // Check for a virtual base class.
2763  // FIXME: We might be able to short-circuit this if we know in advance that
2764  // there are no virtual bases.
2765  VirtualBaseSpec = nullptr;
2766  if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
2767  // We haven't found a base yet; search the class hierarchy for a
2768  // virtual base class.
2769  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2770  /*DetectVirtual=*/false);
2771  if (SemaRef.IsDerivedFrom(ClassDecl->getLocation(),
2772  SemaRef.Context.getTypeDeclType(ClassDecl),
2773  BaseType, Paths)) {
2774  for (CXXBasePaths::paths_iterator Path = Paths.begin();
2775  Path != Paths.end(); ++Path) {
2776  if (Path->back().Base->isVirtual()) {
2777  VirtualBaseSpec = Path->back().Base;
2778  break;
2779  }
2780  }
2781  }
2782  }
2783 
2784  return DirectBaseSpec || VirtualBaseSpec;
2785 }
2786 
2787 /// \brief Handle a C++ member initializer using braced-init-list syntax.
2789 Sema::ActOnMemInitializer(Decl *ConstructorD,
2790  Scope *S,
2791  CXXScopeSpec &SS,
2792  IdentifierInfo *MemberOrBase,
2793  ParsedType TemplateTypeTy,
2794  const DeclSpec &DS,
2795  SourceLocation IdLoc,
2796  Expr *InitList,
2797  SourceLocation EllipsisLoc) {
2798  return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
2799  DS, IdLoc, InitList,
2800  EllipsisLoc);
2801 }
2802 
2803 /// \brief Handle a C++ member initializer using parentheses syntax.
2805 Sema::ActOnMemInitializer(Decl *ConstructorD,
2806  Scope *S,
2807  CXXScopeSpec &SS,
2808  IdentifierInfo *MemberOrBase,
2809  ParsedType TemplateTypeTy,
2810  const DeclSpec &DS,
2811  SourceLocation IdLoc,
2812  SourceLocation LParenLoc,
2813  ArrayRef<Expr *> Args,
2814  SourceLocation RParenLoc,
2815  SourceLocation EllipsisLoc) {
2816  Expr *List = new (Context) ParenListExpr(Context, LParenLoc,
2817  Args, RParenLoc);
2818  return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
2819  DS, IdLoc, List, EllipsisLoc);
2820 }
2821 
2822 namespace {
2823 
2824 // Callback to only accept typo corrections that can be a valid C++ member
2825 // intializer: either a non-static field member or a base class.
2826 class MemInitializerValidatorCCC : public CorrectionCandidateCallback {
2827 public:
2828  explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl)
2829  : ClassDecl(ClassDecl) {}
2830 
2831  bool ValidateCandidate(const TypoCorrection &candidate) override {
2832  if (NamedDecl *ND = candidate.getCorrectionDecl()) {
2833  if (FieldDecl *Member = dyn_cast<FieldDecl>(ND))
2834  return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
2835  return isa<TypeDecl>(ND);
2836  }
2837  return false;
2838  }
2839 
2840 private:
2841  CXXRecordDecl *ClassDecl;
2842 };
2843 
2844 }
2845 
2846 /// \brief Handle a C++ member initializer.
2848 Sema::BuildMemInitializer(Decl *ConstructorD,
2849  Scope *S,
2850  CXXScopeSpec &SS,
2851  IdentifierInfo *MemberOrBase,
2852  ParsedType TemplateTypeTy,
2853  const DeclSpec &DS,
2854  SourceLocation IdLoc,
2855  Expr *Init,
2856  SourceLocation EllipsisLoc) {
2858  if (!Res.isUsable())
2859  return true;
2860  Init = Res.get();
2861 
2862  if (!ConstructorD)
2863  return true;
2864 
2865  AdjustDeclIfTemplate(ConstructorD);
2866 
2867  CXXConstructorDecl *Constructor
2868  = dyn_cast<CXXConstructorDecl>(ConstructorD);
2869  if (!Constructor) {
2870  // The user wrote a constructor initializer on a function that is
2871  // not a C++ constructor. Ignore the error for now, because we may
2872  // have more member initializers coming; we'll diagnose it just
2873  // once in ActOnMemInitializers.
2874  return true;
2875  }
2876 
2877  CXXRecordDecl *ClassDecl = Constructor->getParent();
2878 
2879  // C++ [class.base.init]p2:
2880  // Names in a mem-initializer-id are looked up in the scope of the
2881  // constructor's class and, if not found in that scope, are looked
2882  // up in the scope containing the constructor's definition.
2883  // [Note: if the constructor's class contains a member with the
2884  // same name as a direct or virtual base class of the class, a
2885  // mem-initializer-id naming the member or base class and composed
2886  // of a single identifier refers to the class member. A
2887  // mem-initializer-id for the hidden base class may be specified
2888  // using a qualified name. ]
2889  if (!SS.getScopeRep() && !TemplateTypeTy) {
2890  // Look for a member, first.
2891  DeclContext::lookup_result Result = ClassDecl->lookup(MemberOrBase);
2892  if (!Result.empty()) {
2893  ValueDecl *Member;
2894  if ((Member = dyn_cast<FieldDecl>(Result.front())) ||
2895  (Member = dyn_cast<IndirectFieldDecl>(Result.front()))) {
2896  if (EllipsisLoc.isValid())
2897  Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
2898  << MemberOrBase
2899  << SourceRange(IdLoc, Init->getSourceRange().getEnd());
2900 
2901  return BuildMemberInitializer(Member, Init, IdLoc);
2902  }
2903  }
2904  }
2905  // It didn't name a member, so see if it names a class.
2906  QualType BaseType;
2907  TypeSourceInfo *TInfo = nullptr;
2908 
2909  if (TemplateTypeTy) {
2910  BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
2911  } else if (DS.getTypeSpecType() == TST_decltype) {
2912  BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
2913  } else {
2914  LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
2915  LookupParsedName(R, S, &SS);
2916 
2917  TypeDecl *TyD = R.getAsSingle<TypeDecl>();
2918  if (!TyD) {
2919  if (R.isAmbiguous()) return true;
2920 
2921  // We don't want access-control diagnostics here.
2922  R.suppressDiagnostics();
2923 
2924  if (SS.isSet() && isDependentScopeSpecifier(SS)) {
2925  bool NotUnknownSpecialization = false;
2926  DeclContext *DC = computeDeclContext(SS, false);
2927  if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
2928  NotUnknownSpecialization = !Record->hasAnyDependentBases();
2929 
2930  if (!NotUnknownSpecialization) {
2931  // When the scope specifier can refer to a member of an unknown
2932  // specialization, we take it as a type name.
2935  *MemberOrBase, IdLoc);
2936  if (BaseType.isNull())
2937  return true;
2938 
2939  R.clear();
2940  R.setLookupName(MemberOrBase);
2941  }
2942  }
2943 
2944  // If no results were found, try to correct typos.
2945  TypoCorrection Corr;
2946  if (R.empty() && BaseType.isNull() &&
2947  (Corr = CorrectTypo(
2948  R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
2949  llvm::make_unique<MemInitializerValidatorCCC>(ClassDecl),
2950  CTK_ErrorRecovery, ClassDecl))) {
2951  if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
2952  // We have found a non-static data member with a similar
2953  // name to what was typed; complain and initialize that
2954  // member.
2955  diagnoseTypo(Corr,
2956  PDiag(diag::err_mem_init_not_member_or_class_suggest)
2957  << MemberOrBase << true);
2958  return BuildMemberInitializer(Member, Init, IdLoc);
2959  } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
2960  const CXXBaseSpecifier *DirectBaseSpec;
2961  const CXXBaseSpecifier *VirtualBaseSpec;
2962  if (FindBaseInitializer(*this, ClassDecl,
2964  DirectBaseSpec, VirtualBaseSpec)) {
2965  // We have found a direct or virtual base class with a
2966  // similar name to what was typed; complain and initialize
2967  // that base class.
2968  diagnoseTypo(Corr,
2969  PDiag(diag::err_mem_init_not_member_or_class_suggest)
2970  << MemberOrBase << false,
2971  PDiag() /*Suppress note, we provide our own.*/);
2972 
2973  const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
2974  : VirtualBaseSpec;
2975  Diag(BaseSpec->getLocStart(),
2976  diag::note_base_class_specified_here)
2977  << BaseSpec->getType()
2978  << BaseSpec->getSourceRange();
2979 
2980  TyD = Type;
2981  }
2982  }
2983  }
2984 
2985  if (!TyD && BaseType.isNull()) {
2986  Diag(IdLoc, diag::err_mem_init_not_member_or_class)
2987  << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
2988  return true;
2989  }
2990  }
2991 
2992  if (BaseType.isNull()) {
2993  BaseType = Context.getTypeDeclType(TyD);
2994  MarkAnyDeclReferenced(TyD->getLocation(), TyD, /*OdrUse=*/false);
2995  if (SS.isSet()) {
2996  BaseType = Context.getElaboratedType(ETK_None, SS.getScopeRep(),
2997  BaseType);
2998  TInfo = Context.CreateTypeSourceInfo(BaseType);
3000  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
3003  }
3004  }
3005  }
3006 
3007  if (!TInfo)
3008  TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
3009 
3010  return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc);
3011 }
3012 
3013 /// Checks a member initializer expression for cases where reference (or
3014 /// pointer) members are bound to by-value parameters (or their addresses).
3016  Expr *Init,
3017  SourceLocation IdLoc) {
3018  QualType MemberTy = Member->getType();
3019 
3020  // We only handle pointers and references currently.
3021  // FIXME: Would this be relevant for ObjC object pointers? Or block pointers?
3022  if (!MemberTy->isReferenceType() && !MemberTy->isPointerType())
3023  return;
3024 
3025  const bool IsPointer = MemberTy->isPointerType();
3026  if (IsPointer) {
3027  if (const UnaryOperator *Op
3028  = dyn_cast<UnaryOperator>(Init->IgnoreParenImpCasts())) {
3029  // The only case we're worried about with pointers requires taking the
3030  // address.
3031  if (Op->getOpcode() != UO_AddrOf)
3032  return;
3033 
3034  Init = Op->getSubExpr();
3035  } else {
3036  // We only handle address-of expression initializers for pointers.
3037  return;
3038  }
3039  }
3040 
3041  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Init->IgnoreParens())) {
3042  // We only warn when referring to a non-reference parameter declaration.
3043  const ParmVarDecl *Parameter = dyn_cast<ParmVarDecl>(DRE->getDecl());
3044  if (!Parameter || Parameter->getType()->isReferenceType())
3045  return;
3046 
3047  S.Diag(Init->getExprLoc(),
3048  IsPointer ? diag::warn_init_ptr_member_to_parameter_addr
3049  : diag::warn_bind_ref_member_to_parameter)
3050  << Member << Parameter << Init->getSourceRange();
3051  } else {
3052  // Other initializers are fine.
3053  return;
3054  }
3055 
3056  S.Diag(Member->getLocation(), diag::note_ref_or_ptr_member_declared_here)
3057  << (unsigned)IsPointer;
3058 }
3059 
3062  SourceLocation IdLoc) {
3063  FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member);
3064  IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member);
3065  assert((DirectMember || IndirectMember) &&
3066  "Member must be a FieldDecl or IndirectFieldDecl");
3067 
3069  return true;
3070 
3071  if (Member->isInvalidDecl())
3072  return true;
3073 
3074  MultiExprArg Args;
3075  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
3076  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
3077  } else if (InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
3078  Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
3079  } else {
3080  // Template instantiation doesn't reconstruct ParenListExprs for us.
3081  Args = Init;
3082  }
3083 
3084  SourceRange InitRange = Init->getSourceRange();
3085 
3086  if (Member->getType()->isDependentType() || Init->isTypeDependent()) {
3087  // Can't check initialization for a member of dependent type or when
3088  // any of the arguments are type-dependent expressions.
3090  } else {
3091  bool InitList = false;
3092  if (isa<InitListExpr>(Init)) {
3093  InitList = true;
3094  Args = Init;
3095  }
3096 
3097  // Initialize the member.
3098  InitializedEntity MemberEntity =
3099  DirectMember ? InitializedEntity::InitializeMember(DirectMember, nullptr)
3100  : InitializedEntity::InitializeMember(IndirectMember,
3101  nullptr);
3103  InitList ? InitializationKind::CreateDirectList(IdLoc)
3104  : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(),
3105  InitRange.getEnd());
3106 
3107  InitializationSequence InitSeq(*this, MemberEntity, Kind, Args);
3108  ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind, Args,
3109  nullptr);
3110  if (MemberInit.isInvalid())
3111  return true;
3112 
3113  CheckForDanglingReferenceOrPointer(*this, Member, MemberInit.get(), IdLoc);
3114 
3115  // C++11 [class.base.init]p7:
3116  // The initialization of each base and member constitutes a
3117  // full-expression.
3118  MemberInit = ActOnFinishFullExpr(MemberInit.get(), InitRange.getBegin());
3119  if (MemberInit.isInvalid())
3120  return true;
3121 
3122  Init = MemberInit.get();
3123  }
3124 
3125  if (DirectMember) {
3126  return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc,
3127  InitRange.getBegin(), Init,
3128  InitRange.getEnd());
3129  } else {
3130  return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc,
3131  InitRange.getBegin(), Init,
3132  InitRange.getEnd());
3133  }
3134 }
3135 
3138  CXXRecordDecl *ClassDecl) {
3139  SourceLocation NameLoc = TInfo->getTypeLoc().getLocalSourceRange().getBegin();
3140  if (!LangOpts.CPlusPlus11)
3141  return Diag(NameLoc, diag::err_delegating_ctor)
3142  << TInfo->getTypeLoc().getLocalSourceRange();
3143  Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
3144 
3145  bool InitList = true;
3146  MultiExprArg Args = Init;
3147  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
3148  InitList = false;
3149  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
3150  }
3151 
3152  SourceRange InitRange = Init->getSourceRange();
3153  // Initialize the object.
3155  QualType(ClassDecl->getTypeForDecl(), 0));
3157  InitList ? InitializationKind::CreateDirectList(NameLoc)
3158  : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(),
3159  InitRange.getEnd());
3160  InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args);
3161  ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind,
3162  Args, nullptr);
3163  if (DelegationInit.isInvalid())
3164  return true;
3165 
3166  assert(cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() &&
3167  "Delegating constructor with no target?");
3168 
3169  // C++11 [class.base.init]p7:
3170  // The initialization of each base and member constitutes a
3171  // full-expression.
3172  DelegationInit = ActOnFinishFullExpr(DelegationInit.get(),
3173  InitRange.getBegin());
3174  if (DelegationInit.isInvalid())
3175  return true;
3176 
3177  // If we are in a dependent context, template instantiation will
3178  // perform this type-checking again. Just save the arguments that we
3179  // received in a ParenListExpr.
3180  // FIXME: This isn't quite ideal, since our ASTs don't capture all
3181  // of the information that we have about the base
3182  // initializer. However, deconstructing the ASTs is a dicey process,
3183  // and this approach is far more likely to get the corner cases right.
3185  DelegationInit = Init;
3186 
3187  return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(),
3188  DelegationInit.getAs<Expr>(),
3189  InitRange.getEnd());
3190 }
3191 
3194  Expr *Init, CXXRecordDecl *ClassDecl,
3195  SourceLocation EllipsisLoc) {
3196  SourceLocation BaseLoc
3197  = BaseTInfo->getTypeLoc().getLocalSourceRange().getBegin();
3198 
3199  if (!BaseType->isDependentType() && !BaseType->isRecordType())
3200  return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
3201  << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
3202 
3203  // C++ [class.base.init]p2:
3204  // [...] Unless the mem-initializer-id names a nonstatic data
3205  // member of the constructor's class or a direct or virtual base
3206  // of that class, the mem-initializer is ill-formed. A
3207  // mem-initializer-list can initialize a base class using any
3208  // name that denotes that base class type.
3209  bool Dependent = BaseType->isDependentType() || Init->isTypeDependent();
3210 
3211  SourceRange InitRange = Init->getSourceRange();
3212  if (EllipsisLoc.isValid()) {
3213  // This is a pack expansion.
3214  if (!BaseType->containsUnexpandedParameterPack()) {
3215  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
3216  << SourceRange(BaseLoc, InitRange.getEnd());
3217 
3218  EllipsisLoc = SourceLocation();
3219  }
3220  } else {
3221  // Check for any unexpanded parameter packs.
3222  if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer))
3223  return true;
3224 
3226  return true;
3227  }
3228 
3229  // Check for direct and virtual base classes.
3230  const CXXBaseSpecifier *DirectBaseSpec = nullptr;
3231  const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
3232  if (!Dependent) {
3234  BaseType))
3235  return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl);
3236 
3237  FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
3238  VirtualBaseSpec);
3239 
3240  // C++ [base.class.init]p2:
3241  // Unless the mem-initializer-id names a nonstatic data member of the
3242  // constructor's class or a direct or virtual base of that class, the
3243  // mem-initializer is ill-formed.
3244  if (!DirectBaseSpec && !VirtualBaseSpec) {
3245  // If the class has any dependent bases, then it's possible that
3246  // one of those types will resolve to the same type as
3247  // BaseType. Therefore, just treat this as a dependent base
3248  // class initialization. FIXME: Should we try to check the
3249  // initialization anyway? It seems odd.
3250  if (ClassDecl->hasAnyDependentBases())
3251  Dependent = true;
3252  else
3253  return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
3254  << BaseType << Context.getTypeDeclType(ClassDecl)
3255  << BaseTInfo->getTypeLoc().getLocalSourceRange();
3256  }
3257  }
3258 
3259  if (Dependent) {
3261 
3262  return new (Context) CXXCtorInitializer(Context, BaseTInfo,
3263  /*IsVirtual=*/false,
3264  InitRange.getBegin(), Init,
3265  InitRange.getEnd(), EllipsisLoc);
3266  }
3267 
3268  // C++ [base.class.init]p2:
3269  // If a mem-initializer-id is ambiguous because it designates both
3270  // a direct non-virtual base class and an inherited virtual base
3271  // class, the mem-initializer is ill-formed.
3272  if (DirectBaseSpec && VirtualBaseSpec)
3273  return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
3274  << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
3275 
3276  const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
3277  if (!BaseSpec)
3278  BaseSpec = VirtualBaseSpec;
3279 
3280  // Initialize the base.
3281  bool InitList = true;
3282  MultiExprArg Args = Init;
3283  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
3284  InitList = false;
3285  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
3286  }
3287 
3288  InitializedEntity BaseEntity =
3289  InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec);
3291  InitList ? InitializationKind::CreateDirectList(BaseLoc)
3292  : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(),
3293  InitRange.getEnd());
3294  InitializationSequence InitSeq(*this, BaseEntity, Kind, Args);
3295  ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind, Args, nullptr);
3296  if (BaseInit.isInvalid())
3297  return true;
3298 
3299  // C++11 [class.base.init]p7:
3300  // The initialization of each base and member constitutes a
3301  // full-expression.
3302  BaseInit = ActOnFinishFullExpr(BaseInit.get(), InitRange.getBegin());
3303  if (BaseInit.isInvalid())
3304  return true;
3305 
3306  // If we are in a dependent context, template instantiation will
3307  // perform this type-checking again. Just save the arguments that we
3308  // received in a ParenListExpr.
3309  // FIXME: This isn't quite ideal, since our ASTs don't capture all
3310  // of the information that we have about the base
3311  // initializer. However, deconstructing the ASTs is a dicey process,
3312  // and this approach is far more likely to get the corner cases right.
3314  BaseInit = Init;
3315 
3316  return new (Context) CXXCtorInitializer(Context, BaseTInfo,
3317  BaseSpec->isVirtual(),
3318  InitRange.getBegin(),
3319  BaseInit.getAs<Expr>(),
3320  InitRange.getEnd(), EllipsisLoc);
3321 }
3322 
3323 // Create a static_cast<T&&>(expr).
3324 static Expr *CastForMoving(Sema &SemaRef, Expr *E, QualType T = QualType()) {
3325  if (T.isNull()) T = E->getType();
3326  QualType TargetType = SemaRef.BuildReferenceType(
3327  T, /*SpelledAsLValue*/false, SourceLocation(), DeclarationName());
3328  SourceLocation ExprLoc = E->getLocStart();
3329  TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo(
3330  TargetType, ExprLoc);
3331 
3332  return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
3333  SourceRange(ExprLoc, ExprLoc),
3334  E->getSourceRange()).get();
3335 }
3336 
3337 /// ImplicitInitializerKind - How an implicit base or member initializer should
3338 /// initialize its base or member.
3344 };
3345 
3346 static bool
3348  ImplicitInitializerKind ImplicitInitKind,
3349  CXXBaseSpecifier *BaseSpec,
3350  bool IsInheritedVirtualBase,
3351  CXXCtorInitializer *&CXXBaseInit) {
3352  InitializedEntity InitEntity
3353  = InitializedEntity::InitializeBase(SemaRef.Context, BaseSpec,
3354  IsInheritedVirtualBase);
3355 
3356  ExprResult BaseInit;
3357 
3358  switch (ImplicitInitKind) {
3359  case IIK_Inherit: {
3360  const CXXRecordDecl *Inherited =
3361  Constructor->getInheritedConstructor()->getParent();
3362  const CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
3363  if (Base && Inherited->getCanonicalDecl() == Base->getCanonicalDecl()) {
3364  // C++11 [class.inhctor]p8:
3365  // Each expression in the expression-list is of the form
3366  // static_cast<T&&>(p), where p is the name of the corresponding
3367  // constructor parameter and T is the declared type of p.
3369  for (unsigned I = 0, E = Constructor->getNumParams(); I != E; ++I) {
3370  ParmVarDecl *PD = Constructor->getParamDecl(I);
3371  ExprResult ArgExpr =
3372  SemaRef.BuildDeclRefExpr(PD, PD->getType().getNonReferenceType(),
3374  if (ArgExpr.isInvalid())
3375  return true;
3376  Args.push_back(CastForMoving(SemaRef, ArgExpr.get(), PD->getType()));
3377  }
3378 
3380  Constructor->getLocation(), SourceLocation(), SourceLocation());
3381  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, Args);
3382  BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, Args);
3383  break;
3384  }
3385  }
3386  // Fall through.
3387  case IIK_Default: {
3388  InitializationKind InitKind
3390  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
3391  BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
3392  break;
3393  }
3394 
3395  case IIK_Move:
3396  case IIK_Copy: {
3397  bool Moving = ImplicitInitKind == IIK_Move;
3398  ParmVarDecl *Param = Constructor->getParamDecl(0);
3399  QualType ParamType = Param->getType().getNonReferenceType();
3400 
3401  Expr *CopyCtorArg =
3403  SourceLocation(), Param, false,
3404  Constructor->getLocation(), ParamType,
3405  VK_LValue, nullptr);
3406 
3407  SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg));
3408 
3409  // Cast to the base class to avoid ambiguities.
3410  QualType ArgTy =
3411  SemaRef.Context.getQualifiedType(BaseSpec->getType().getUnqualifiedType(),
3412  ParamType.getQualifiers());
3413 
3414  if (Moving) {
3415  CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg);
3416  }
3417 
3418  CXXCastPath BasePath;
3419  BasePath.push_back(BaseSpec);
3420  CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy,
3422  Moving ? VK_XValue : VK_LValue,
3423  &BasePath).get();
3424 
3425  InitializationKind InitKind
3428  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, CopyCtorArg);
3429  BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, CopyCtorArg);
3430  break;
3431  }
3432  }
3433 
3434  BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit);
3435  if (BaseInit.isInvalid())
3436  return true;
3437 
3438  CXXBaseInit =
3439  new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
3440  SemaRef.Context.getTrivialTypeSourceInfo(BaseSpec->getType(),
3441  SourceLocation()),
3442  BaseSpec->isVirtual(),
3443  SourceLocation(),
3444  BaseInit.getAs<Expr>(),
3445  SourceLocation(),
3446  SourceLocation());
3447 
3448  return false;
3449 }
3450 
3451 static bool RefersToRValueRef(Expr *MemRef) {
3452  ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
3453  return Referenced->getType()->isRValueReferenceType();
3454 }
3455 
3456 static bool
3458  ImplicitInitializerKind ImplicitInitKind,
3459  FieldDecl *Field, IndirectFieldDecl *Indirect,
3460  CXXCtorInitializer *&CXXMemberInit) {
3461  if (Field->isInvalidDecl())
3462  return true;
3463 
3464  SourceLocation Loc = Constructor->getLocation();
3465 
3466  if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) {
3467  bool Moving = ImplicitInitKind == IIK_Move;
3468  ParmVarDecl *Param = Constructor->getParamDecl(0);
3469  QualType ParamType = Param->getType().getNonReferenceType();
3470 
3471  // Suppress copying zero-width bitfields.
3472  if (Field->isBitField() && Field->getBitWidthValue(SemaRef.Context) == 0)
3473  return false;
3474 
3475  Expr *MemberExprBase =
3477  SourceLocation(), Param, false,
3478  Loc, ParamType, VK_LValue, nullptr);
3479 
3480  SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase));
3481 
3482  if (Moving) {
3483  MemberExprBase = CastForMoving(SemaRef, MemberExprBase);
3484  }
3485 
3486  // Build a reference to this field within the parameter.
3487  CXXScopeSpec SS;
3488  LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
3490  MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect)
3491  : cast<ValueDecl>(Field), AS_public);
3492  MemberLookup.resolveKind();
3493  ExprResult CtorArg
3494  = SemaRef.BuildMemberReferenceExpr(MemberExprBase,
3495  ParamType, Loc,
3496  /*IsArrow=*/false,
3497  SS,
3498  /*TemplateKWLoc=*/SourceLocation(),
3499  /*FirstQualifierInScope=*/nullptr,
3500  MemberLookup,
3501  /*TemplateArgs=*/nullptr,
3502  /*S*/nullptr);
3503  if (CtorArg.isInvalid())
3504  return true;
3505 
3506  // C++11 [class.copy]p15:
3507  // - if a member m has rvalue reference type T&&, it is direct-initialized
3508  // with static_cast<T&&>(x.m);
3509  if (RefersToRValueRef(CtorArg.get())) {
3510  CtorArg = CastForMoving(SemaRef, CtorArg.get());
3511  }
3512 
3513  // When the field we are copying is an array, create index variables for
3514  // each dimension of the array. We use these index variables to subscript
3515  // the source array, and other clients (e.g., CodeGen) will perform the
3516  // necessary iteration with these index variables.
3517  SmallVector<VarDecl *, 4> IndexVariables;
3518  QualType BaseType = Field->getType();
3519  QualType SizeType = SemaRef.Context.getSizeType();
3520  bool InitializingArray = false;
3521  while (const ConstantArrayType *Array
3522  = SemaRef.Context.getAsConstantArrayType(BaseType)) {
3523  InitializingArray = true;
3524  // Create the iteration variable for this array index.
3525  IdentifierInfo *IterationVarName = nullptr;
3526  {
3527  SmallString<8> Str;
3528  llvm::raw_svector_ostream OS(Str);
3529  OS << "__i" << IndexVariables.size();
3530  IterationVarName = &SemaRef.Context.Idents.get(OS.str());
3531  }
3532  VarDecl *IterationVar
3533  = VarDecl::Create(SemaRef.Context, SemaRef.CurContext, Loc, Loc,
3534  IterationVarName, SizeType,
3535  SemaRef.Context.getTrivialTypeSourceInfo(SizeType, Loc),
3536  SC_None);
3537  IndexVariables.push_back(IterationVar);
3538 
3539  // Create a reference to the iteration variable.
3540  ExprResult IterationVarRef
3541  = SemaRef.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc);
3542  assert(!IterationVarRef.isInvalid() &&
3543  "Reference to invented variable cannot fail!");
3544  IterationVarRef = SemaRef.DefaultLvalueConversion(IterationVarRef.get());
3545  assert(!IterationVarRef.isInvalid() &&
3546  "Conversion of invented variable cannot fail!");
3547 
3548  // Subscript the array with this iteration variable.
3549  CtorArg = SemaRef.CreateBuiltinArraySubscriptExpr(CtorArg.get(), Loc,
3550  IterationVarRef.get(),
3551  Loc);
3552  if (CtorArg.isInvalid())
3553  return true;
3554 
3555  BaseType = Array->getElementType();
3556  }
3557 
3558  // The array subscript expression is an lvalue, which is wrong for moving.
3559  if (Moving && InitializingArray)
3560  CtorArg = CastForMoving(SemaRef, CtorArg.get());
3561 
3562  // Construct the entity that we will be initializing. For an array, this
3563  // will be first element in the array, which may require several levels
3564  // of array-subscript entities.
3566  Entities.reserve(1 + IndexVariables.size());
3567  if (Indirect)
3568  Entities.push_back(InitializedEntity::InitializeMember(Indirect));
3569  else
3570  Entities.push_back(InitializedEntity::InitializeMember(Field));
3571  for (unsigned I = 0, N = IndexVariables.size(); I != N; ++I)
3572  Entities.push_back(InitializedEntity::InitializeElement(SemaRef.Context,
3573  0,
3574  Entities.back()));
3575 
3576  // Direct-initialize to use the copy constructor.
3577  InitializationKind InitKind =
3579 
3580  Expr *CtorArgE = CtorArg.getAs<Expr>();
3581  InitializationSequence InitSeq(SemaRef, Entities.back(), InitKind,
3582  CtorArgE);
3583 
3584  ExprResult MemberInit
3585  = InitSeq.Perform(SemaRef, Entities.back(), InitKind,
3586  MultiExprArg(&CtorArgE, 1));
3587  MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
3588  if (MemberInit.isInvalid())
3589  return true;
3590 
3591  if (Indirect) {
3592  assert(IndexVariables.size() == 0 &&
3593  "Indirect field improperly initialized");
3594  CXXMemberInit
3595  = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Indirect,
3596  Loc, Loc,
3597  MemberInit.getAs<Expr>(),
3598  Loc);
3599  } else
3600  CXXMemberInit = CXXCtorInitializer::Create(SemaRef.Context, Field, Loc,
3601  Loc, MemberInit.getAs<Expr>(),
3602  Loc,
3603  IndexVariables.data(),
3604  IndexVariables.size());
3605  return false;
3606  }
3607 
3608  assert((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) &&
3609  "Unhandled implicit init kind!");
3610 
3611  QualType FieldBaseElementType =
3612  SemaRef.Context.getBaseElementType(Field->getType());
3613 
3614  if (FieldBaseElementType->isRecordType()) {
3615  InitializedEntity InitEntity
3616  = Indirect? InitializedEntity::InitializeMember(Indirect)
3618  InitializationKind InitKind =
3620 
3621  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
3622  ExprResult MemberInit =
3623  InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
3624 
3625  MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
3626  if (MemberInit.isInvalid())
3627  return true;
3628 
3629  if (Indirect)
3630  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
3631  Indirect, Loc,
3632  Loc,
3633  MemberInit.get(),
3634  Loc);
3635  else
3636  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
3637  Field, Loc, Loc,
3638  MemberInit.get(),
3639  Loc);
3640  return false;
3641  }
3642 
3643  if (!Field->getParent()->isUnion()) {
3644  if (FieldBaseElementType->isReferenceType()) {
3645  SemaRef.Diag(Constructor->getLocation(),
3646  diag::err_uninitialized_member_in_ctor)
3647  << (int)Constructor->isImplicit()
3648  << SemaRef.Context.getTagDeclType(Constructor->getParent())
3649  << 0 << Field->getDeclName();
3650  SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
3651  return true;
3652  }
3653 
3654  if (FieldBaseElementType.isConstQualified()) {
3655  SemaRef.Diag(Constructor->getLocation(),
3656  diag::err_uninitialized_member_in_ctor)
3657  << (int)Constructor->isImplicit()
3658  << SemaRef.Context.getTagDeclType(Constructor->getParent())
3659  << 1 << Field->getDeclName();
3660  SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
3661  return true;
3662  }
3663  }
3664 
3665  if (SemaRef.getLangOpts().ObjCAutoRefCount &&
3666  FieldBaseElementType->isObjCRetainableType() &&
3667  FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_None &&
3668  FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_ExplicitNone) {
3669  // ARC:
3670  // Default-initialize Objective-C pointers to NULL.
3671  CXXMemberInit
3672  = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
3673  Loc, Loc,
3674  new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()),
3675  Loc);
3676  return false;
3677  }
3678 
3679  // Nothing to initialize.
3680  CXXMemberInit = nullptr;
3681  return false;
3682 }
3683 
3684 namespace {
3685 struct BaseAndFieldInfo {
3686  Sema &S;
3687  CXXConstructorDecl *Ctor;
3688  bool AnyErrorsInInits;
3690  llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
3692  llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
3693 
3694  BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits)
3695  : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
3696  bool Generated = Ctor->isImplicit() || Ctor->isDefaulted();
3697  if (Generated && Ctor->isCopyConstructor())
3698  IIK = IIK_Copy;
3699  else if (Generated && Ctor->isMoveConstructor())
3700  IIK = IIK_Move;
3701  else if (Ctor->getInheritedConstructor())
3702  IIK = IIK_Inherit;
3703  else
3704  IIK = IIK_Default;
3705  }
3706 
3707  bool isImplicitCopyOrMove() const {
3708  switch (IIK) {
3709  case IIK_Copy:
3710  case IIK_Move:
3711  return true;
3712 
3713  case IIK_Default:
3714  case IIK_Inherit:
3715  return false;
3716  }
3717 
3718  llvm_unreachable("Invalid ImplicitInitializerKind!");
3719  }
3720 
3721  bool addFieldInitializer(CXXCtorInitializer *Init) {
3722  AllToInit.push_back(Init);
3723 
3724  // Check whether this initializer makes the field "used".
3725  if (Init->getInit()->HasSideEffects(S.Context))
3726  S.UnusedPrivateFields.remove(Init->getAnyMember());
3727 
3728  return false;
3729  }
3730 
3731  bool isInactiveUnionMember(FieldDecl *Field) {
3732  RecordDecl *Record = Field->getParent();
3733  if (!Record->isUnion())
3734  return false;
3735 
3736  if (FieldDecl *Active =
3737  ActiveUnionMember.lookup(Record->getCanonicalDecl()))
3738  return Active != Field->getCanonicalDecl();
3739 
3740  // In an implicit copy or move constructor, ignore any in-class initializer.
3741  if (isImplicitCopyOrMove())
3742  return true;
3743 
3744  // If there's no explicit initialization, the field is active only if it
3745  // has an in-class initializer...
3746  if (Field->hasInClassInitializer())
3747  return false;
3748  // ... or it's an anonymous struct or union whose class has an in-class
3749  // initializer.
3750  if (!Field->isAnonymousStructOrUnion())
3751  return true;
3752  CXXRecordDecl *FieldRD = Field->getType()->getAsCXXRecordDecl();
3753  return !FieldRD->hasInClassInitializer();
3754  }
3755 
3756  /// \brief Determine whether the given field is, or is within, a union member
3757  /// that is inactive (because there was an initializer given for a different
3758  /// member of the union, or because the union was not initialized at all).
3759  bool isWithinInactiveUnionMember(FieldDecl *Field,
3760  IndirectFieldDecl *Indirect) {
3761  if (!Indirect)
3762  return isInactiveUnionMember(Field);
3763 
3764  for (auto *C : Indirect->chain()) {
3765  FieldDecl *Field = dyn_cast<FieldDecl>(C);
3766  if (Field && isInactiveUnionMember(Field))
3767  return true;
3768  }
3769  return false;
3770  }
3771 };
3772 }
3773 
3774 /// \brief Determine whether the given type is an incomplete or zero-lenfgth
3775 /// array type.
3777  if (T->isIncompleteArrayType())
3778  return true;
3779 
3780  while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
3781  if (!ArrayT->getSize())
3782  return true;
3783 
3784  T = ArrayT->getElementType();
3785  }
3786 
3787  return false;
3788 }
3789 
3790 static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
3791  FieldDecl *Field,
3792  IndirectFieldDecl *Indirect = nullptr) {
3793  if (Field->isInvalidDecl())
3794  return false;
3795 
3796  // Overwhelmingly common case: we have a direct initializer for this field.
3797  if (CXXCtorInitializer *Init =
3798  Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
3799  return Info.addFieldInitializer(Init);
3800 
3801  // C++11 [class.base.init]p8:
3802  // if the entity is a non-static data member that has a
3803  // brace-or-equal-initializer and either
3804  // -- the constructor's class is a union and no other variant member of that
3805  // union is designated by a mem-initializer-id or
3806  // -- the constructor's class is not a union, and, if the entity is a member
3807  // of an anonymous union, no other member of that union is designated by
3808  // a mem-initializer-id,
3809  // the entity is initialized as specified in [dcl.init].
3810  //
3811  // We also apply the same rules to handle anonymous structs within anonymous
3812  // unions.
3813  if (Info.isWithinInactiveUnionMember(Field, Indirect))
3814  return false;
3815 
3816  if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
3817  ExprResult DIE =
3818  SemaRef.BuildCXXDefaultInitExpr(Info.Ctor->getLocation(), Field);
3819  if (DIE.isInvalid())
3820  return true;
3821  CXXCtorInitializer *Init;
3822  if (Indirect)
3823  Init = new (SemaRef.Context)
3824  CXXCtorInitializer(SemaRef.Context, Indirect, SourceLocation(),
3825  SourceLocation(), DIE.get(), SourceLocation());
3826  else
3827  Init = new (SemaRef.Context)
3828  CXXCtorInitializer(SemaRef.Context, Field, SourceLocation(),
3829  SourceLocation(), DIE.get(), SourceLocation());
3830  return Info.addFieldInitializer(Init);
3831  }
3832 
3833  // Don't initialize incomplete or zero-length arrays.
3834  if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType()))
3835  return false;
3836 
3837  // Don't try to build an implicit initializer if there were semantic
3838  // errors in any of the initializers (and therefore we might be
3839  // missing some that the user actually wrote).
3840  if (Info.AnyErrorsInInits)
3841  return false;
3842 
3843  CXXCtorInitializer *Init = nullptr;
3844  if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field,
3845  Indirect, Init))
3846  return true;
3847 
3848  if (!Init)
3849  return false;
3850 
3851  return Info.addFieldInitializer(Init);
3852 }
3853 
3854 bool
3856  CXXCtorInitializer *Initializer) {
3857  assert(Initializer->isDelegatingInitializer());
3858  Constructor->setNumCtorInitializers(1);
3859  CXXCtorInitializer **initializer =
3860  new (Context) CXXCtorInitializer*[1];
3861  memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*));
3862  Constructor->setCtorInitializers(initializer);
3863 
3864  if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) {
3865  MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor);
3866  DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation());
3867  }
3868 
3869  DelegatingCtorDecls.push_back(Constructor);
3870 
3871  DiagnoseUninitializedFields(*this, Constructor);
3872 
3873  return false;
3874 }
3875 
3876 bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
3877  ArrayRef<CXXCtorInitializer *> Initializers) {
3878  if (Constructor->isDependentContext()) {
3879  // Just store the initializers as written, they will be checked during
3880  // instantiation.
3881  if (!Initializers.empty()) {
3882  Constructor->setNumCtorInitializers(Initializers.size());
3883  CXXCtorInitializer **baseOrMemberInitializers =
3884  new (Context) CXXCtorInitializer*[Initializers.size()];
3885  memcpy(baseOrMemberInitializers, Initializers.data(),
3886  Initializers.size() * sizeof(CXXCtorInitializer*));
3887  Constructor->setCtorInitializers(baseOrMemberInitializers);
3888  }
3889 
3890  // Let template instantiation know whether we had errors.
3891  if (AnyErrors)
3892  Constructor->setInvalidDecl();
3893 
3894  return false;
3895  }
3896 
3897  BaseAndFieldInfo Info(*this, Constructor, AnyErrors);
3898 
3899  // We need to build the initializer AST according to order of construction
3900  // and not what user specified in the Initializers list.
3901  CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
3902  if (!ClassDecl)
3903  return true;
3904 
3905  bool HadError = false;
3906 
3907  for (unsigned i = 0; i < Initializers.size(); i++) {
3908  CXXCtorInitializer *Member = Initializers[i];
3909 
3910  if (Member->isBaseInitializer())
3911  Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
3912  else {
3913  Info.AllBaseFields[Member->getAnyMember()->getCanonicalDecl()] = Member;
3914 
3915  if (IndirectFieldDecl *F = Member->getIndirectMember()) {
3916  for (auto *C : F->chain()) {
3917  FieldDecl *FD = dyn_cast<FieldDecl>(C);
3918  if (FD && FD->getParent()->isUnion())
3919  Info.ActiveUnionMember.insert(std::make_pair(
3920  FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
3921  }
3922  } else if (FieldDecl *FD = Member->getMember()) {
3923  if (FD->getParent()->isUnion())
3924  Info.ActiveUnionMember.insert(std::make_pair(
3925  FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
3926  }
3927  }
3928  }
3929 
3930  // Keep track of the direct virtual bases.
3931  llvm::SmallPtrSet<CXXBaseSpecifier *, 16> DirectVBases;
3932  for (auto &I : ClassDecl->bases()) {
3933  if (I.isVirtual())
3934  DirectVBases.insert(&I);
3935  }
3936 
3937  // Push virtual bases before others.
3938  for (auto &VBase : ClassDecl->vbases()) {
3940  = Info.AllBaseFields.lookup(VBase.getType()->getAs<RecordType>())) {
3941  // [class.base.init]p7, per DR257:
3942  // A mem-initializer where the mem-initializer-id names a virtual base
3943  // class is ignored during execution of a constructor of any class that
3944  // is not the most derived class.
3945  if (ClassDecl->isAbstract()) {
3946  // FIXME: Provide a fixit to remove the base specifier. This requires
3947  // tracking the location of the associated comma for a base specifier.
3948  Diag(Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
3949  << VBase.getType() << ClassDecl;
3950  DiagnoseAbstractType(ClassDecl);
3951  }
3952 
3953  Info.AllToInit.push_back(Value);
3954  } else if (!AnyErrors && !ClassDecl->isAbstract()) {
3955  // [class.base.init]p8, per DR257:
3956  // If a given [...] base class is not named by a mem-initializer-id
3957  // [...] and the entity is not a virtual base class of an abstract
3958  // class, then [...] the entity is default-initialized.
3959  bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
3960  CXXCtorInitializer *CXXBaseInit;
3961  if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
3962  &VBase, IsInheritedVirtualBase,
3963  CXXBaseInit)) {
3964  HadError = true;
3965  continue;
3966  }
3967 
3968  Info.AllToInit.push_back(CXXBaseInit);
3969  }
3970  }
3971 
3972  // Non-virtual bases.
3973  for (auto &Base : ClassDecl->bases()) {
3974  // Virtuals are in the virtual base list and already constructed.
3975  if (Base.isVirtual())
3976  continue;
3977 
3979  = Info.AllBaseFields.lookup(Base.getType()->getAs<RecordType>())) {
3980  Info.AllToInit.push_back(Value);
3981  } else if (!AnyErrors) {
3982  CXXCtorInitializer *CXXBaseInit;
3983  if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
3984  &Base, /*IsInheritedVirtualBase=*/false,
3985  CXXBaseInit)) {
3986  HadError = true;
3987  continue;
3988  }
3989 
3990  Info.AllToInit.push_back(CXXBaseInit);
3991  }
3992  }
3993 
3994  // Fields.
3995  for (auto *Mem : ClassDecl->decls()) {
3996  if (auto *F = dyn_cast<FieldDecl>(Mem)) {
3997  // C++ [class.bit]p2:
3998  // A declaration for a bit-field that omits the identifier declares an
3999  // unnamed bit-field. Unnamed bit-fields are not members and cannot be
4000  // initialized.
4001  if (F->isUnnamedBitfield())
4002  continue;
4003 
4004  // If we're not generating the implicit copy/move constructor, then we'll
4005  // handle anonymous struct/union fields based on their individual
4006  // indirect fields.
4007  if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
4008  continue;
4009 
4010  if (CollectFieldInitializer(*this, Info, F))
4011  HadError = true;
4012  continue;
4013  }
4014 
4015  // Beyond this point, we only consider default initialization.
4016  if (Info.isImplicitCopyOrMove())
4017  continue;
4018 
4019  if (auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
4020  if (F->getType()->isIncompleteArrayType()) {
4021  assert(ClassDecl->hasFlexibleArrayMember() &&
4022  "Incomplete array type is not valid");
4023  continue;
4024  }
4025 
4026  // Initialize each field of an anonymous struct individually.
4027  if (CollectFieldInitializer(*this, Info, F->getAnonField(), F))
4028  HadError = true;
4029 
4030  continue;
4031  }
4032  }
4033 
4034  unsigned NumInitializers = Info.AllToInit.size();
4035  if (NumInitializers > 0) {
4036  Constructor->setNumCtorInitializers(NumInitializers);
4037  CXXCtorInitializer **baseOrMemberInitializers =
4038  new (Context) CXXCtorInitializer*[NumInitializers];
4039  memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
4040  NumInitializers * sizeof(CXXCtorInitializer*));
4041  Constructor->setCtorInitializers(baseOrMemberInitializers);
4042 
4043  // Constructors implicitly reference the base and member
4044  // destructors.
4046  Constructor->getParent());
4047  }
4048 
4049  return HadError;
4050 }
4051 
4053  if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
4054  const RecordDecl *RD = RT->getDecl();
4055  if (RD->isAnonymousStructOrUnion()) {
4056  for (auto *Field : RD->fields())
4057  PopulateKeysForFields(Field, IdealInits);
4058  return;
4059  }
4060  }
4061  IdealInits.push_back(Field->getCanonicalDecl());
4062 }
4063 
4064 static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
4065  return Context.getCanonicalType(BaseType).getTypePtr();
4066 }
4067 
4068 static const void *GetKeyForMember(ASTContext &Context,
4069  CXXCtorInitializer *Member) {
4070  if (!Member->isAnyMemberInitializer())
4071  return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0));
4072 
4073  return Member->getAnyMember()->getCanonicalDecl();
4074 }
4075 
4077  Sema &SemaRef, const CXXConstructorDecl *Constructor,
4079  if (Constructor->getDeclContext()->isDependentContext())
4080  return;
4081 
4082  // Don't check initializers order unless the warning is enabled at the
4083  // location of at least one initializer.
4084  bool ShouldCheckOrder = false;
4085  for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
4086  CXXCtorInitializer *Init = Inits[InitIndex];
4087  if (!SemaRef.Diags.isIgnored(diag::warn_initializer_out_of_order,
4088  Init->getSourceLocation())) {
4089  ShouldCheckOrder = true;
4090  break;
4091  }
4092  }
4093  if (!ShouldCheckOrder)
4094  return;
4095 
4096  // Build the list of bases and members in the order that they'll
4097  // actually be initialized. The explicit initializers should be in
4098  // this same order but may be missing things.
4099  SmallVector<const void*, 32> IdealInitKeys;
4100 
4101  const CXXRecordDecl *ClassDecl = Constructor->getParent();
4102 
4103  // 1. Virtual bases.
4104  for (const auto &VBase : ClassDecl->vbases())
4105  IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase.getType()));
4106 
4107  // 2. Non-virtual bases.
4108  for (const auto &Base : ClassDecl->bases()) {
4109  if (Base.isVirtual())
4110  continue;
4111  IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base.getType()));
4112  }
4113 
4114  // 3. Direct fields.
4115  for (auto *Field : ClassDecl->fields()) {
4116  if (Field->isUnnamedBitfield())
4117  continue;
4118 
4119  PopulateKeysForFields(Field, IdealInitKeys);
4120  }
4121 
4122  unsigned NumIdealInits = IdealInitKeys.size();
4123  unsigned IdealIndex = 0;
4124 
4125  CXXCtorInitializer *PrevInit = nullptr;
4126  for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
4127  CXXCtorInitializer *Init = Inits[InitIndex];
4128  const void *InitKey = GetKeyForMember(SemaRef.Context, Init);
4129 
4130  // Scan forward to try to find this initializer in the idealized
4131  // initializers list.
4132  for (; IdealIndex != NumIdealInits; ++IdealIndex)
4133  if (InitKey == IdealInitKeys[IdealIndex])
4134  break;
4135 
4136  // If we didn't find this initializer, it must be because we
4137  // scanned past it on a previous iteration. That can only
4138  // happen if we're out of order; emit a warning.
4139  if (IdealIndex == NumIdealInits && PrevInit) {
4141  SemaRef.Diag(PrevInit->getSourceLocation(),
4142  diag::warn_initializer_out_of_order);
4143 
4144  if (PrevInit->isAnyMemberInitializer())
4145  D << 0 << PrevInit->getAnyMember()->getDeclName();
4146  else
4147  D << 1 << PrevInit->getTypeSourceInfo()->getType();
4148 
4149  if (Init->isAnyMemberInitializer())
4150  D << 0 << Init->getAnyMember()->getDeclName();
4151  else
4152  D << 1 << Init->getTypeSourceInfo()->getType();
4153 
4154  // Move back to the initializer's location in the ideal list.
4155  for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
4156  if (InitKey == IdealInitKeys[IdealIndex])
4157  break;
4158 
4159  assert(IdealIndex < NumIdealInits &&
4160  "initializer not found in initializer list");
4161  }
4162 
4163  PrevInit = Init;
4164  }
4165 }
4166 
4167 namespace {
4168 bool CheckRedundantInit(Sema &S,
4169  CXXCtorInitializer *Init,
4170  CXXCtorInitializer *&PrevInit) {
4171  if (!PrevInit) {
4172  PrevInit = Init;
4173  return false;
4174  }
4175 
4176  if (FieldDecl *Field = Init->getAnyMember())
4177  S.Diag(Init->getSourceLocation(),
4178  diag::err_multiple_mem_initialization)
4179  << Field->getDeclName()
4180  << Init->getSourceRange();
4181  else {
4182  const Type *BaseClass = Init->getBaseClass();
4183  assert(BaseClass && "neither field nor base");
4184  S.Diag(Init->getSourceLocation(),
4185  diag::err_multiple_base_initialization)
4186  << QualType(BaseClass, 0)
4187  << Init->getSourceRange();
4188  }
4189  S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer)
4190  << 0 << PrevInit->getSourceRange();
4191 
4192  return true;
4193 }
4194 
4195 typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
4196 typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
4197 
4198 bool CheckRedundantUnionInit(Sema &S,
4199  CXXCtorInitializer *Init,
4200  RedundantUnionMap &Unions) {
4201  FieldDecl *Field = Init->getAnyMember();
4202  RecordDecl *Parent = Field->getParent();
4203  NamedDecl *Child = Field;
4204 
4205  while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {
4206  if (Parent->isUnion()) {
4207  UnionEntry &En = Unions[Parent];
4208  if (En.first && En.first != Child) {
4209  S.Diag(Init->getSourceLocation(),
4210  diag::err_multiple_mem_union_initialization)
4211  << Field->getDeclName()
4212  << Init->getSourceRange();
4213  S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
4214  << 0 << En.second->getSourceRange();
4215  return true;
4216  }
4217  if (!En.first) {
4218  En.first = Child;
4219  En.second = Init;
4220  }
4221  if (!Parent->isAnonymousStructOrUnion())
4222  return false;
4223  }
4224 
4225  Child = Parent;
4226  Parent = cast<RecordDecl>(Parent->getDeclContext());
4227  }
4228 
4229  return false;
4230 }
4231 }
4232 
4233 /// ActOnMemInitializers - Handle the member initializers for a constructor.
4234 void Sema::ActOnMemInitializers(Decl *ConstructorDecl,
4237  bool AnyErrors) {
4238  if (!ConstructorDecl)
4239  return;
4240 
4241  AdjustDeclIfTemplate(ConstructorDecl);
4242 
4243  CXXConstructorDecl *Constructor
4244  = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
4245 
4246  if (!Constructor) {
4247  Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
4248  return;
4249  }
4250 
4251  // Mapping for the duplicate initializers check.
4252  // For member initializers, this is keyed with a FieldDecl*.
4253  // For base initializers, this is keyed with a Type*.
4254  llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
4255 
4256  // Mapping for the inconsistent anonymous-union initializers check.
4257  RedundantUnionMap MemberUnions;
4258 
4259  bool HadError = false;
4260  for (unsigned i = 0; i < MemInits.size(); i++) {
4261  CXXCtorInitializer *Init = MemInits[i];
4262 
4263  // Set the source order index.
4264  Init->setSourceOrder(i);
4265 
4266  if (Init->isAnyMemberInitializer()) {
4267  const void *Key = GetKeyForMember(Context, Init);
4268  if (CheckRedundantInit(*this, Init, Members[Key]) ||
4269  CheckRedundantUnionInit(*this, Init, MemberUnions))
4270  HadError = true;
4271  } else if (Init->isBaseInitializer()) {
4272  const void *Key = GetKeyForMember(Context, Init);
4273  if (CheckRedundantInit(*this, Init, Members[Key]))
4274  HadError = true;
4275  } else {
4276  assert(Init->isDelegatingInitializer());
4277  // This must be the only initializer
4278  if (MemInits.size() != 1) {
4279  Diag(Init->getSourceLocation(),
4280  diag::err_delegating_initializer_alone)
4281  << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
4282  // We will treat this as being the only initializer.
4283  }
4284  SetDelegatingInitializer(Constructor, MemInits[i]);
4285  // Return immediately as the initializer is set.
4286  return;
4287  }
4288  }
4289 
4290  if (HadError)
4291  return;
4292 
4293  DiagnoseBaseOrMemInitializerOrder(*this, Constructor, MemInits);
4294 
4295  SetCtorInitializers(Constructor, AnyErrors, MemInits);
4296 
4297  DiagnoseUninitializedFields(*this, Constructor);
4298 }
4299 
4300 void
4302  CXXRecordDecl *ClassDecl) {
4303  // Ignore dependent contexts. Also ignore unions, since their members never
4304  // have destructors implicitly called.
4305  if (ClassDecl->isDependentContext() || ClassDecl->isUnion())
4306  return;
4307 
4308  // FIXME: all the access-control diagnostics are positioned on the
4309  // field/base declaration. That's probably good; that said, the
4310  // user might reasonably want to know why the destructor is being
4311  // emitted, and we currently don't say.
4312 
4313  // Non-static data members.
4314  for (auto *Field : ClassDecl->fields()) {
4315  if (Field->isInvalidDecl())
4316  continue;
4317 
4318  // Don't destroy incomplete or zero-length arrays.
4320  continue;
4321 
4322  QualType FieldType = Context.getBaseElementType(Field->getType());
4323 
4324  const RecordType* RT = FieldType->getAs<RecordType>();
4325  if (!RT)
4326  continue;
4327 
4328  CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
4329  if (FieldClassDecl->isInvalidDecl())
4330  continue;
4331  if (FieldClassDecl->hasIrrelevantDestructor())
4332  continue;
4333  // The destructor for an implicit anonymous union member is never invoked.
4334  if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
4335  continue;
4336 
4337  CXXDestructorDecl *Dtor = LookupDestructor(FieldClassDecl);
4338  assert(Dtor && "No dtor found for FieldClassDecl!");
4339  CheckDestructorAccess(Field->getLocation(), Dtor,
4340  PDiag(diag::err_access_dtor_field)
4341  << Field->getDeclName()
4342  << FieldType);
4343 
4344  MarkFunctionReferenced(Location, Dtor);
4345  DiagnoseUseOfDecl(Dtor, Location);
4346  }
4347 
4348  llvm::SmallPtrSet<const RecordType *, 8> DirectVirtualBases;
4349 
4350  // Bases.
4351  for (const auto &Base : ClassDecl->bases()) {
4352  // Bases are always records in a well-formed non-dependent class.
4353  const RecordType *RT = Base.getType()->getAs<RecordType>();
4354 
4355  // Remember direct virtual bases.
4356  if (Base.isVirtual())
4357  DirectVirtualBases.insert(RT);
4358 
4359  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
4360  // If our base class is invalid, we probably can't get its dtor anyway.
4361  if (BaseClassDecl->isInvalidDecl())
4362  continue;
4363  if (BaseClassDecl->hasIrrelevantDestructor())
4364  continue;
4365 
4366  CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
4367  assert(Dtor && "No dtor found for BaseClassDecl!");
4368 
4369  // FIXME: caret should be on the start of the class name
4370  CheckDestructorAccess(Base.getLocStart(), Dtor,
4371  PDiag(diag::err_access_dtor_base)
4372  << Base.getType()
4373  << Base.getSourceRange(),
4374  Context.getTypeDeclType(ClassDecl));
4375 
4376  MarkFunctionReferenced(Location, Dtor);
4377  DiagnoseUseOfDecl(Dtor, Location);
4378  }
4379 
4380  // Virtual bases.
4381  for (const auto &VBase : ClassDecl->vbases()) {
4382  // Bases are always records in a well-formed non-dependent class.
4383  const RecordType *RT = VBase.getType()->castAs<RecordType>();
4384 
4385  // Ignore direct virtual bases.
4386  if (DirectVirtualBases.count(RT))
4387  continue;
4388 
4389  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
4390  // If our base class is invalid, we probably can't get its dtor anyway.
4391  if (BaseClassDecl->isInvalidDecl())
4392  continue;
4393  if (BaseClassDecl->hasIrrelevantDestructor())
4394  continue;
4395 
4396  CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
4397  assert(Dtor && "No dtor found for BaseClassDecl!");
4399  ClassDecl->getLocation(), Dtor,
4400  PDiag(diag::err_access_dtor_vbase)
4401  << Context.getTypeDeclType(ClassDecl) << VBase.getType(),
4402  Context.getTypeDeclType(ClassDecl)) ==
4403  AR_accessible) {
4405  Context.getTypeDeclType(ClassDecl), VBase.getType(),
4406  diag::err_access_dtor_vbase, 0, ClassDecl->getLocation(),
4407  SourceRange(), DeclarationName(), nullptr);
4408  }
4409 
4410  MarkFunctionReferenced(Location, Dtor);
4411  DiagnoseUseOfDecl(Dtor, Location);
4412  }
4413 }
4414 
4415 void Sema::ActOnDefaultCtorInitializers(Decl *CDtorDecl) {
4416  if (!CDtorDecl)
4417  return;
4418 
4419  if (CXXConstructorDecl *Constructor
4420  = dyn_cast<CXXConstructorDecl>(CDtorDecl)) {
4421  SetCtorInitializers(Constructor, /*AnyErrors=*/false);
4422  DiagnoseUninitializedFields(*this, Constructor);
4423  }
4424 }
4425 
4427  if (!getLangOpts().CPlusPlus)
4428  return false;
4429 
4430  const auto *RD = Context.getBaseElementType(T)->getAsCXXRecordDecl();
4431  if (!RD)
4432  return false;
4433 
4434  // FIXME: Per [temp.inst]p1, we are supposed to trigger instantiation of a
4435  // class template specialization here, but doing so breaks a lot of code.
4436 
4437  // We can't answer whether something is abstract until it has a
4438  // definition. If it's currently being defined, we'll walk back
4439  // over all the declarations when we have a full definition.
4440  const CXXRecordDecl *Def = RD->getDefinition();
4441  if (!Def || Def->isBeingDefined())
4442  return false;
4443 
4444  return RD->isAbstract();
4445 }
4446 
4448  TypeDiagnoser &Diagnoser) {
4449  if (!isAbstractType(Loc, T))
4450  return false;
4451 
4452  T = Context.getBaseElementType(T);
4453  Diagnoser.diagnose(*this, Loc, T);
4455  return true;
4456 }
4457 
4459  // Check if we've already emitted the list of pure virtual functions
4460  // for this class.
4462  return;
4463 
4464  // If the diagnostic is suppressed, don't emit the notes. We're only
4465  // going to emit them once, so try to attach them to a diagnostic we're
4466  // actually going to show.
4468  return;
4469 
4470  CXXFinalOverriderMap FinalOverriders;
4471  RD->getFinalOverriders(FinalOverriders);
4472 
4473  // Keep a set of seen pure methods so we won't diagnose the same method
4474  // more than once.
4475  llvm::SmallPtrSet<const CXXMethodDecl *, 8> SeenPureMethods;
4476 
4477  for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
4478  MEnd = FinalOverriders.end();
4479  M != MEnd;
4480  ++M) {
4481  for (OverridingMethods::iterator SO = M->second.begin(),
4482  SOEnd = M->second.end();
4483  SO != SOEnd; ++SO) {
4484  // C++ [class.abstract]p4:
4485  // A class is abstract if it contains or inherits at least one
4486  // pure virtual function for which the final overrider is pure
4487  // virtual.
4488 
4489  //
4490  if (SO->second.size() != 1)
4491  continue;
4492 
4493  if (!SO->second.front().Method->isPure())
4494  continue;
4495 
4496  if (!SeenPureMethods.insert(SO->second.front().Method).second)
4497  continue;
4498 
4499  Diag(SO->second.front().Method->getLocation(),
4500  diag::note_pure_virtual_function)
4501  << SO->second.front().Method->getDeclName() << RD->getDeclName();
4502  }
4503  }
4504 
4507  PureVirtualClassDiagSet->insert(RD);
4508 }
4509 
4510 namespace {
4511 struct AbstractUsageInfo {
4512  Sema &S;
4513  CXXRecordDecl *Record;
4514  CanQualType AbstractType;
4515  bool Invalid;
4516 
4517  AbstractUsageInfo(Sema &S, CXXRecordDecl *Record)
4518  : S(S), Record(Record),
4519  AbstractType(S.Context.getCanonicalType(
4520  S.Context.getTypeDeclType(Record))),
4521  Invalid(false) {}
4522 
4523  void DiagnoseAbstractType() {
4524  if (Invalid) return;
4525  S.DiagnoseAbstractType(Record);
4526  Invalid = true;
4527  }
4528 
4529  void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
4530 };
4531 
4532 struct CheckAbstractUsage {
4533  AbstractUsageInfo &Info;
4534  const NamedDecl *Ctx;
4535 
4536  CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
4537  : Info(Info), Ctx(Ctx) {}
4538 
4539  void Visit(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
4540  switch (TL.getTypeLocClass()) {
4541 #define ABSTRACT_TYPELOC(CLASS, PARENT)
4542 #define TYPELOC(CLASS, PARENT) \
4543  case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
4544 #include "clang/AST/TypeLocNodes.def"
4545  }
4546  }
4547 
4548  void Check(FunctionProtoTypeLoc TL, Sema::AbstractDiagSelID Sel) {
4550  for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {
4551  if (!TL.getParam(I))
4552  continue;
4553 
4555  if (TSI) Visit(TSI->getTypeLoc(), Sema::AbstractParamType);
4556  }
4557  }
4558 
4559  void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) {
4561  }
4562 
4564  // Visit the type parameters from a permissive context.
4565  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
4566  TemplateArgumentLoc TAL = TL.getArgLoc(I);
4568  if (TypeSourceInfo *TSI = TAL.getTypeSourceInfo())
4569  Visit(TSI->getTypeLoc(), Sema::AbstractNone);
4570  // TODO: other template argument types?
4571  }
4572  }
4573 
4574  // Visit pointee types from a permissive context.
4575 #define CheckPolymorphic(Type) \
4576  void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
4577  Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
4578  }
4584 
4585  /// Handle all the types we haven't given a more specific
4586  /// implementation for above.
4587  void Check(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
4588  // Every other kind of type that we haven't called out already
4589  // that has an inner type is either (1) sugar or (2) contains that
4590  // inner type in some way as a subobject.
4591  if (TypeLoc Next = TL.getNextTypeLoc())
4592  return Visit(Next, Sel);
4593 
4594  // If there's no inner type and we're in a permissive context,
4595  // don't diagnose.
4596  if (Sel == Sema::AbstractNone) return;
4597 
4598  // Check whether the type matches the abstract type.
4599  QualType T = TL.getType();
4600  if (T->isArrayType()) {
4602  T = Info.S.Context.getBaseElementType(T);
4603  }
4605  if (CT != Info.AbstractType) return;
4606 
4607  // It matched; do some magic.
4608  if (Sel == Sema::AbstractArrayType) {
4609  Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type)
4610  << T << TL.getSourceRange();
4611  } else {
4612  Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl)
4613  << Sel << T << TL.getSourceRange();
4614  }
4615  Info.DiagnoseAbstractType();
4616  }
4617 };
4618 
4619 void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
4621  CheckAbstractUsage(*this, D).Visit(TL, Sel);
4622 }
4623 
4624 }
4625 
4626 /// Check for invalid uses of an abstract type in a method declaration.
4627 static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
4628  CXXMethodDecl *MD) {
4629  // No need to do the check on definitions, which require that
4630  // the return/param types be complete.
4631  if (MD->doesThisDeclarationHaveABody())
4632  return;
4633 
4634  // For safety's sake, just ignore it if we don't have type source
4635  // information. This should never happen for non-implicit methods,
4636  // but...
4637  if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
4638  Info.CheckType(MD, TSI->getTypeLoc(), Sema::AbstractNone);
4639 }
4640 
4641 /// Check for invalid uses of an abstract type within a class definition.
4642 static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
4643  CXXRecordDecl *RD) {
4644  for (auto *D : RD->decls()) {
4645  if (D->isImplicit()) continue;
4646 
4647  // Methods and method templates.
4648  if (isa<CXXMethodDecl>(D)) {
4649  CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(D));
4650  } else if (isa<FunctionTemplateDecl>(D)) {
4651  FunctionDecl *FD = cast<FunctionTemplateDecl>(D)->getTemplatedDecl();
4652  CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(FD));
4653 
4654  // Fields and static variables.
4655  } else if (isa<FieldDecl>(D)) {
4656  FieldDecl *FD = cast<FieldDecl>(D);
4657  if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
4658  Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractFieldType);
4659  } else if (isa<VarDecl>(D)) {
4660  VarDecl *VD = cast<VarDecl>(D);
4661  if (TypeSourceInfo *TSI = VD->getTypeSourceInfo())
4662  Info.CheckType(VD, TSI->getTypeLoc(), Sema::AbstractVariableType);
4663 
4664  // Nested classes and class templates.
4665  } else if (isa<CXXRecordDecl>(D)) {
4666  CheckAbstractClassUsage(Info, cast<CXXRecordDecl>(D));
4667  } else if (isa<ClassTemplateDecl>(D)) {
4669  cast<ClassTemplateDecl>(D)->getTemplatedDecl());
4670  }
4671  }
4672 }
4673 
4675  Attr *ClassAttr = getDLLAttr(Class);
4676  if (!ClassAttr)
4677  return;
4678 
4679  assert(ClassAttr->getKind() == attr::DLLExport);
4680 
4682 
4684  // Don't go any further if this is just an explicit instantiation
4685  // declaration.
4686  return;
4687 
4688  for (Decl *Member : Class->decls()) {
4689  auto *MD = dyn_cast<CXXMethodDecl>(Member);
4690  if (!MD)
4691  continue;
4692 
4693  if (Member->getAttr<DLLExportAttr>()) {
4694  if (MD->isUserProvided()) {
4695  // Instantiate non-default class member functions ...
4696 
4697  // .. except for certain kinds of template specializations.
4698  if (TSK == TSK_ImplicitInstantiation && !ClassAttr->isInherited())
4699  continue;
4700 
4701  S.MarkFunctionReferenced(Class->getLocation(), MD);
4702 
4703  // The function will be passed to the consumer when its definition is
4704  // encountered.
4705  } else if (!MD->isTrivial() || MD->isExplicitlyDefaulted() ||
4706  MD->isCopyAssignmentOperator() ||
4707  MD->isMoveAssignmentOperator()) {
4708  // Synthesize and instantiate non-trivial implicit methods, explicitly
4709  // defaulted methods, and the copy and move assignment operators. The
4710  // latter are exported even if they are trivial, because the address of
4711  // an operator can be taken and should compare equal accross libraries.
4712  DiagnosticErrorTrap Trap(S.Diags);
4713  S.MarkFunctionReferenced(Class->getLocation(), MD);
4714  if (Trap.hasErrorOccurred()) {
4715  S.Diag(ClassAttr->getLocation(), diag::note_due_to_dllexported_class)
4716  << Class->getName() << !S.getLangOpts().CPlusPlus11;
4717  break;
4718  }
4719 
4720  // There is no later point when we will see the definition of this
4721  // function, so pass it to the consumer now.
4723  }
4724  }
4725  }
4726 }
4727 
4728 /// \brief Check class-level dllimport/dllexport attribute.
4730  Attr *ClassAttr = getDLLAttr(Class);
4731 
4732  // MSVC inherits DLL attributes to partial class template specializations.
4733  if (Context.getTargetInfo().getCXXABI().isMicrosoft() && !ClassAttr) {
4734  if (auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(Class)) {
4735  if (Attr *TemplateAttr =
4736  getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
4737  auto *A = cast<InheritableAttr>(TemplateAttr->clone(getASTContext()));
4738  A->setInherited(true);
4739  ClassAttr = A;
4740  }
4741  }
4742  }
4743 
4744  if (!ClassAttr)
4745  return;
4746 
4747  if (!Class->isExternallyVisible()) {
4748  Diag(Class->getLocation(), diag::err_attribute_dll_not_extern)
4749  << Class << ClassAttr;
4750  return;
4751  }
4752 
4754  !ClassAttr->isInherited()) {
4755  // Diagnose dll attributes on members of class with dll attribute.
4756  for (Decl *Member : Class->decls()) {
4757  if (!isa<VarDecl>(Member) && !isa<CXXMethodDecl>(Member))
4758  continue;
4759  InheritableAttr *MemberAttr = getDLLAttr(Member);
4760  if (!MemberAttr || MemberAttr->isInherited() || Member->isInvalidDecl())
4761  continue;
4762 
4763  Diag(MemberAttr->getLocation(),
4764  diag::err_attribute_dll_member_of_dll_class)
4765  << MemberAttr << ClassAttr;
4766  Diag(ClassAttr->getLocation(), diag::note_previous_attribute);
4767  Member->setInvalidDecl();
4768  }
4769  }
4770 
4771  if (Class->getDescribedClassTemplate())
4772  // Don't inherit dll attribute until the template is instantiated.
4773  return;
4774 
4775  // The class is either imported or exported.
4776  const bool ClassExported = ClassAttr->getKind() == attr::DLLExport;
4777  const bool ClassImported = !ClassExported;
4778 
4780 
4781  // Ignore explicit dllexport on explicit class template instantiation declarations.
4782  if (ClassExported && !ClassAttr->isInherited() &&
4784  Class->dropAttr<DLLExportAttr>();
4785  return;
4786  }
4787 
4788  // Force declaration of implicit members so they can inherit the attribute.
4790 
4791  // FIXME: MSVC's docs say all bases must be exportable, but this doesn't
4792  // seem to be true in practice?
4793 
4794  for (Decl *Member : Class->decls()) {
4795  VarDecl *VD = dyn_cast<VarDecl>(Member);
4796  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Member);
4797 
4798  // Only methods and static fields inherit the attributes.
4799  if (!VD && !MD)
4800  continue;
4801 
4802  if (MD) {
4803  // Don't process deleted methods.
4804  if (MD->isDeleted())
4805  continue;
4806 
4807  if (MD->isInlined()) {
4808  // MinGW does not import or export inline methods.
4810  continue;
4811 
4812  // MSVC versions before 2015 don't export the move assignment operators,
4813  // so don't attempt to import them if we have a definition.
4814  if (ClassImported && MD->isMoveAssignmentOperator() &&
4816  continue;
4817  }
4818  }
4819 
4820  if (!cast<NamedDecl>(Member)->isExternallyVisible())
4821  continue;
4822 
4823  if (!getDLLAttr(Member)) {
4824  auto *NewAttr =
4825  cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
4826  NewAttr->setInherited(true);
4827  Member->addAttr(NewAttr);
4828  }
4829  }
4830 
4831  if (ClassExported)
4832  DelayedDllExportClasses.push_back(Class);
4833 }
4834 
4835 /// \brief Perform propagation of DLL attributes from a derived class to a
4836 /// templated base class for MS compatibility.
4838  CXXRecordDecl *Class, Attr *ClassAttr,
4839  ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc) {
4840  if (getDLLAttr(
4841  BaseTemplateSpec->getSpecializedTemplate()->getTemplatedDecl())) {
4842  // If the base class template has a DLL attribute, don't try to change it.
4843  return;
4844  }
4845 
4846  auto TSK = BaseTemplateSpec->getSpecializationKind();
4847  if (!getDLLAttr(BaseTemplateSpec) &&
4849  TSK == TSK_ImplicitInstantiation)) {
4850  // The template hasn't been instantiated yet (or it has, but only as an
4851  // explicit instantiation declaration or implicit instantiation, which means
4852  // we haven't codegenned any members yet), so propagate the attribute.
4853  auto *NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
4854  NewAttr->setInherited(true);
4855  BaseTemplateSpec->addAttr(NewAttr);
4856 
4857  // If the template is already instantiated, checkDLLAttributeRedeclaration()
4858  // needs to be run again to work see the new attribute. Otherwise this will
4859  // get run whenever the template is instantiated.
4860  if (TSK != TSK_Undeclared)
4861  checkClassLevelDLLAttribute(BaseTemplateSpec);
4862 
4863  return;
4864  }
4865 
4866  if (getDLLAttr(BaseTemplateSpec)) {
4867  // The template has already been specialized or instantiated with an
4868  // attribute, explicitly or through propagation. We should not try to change
4869  // it.
4870  return;
4871  }
4872 
4873  // The template was previously instantiated or explicitly specialized without
4874  // a dll attribute, It's too late for us to add an attribute, so warn that
4875  // this is unsupported.
4876  Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)
4877  << BaseTemplateSpec->isExplicitSpecialization();
4878  Diag(ClassAttr->getLocation(), diag::note_attribute);
4879  if (BaseTemplateSpec->isExplicitSpecialization()) {
4880  Diag(BaseTemplateSpec->getLocation(),
4881  diag::note_template_class_explicit_specialization_was_here)
4882  << BaseTemplateSpec;
4883  } else {
4884  Diag(BaseTemplateSpec->getPointOfInstantiation(),
4885  diag::note_template_class_instantiation_was_here)
4886  << BaseTemplateSpec;
4887  }
4888 }
4889 
4890 /// \brief Perform semantic checks on a class definition that has been
4891 /// completing, introducing implicitly-declared members, checking for
4892 /// abstract types, etc.
4894  if (!Record)
4895  return;
4896 
4897  if (Record->isAbstract() && !Record->isInvalidDecl()) {
4898  AbstractUsageInfo Info(*this, Record);
4899  CheckAbstractClassUsage(Info, Record);
4900  }
4901 
4902  // If this is not an aggregate type and has no user-declared constructor,
4903  // complain about any non-static data members of reference or const scalar
4904  // type, since they will never get initializers.
4905  if (!Record->isInvalidDecl() && !Record->isDependentType() &&
4906  !Record->isAggregate() && !Record->hasUserDeclaredConstructor() &&
4907  !Record->isLambda()) {
4908  bool Complained = false;
4909  for (const auto *F : Record->fields()) {
4910  if (F->hasInClassInitializer() || F->isUnnamedBitfield())
4911  continue;
4912 
4913  if (F->getType()->isReferenceType() ||
4914  (F->getType().isConstQualified() && F->getType()->isScalarType())) {
4915  if (!Complained) {
4916  Diag(Record->getLocation(), diag::warn_no_constructor_for_refconst)
4917  << Record->getTagKind() << Record;
4918  Complained = true;
4919  }
4920 
4921  Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
4922  << F->getType()->isReferenceType()
4923  << F->getDeclName();
4924  }
4925  }
4926  }
4927 
4928  if (Record->getIdentifier()) {
4929  // C++ [class.mem]p13:
4930  // If T is the name of a class, then each of the following shall have a
4931  // name different from T:
4932  // - every member of every anonymous union that is a member of class T.
4933  //
4934  // C++ [class.mem]p14:
4935  // In addition, if class T has a user-declared constructor (12.1), every
4936  // non-static data member of class T shall have a name different from T.
4937  DeclContext::lookup_result R = Record->lookup(Record->getDeclName());
4938  for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
4939  ++I) {
4940  NamedDecl *D = *I;
4941  if ((isa<FieldDecl>(D) && Record->hasUserDeclaredConstructor()) ||
4942  isa<IndirectFieldDecl>(D)) {
4943  Diag(D->getLocation(), diag::err_member_name_of_class)
4944  << D->getDeclName();
4945  break;
4946  }
4947  }
4948  }
4949 
4950  // Warn if the class has virtual methods but non-virtual public destructor.
4951  if (Record->isPolymorphic() && !Record->isDependentType()) {
4952  CXXDestructorDecl *dtor = Record->getDestructor();
4953  if ((!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public)) &&
4954  !Record->hasAttr<FinalAttr>())
4955  Diag(dtor ? dtor->getLocation() : Record->getLocation(),
4956  diag::warn_non_virtual_dtor) << Context.getRecordType(Record);
4957  }
4958 
4959  if (Record->isAbstract()) {
4960  if (FinalAttr *FA = Record->getAttr<FinalAttr>()) {
4961  Diag(Record->getLocation(), diag::warn_abstract_final_class)
4962  << FA->isSpelledAsSealed();
4963  DiagnoseAbstractType(Record);
4964  }
4965  }
4966 
4967  bool HasMethodWithOverrideControl = false,
4968  HasOverridingMethodWithoutOverrideControl = false;
4969  if (!Record->isDependentType()) {
4970  for (auto *M : Record->methods()) {
4971  // See if a method overloads virtual methods in a base
4972  // class without overriding any.
4973  if (!M->isStatic())
4975  if (M->hasAttr<OverrideAttr>())
4976  HasMethodWithOverrideControl = true;
4977  else if (M->size_overridden_methods() > 0)
4978  HasOverridingMethodWithoutOverrideControl = true;
4979  // Check whether the explicitly-defaulted special members are valid.
4980  if (!M->isInvalidDecl() && M->isExplicitlyDefaulted())
4982 
4983  // For an explicitly defaulted or deleted special member, we defer
4984  // determining triviality until the class is complete. That time is now!
4985  if (!M->isImplicit() && !M->isUserProvided()) {
4987  if (CSM != CXXInvalid) {
4988  M->setTrivial(SpecialMemberIsTrivial(M, CSM));
4989 
4990  // Inform the class that we've finished declaring this member.
4992  }
4993  }
4994  }
4995  }
4996 
4997  if (HasMethodWithOverrideControl &&
4998  HasOverridingMethodWithoutOverrideControl) {
4999  // At least one method has the 'override' control declared.
5000  // Diagnose all other overridden methods which do not have 'override' specified on them.
5001  for (auto *M : Record->methods())
5003  }
5004 
5005  // ms_struct is a request to use the same ABI rules as MSVC. Check
5006  // whether this class uses any C++ features that are implemented
5007  // completely differently in MSVC, and if so, emit a diagnostic.
5008  // That diagnostic defaults to an error, but we allow projects to
5009  // map it down to a warning (or ignore it). It's a fairly common
5010  // practice among users of the ms_struct pragma to mass-annotate
5011  // headers, sweeping up a bunch of types that the project doesn't
5012  // really rely on MSVC-compatible layout for. We must therefore
5013  // support "ms_struct except for C++ stuff" as a secondary ABI.
5014  if (Record->isMsStruct(Context) &&
5015  (Record->isPolymorphic() || Record->getNumBases())) {
5016  Diag(Record->getLocation(), diag::warn_cxx_ms_struct);
5017  }
5018 
5019  // Declare inheriting constructors. We do this eagerly here because:
5020  // - The standard requires an eager diagnostic for conflicting inheriting
5021  // constructors from different classes.
5022  // - The lazy declaration of the other implicit constructors is so as to not
5023  // waste space and performance on classes that are not meant to be
5024  // instantiated (e.g. meta-functions). This doesn't apply to classes that
5025  // have inheriting constructors.
5027 
5029 }
5030 
5031 /// Look up the special member function that would be called by a special
5032 /// member function for a subobject of class type.
5033 ///
5034 /// \param Class The class type of the subobject.
5035 /// \param CSM The kind of special member function.
5036 /// \param FieldQuals If the subobject is a field, its cv-qualifiers.
5037 /// \param ConstRHS True if this is a copy operation with a const object
5038 /// on its RHS, that is, if the argument to the outer special member
5039 /// function is 'const' and this is not a field marked 'mutable'.
5041  Sema &S, CXXRecordDecl *Class, Sema::CXXSpecialMember CSM,
5042  unsigned FieldQuals, bool ConstRHS) {
5043  unsigned LHSQuals = 0;
5044  if (CSM == Sema::CXXCopyAssignment || CSM == Sema::CXXMoveAssignment)
5045  LHSQuals = FieldQuals;
5046 
5047  unsigned RHSQuals = FieldQuals;
5048  if (CSM == Sema::CXXDefaultConstructor || CSM == Sema::CXXDestructor)
5049  RHSQuals = 0;
5050  else if (ConstRHS)
5051  RHSQuals |= Qualifiers::Const;
5052 
5053  return S.LookupSpecialMember(Class, CSM,
5054  RHSQuals & Qualifiers::Const,
5055  RHSQuals & Qualifiers::Volatile,
5056  false,
5057  LHSQuals & Qualifiers::Const,
5058  LHSQuals & Qualifiers::Volatile);
5059 }
5060 
5061 /// Is the special member function which would be selected to perform the
5062 /// specified operation on the specified class type a constexpr constructor?
5063 static bool specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl,
5065  unsigned Quals, bool ConstRHS) {
5067  lookupCallFromSpecialMember(S, ClassDecl, CSM, Quals, ConstRHS);
5068  if (!SMOR || !SMOR->getMethod())
5069  // A constructor we wouldn't select can't be "involved in initializing"
5070  // anything.
5071  return true;
5072  return SMOR->getMethod()->isConstexpr();
5073 }
5074 
5075 /// Determine whether the specified special member function would be constexpr
5076 /// if it were implicitly defined.
5079  bool ConstArg) {
5080  if (!S.getLangOpts().CPlusPlus11)
5081  return false;
5082 
5083  // C++11 [dcl.constexpr]p4:
5084  // In the definition of a constexpr constructor [...]
5085  bool Ctor = true;
5086  switch (CSM) {
5088  // Since default constructor lookup is essentially trivial (and cannot
5089  // involve, for instance, template instantiation), we compute whether a
5090  // defaulted default constructor is constexpr directly within CXXRecordDecl.
5091  //
5092  // This is important for performance; we need to know whether the default
5093  // constructor is constexpr to determine whether the type is a literal type.
5094  return ClassDecl->defaultedDefaultConstructorIsConstexpr();
5095 
5098  // For copy or move constructors, we need to perform overload resolution.
5099  break;
5100 
5103  if (!S.getLangOpts().CPlusPlus14)
5104  return false;
5105  // In C++1y, we need to perform overload resolution.
5106  Ctor = false;
5107  break;
5108 
5109  case Sema::CXXDestructor:
5110  case Sema::CXXInvalid:
5111  return false;
5112  }
5113 
5114  // -- if the class is a non-empty union, or for each non-empty anonymous
5115  // union member of a non-union class, exactly one non-static data member
5116  // shall be initialized; [DR1359]
5117  //
5118  // If we squint, this is guaranteed, since exactly one non-static data member
5119  // will be initialized (if the constructor isn't deleted), we just don't know
5120  // which one.
5121  if (Ctor && ClassDecl->isUnion())
5122  return true;
5123 
5124  // -- the class shall not have any virtual base classes;
5125  if (Ctor && ClassDecl->getNumVBases())
5126  return false;
5127 
5128  // C++1y [class.copy]p26:
5129  // -- [the class] is a literal type, and
5130  if (!Ctor && !ClassDecl->isLiteral())
5131  return false;
5132 
5133  // -- every constructor involved in initializing [...] base class
5134  // sub-objects shall be a constexpr constructor;
5135  // -- the assignment operator selected to copy/move each direct base
5136  // class is a constexpr function, and
5137  for (const auto &B : ClassDecl->bases()) {
5138  const RecordType *BaseType = B.getType()->getAs<RecordType>();
5139  if (!BaseType) continue;
5140 
5141  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
5142  if (!specialMemberIsConstexpr(S, BaseClassDecl, CSM, 0, ConstArg))
5143  return false;
5144  }
5145 
5146  // -- every constructor involved in initializing non-static data members
5147  // [...] shall be a constexpr constructor;
5148  // -- every non-static data member and base class sub-object shall be
5149  // initialized
5150  // -- for each non-static data member of X that is of class type (or array
5151  // thereof), the assignment operator selected to copy/move that member is
5152  // a constexpr function
5153  for (const auto *F : ClassDecl->fields()) {
5154  if (F->isInvalidDecl())
5155  continue;
5156  QualType BaseType = S.Context.getBaseElementType(F->getType());
5157  if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
5158  CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
5159  if (!specialMemberIsConstexpr(S, FieldRecDecl, CSM,
5160  BaseType.getCVRQualifiers(),
5161  ConstArg && !F->isMutable()))
5162  return false;
5163  }
5164  }
5165 
5166  // All OK, it's constexpr!
5167  return true;
5168 }
5169 
5172  switch (S.getSpecialMember(MD)) {
5174  return S.ComputeDefaultedDefaultCtorExceptionSpec(Loc, MD);
5183  case Sema::CXXDestructor:
5184  return S.ComputeDefaultedDtorExceptionSpec(MD);
5185  case Sema::CXXInvalid:
5186  break;
5187  }
5188  assert(cast<CXXConstructorDecl>(MD)->getInheritedConstructor() &&
5189  "only special members have implicit exception specs");
5190  return S.ComputeInheritingCtorExceptionSpec(cast<CXXConstructorDecl>(MD));
5191 }
5192 
5194  CXXMethodDecl *MD) {
5196 
5197  // Build an exception specification pointing back at this member.
5199  EPI.ExceptionSpec.SourceDecl = MD;
5200 
5201  // Set the calling convention to the default for C++ instance methods.
5202  EPI.ExtInfo = EPI.ExtInfo.withCallingConv(
5203  S.Context.getDefaultCallingConvention(/*IsVariadic=*/false,
5204  /*IsCXXMethod=*/true));
5205  return EPI;
5206 }
5207 
5209  const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
5210  if (FPT->getExceptionSpecType() != EST_Unevaluated)
5211  return;
5212 
5213  // Evaluate the exception specification.
5214  auto ESI = computeImplicitExceptionSpec(*this, Loc, MD).getExceptionSpec();
5215 
5216  // Update the type of the special member to use it.
5217  UpdateExceptionSpec(MD, ESI);
5218 
5219  // A user-provided destructor can be defined outside the class. When that
5220  // happens, be sure to update the exception specification on both
5221  // declarations.
5222  const FunctionProtoType *CanonicalFPT =
5224  if (CanonicalFPT->getExceptionSpecType() == EST_Unevaluated)
5226 }
5227 
5229  CXXRecordDecl *RD = MD->getParent();
5231 
5232  assert(MD->isExplicitlyDefaulted() && CSM != CXXInvalid &&
5233  "not an explicitly-defaulted special member");
5234 
5235  // Whether this was the first-declared instance of the constructor.
5236  // This affects whether we implicitly add an exception spec and constexpr.
5237  bool First = MD == MD->getCanonicalDecl();
5238 
5239  bool HadError = false;
5240 
5241  // C++11 [dcl.fct.def.default]p1:
5242  // A function that is explicitly defaulted shall
5243  // -- be a special member function (checked elsewhere),
5244  // -- have the same type (except for ref-qualifiers, and except that a
5245  // copy operation can take a non-const reference) as an implicit
5246  // declaration, and
5247  // -- not have default arguments.
5248  unsigned ExpectedParams = 1;
5249  if (CSM == CXXDefaultConstructor || CSM == CXXDestructor)
5250  ExpectedParams = 0;
5251  if (MD->getNumParams() != ExpectedParams) {
5252  // This also checks for default arguments: a copy or move constructor with a
5253  // default argument is classified as a default constructor, and assignment
5254  // operations and destructors can't have default arguments.
5255  Diag(MD->getLocation(), diag::err_defaulted_special_member_params)
5256  << CSM << MD->getSourceRange();
5257  HadError = true;
5258  } else if (MD->isVariadic()) {
5259  Diag(MD->getLocation(), diag::err_defaulted_special_member_variadic)
5260  << CSM << MD->getSourceRange();
5261  HadError = true;
5262  }
5263 
5265 
5266  bool CanHaveConstParam = false;
5267  if (CSM == CXXCopyConstructor)
5268  CanHaveConstParam = RD->implicitCopyConstructorHasConstParam();
5269  else if (CSM == CXXCopyAssignment)
5270  CanHaveConstParam = RD->implicitCopyAssignmentHasConstParam();
5271 
5272  QualType ReturnType = Context.VoidTy;
5273  if (CSM == CXXCopyAssignment || CSM == CXXMoveAssignment) {
5274  // Check for return type matching.
5275  ReturnType = Type->getReturnType();
5276  QualType ExpectedReturnType =
5278  if (!Context.hasSameType(ReturnType, ExpectedReturnType)) {
5279  Diag(MD->getLocation(), diag::err_defaulted_special_member_return_type)
5280  << (CSM == CXXMoveAssignment) << ExpectedReturnType;
5281  HadError = true;
5282  }
5283 
5284  // A defaulted special member cannot have cv-qualifiers.
5285  if (Type->getTypeQuals()) {
5286  Diag(MD->getLocation(), diag::err_defaulted_special_member_quals)
5287  << (CSM == CXXMoveAssignment) << getLangOpts().CPlusPlus14;
5288  HadError = true;
5289  }
5290  }
5291 
5292  // Check for parameter type matching.
5293  QualType ArgType = ExpectedParams ? Type->getParamType(0) : QualType();
5294  bool HasConstParam = false;
5295  if (ExpectedParams && ArgType->isReferenceType()) {
5296  // Argument must be reference to possibly-const T.
5297  QualType ReferentType = ArgType->getPointeeType();
5298  HasConstParam = ReferentType.isConstQualified();
5299 
5300  if (ReferentType.isVolatileQualified()) {
5301  Diag(MD->getLocation(),
5302  diag::err_defaulted_special_member_volatile_param) << CSM;
5303  HadError = true;
5304  }
5305 
5306  if (HasConstParam && !CanHaveConstParam) {
5307  if (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment) {
5308  Diag(MD->getLocation(),
5309  diag::err_defaulted_special_member_copy_const_param)
5310  << (CSM == CXXCopyAssignment);
5311  // FIXME: Explain why this special member can't be const.
5312  } else {
5313  Diag(MD->getLocation(),
5314  diag::err_defaulted_special_member_move_const_param)
5315  << (CSM == CXXMoveAssignment);
5316  }
5317  HadError = true;
5318  }
5319  } else if (ExpectedParams) {
5320  // A copy assignment operator can take its argument by value, but a
5321  // defaulted one cannot.
5322  assert(CSM == CXXCopyAssignment && "unexpected non-ref argument");
5323  Diag(MD->getLocation(), diag::err_defaulted_copy_assign_not_ref);
5324  HadError = true;
5325  }
5326 
5327  // C++11 [dcl.fct.def.default]p2:
5328  // An explicitly-defaulted function may be declared constexpr only if it
5329  // would have been implicitly declared as constexpr,
5330  // Do not apply this rule to members of class templates, since core issue 1358
5331  // makes such functions always instantiate to constexpr functions. For
5332  // functions which cannot be constexpr (for non-constructors in C++11 and for
5333  // destructors in C++1y), this is checked elsewhere.
5334  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
5335  HasConstParam);
5336  if ((getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD)
5337  : isa<CXXConstructorDecl>(MD)) &&
5338  MD->isConstexpr() && !Constexpr &&
5340  Diag(MD->getLocStart(), diag::err_incorrect_defaulted_constexpr) << CSM;
5341  // FIXME: Explain why the special member can't be constexpr.
5342  HadError = true;
5343  }
5344 
5345  // and may have an explicit exception-specification only if it is compatible
5346  // with the exception-specification on the implicit declaration.
5347  if (Type->hasExceptionSpec()) {
5348  // Delay the check if this is the first declaration of the special member,
5349  // since we may not have parsed some necessary in-class initializers yet.
5350  if (First) {
5351  // If the exception specification needs to be instantiated, do so now,
5352  // before we clobber it with an EST_Unevaluated specification below.
5353  if (Type->getExceptionSpecType() == EST_Uninstantiated) {
5355  Type = MD->getType()->getAs<FunctionProtoType>();
5356  }
5357  DelayedDefaultedMemberExceptionSpecs.push_back(std::make_pair(MD, Type));
5358  } else
5360  }
5361 
5362  // If a function is explicitly defaulted on its first declaration,
5363  if (First) {
5364  // -- it is implicitly considered to be constexpr if the implicit
5365  // definition would be,
5366  MD->setConstexpr(Constexpr);
5367 
5368  // -- it is implicitly considered to have the same exception-specification
5369  // as if it had been implicitly declared,
5372  EPI.ExceptionSpec.SourceDecl = MD;
5373  MD->setType(Context.getFunctionType(ReturnType,
5374  llvm::makeArrayRef(&ArgType,
5375  ExpectedParams),
5376  EPI));
5377  }
5378 
5379  if (ShouldDeleteSpecialMember(MD, CSM)) {
5380  if (First) {
5381  SetDeclDeleted(MD, MD->getLocation());
5382  } else {
5383  // C++11 [dcl.fct.def.default]p4:
5384  // [For a] user-provided explicitly-defaulted function [...] if such a
5385  // function is implicitly defined as deleted, the program is ill-formed.
5386  Diag(MD->getLocation(), diag::err_out_of_line_default_deletes) << CSM;
5387  ShouldDeleteSpecialMember(MD, CSM, /*Diagnose*/true);
5388  HadError = true;
5389  }
5390  }
5391 
5392  if (HadError)
5393  MD->setInvalidDecl();
5394 }
5395 
5396 /// Check whether the exception specification provided for an
5397 /// explicitly-defaulted special member matches the exception specification
5398 /// that would have been generated for an implicit special member, per
5399 /// C++11 [dcl.fct.def.default]p2.
5401  CXXMethodDecl *MD, const FunctionProtoType *SpecifiedType) {
5402  // If the exception specification was explicitly specified but hadn't been
5403  // parsed when the method was defaulted, grab it now.
5404  if (SpecifiedType->getExceptionSpecType() == EST_Unparsed)
5405  SpecifiedType =
5407 
5408  // Compute the implicit exception specification.
5409  CallingConv CC = Context.getDefaultCallingConvention(/*IsVariadic=*/false,
5410  /*IsCXXMethod=*/true);
5413  .getExceptionSpec();
5414  const FunctionProtoType *ImplicitType = cast<FunctionProtoType>(
5416 
5417  // Ensure that it matches.
5419  PDiag(diag::err_incorrect_defaulted_exception_spec)
5420  << getSpecialMember(MD), PDiag(),
5421  ImplicitType, SourceLocation(),
5422  SpecifiedType, MD->getLocation());
5423 }
5424 
5426  decltype(DelayedExceptionSpecChecks) Checks;
5427  decltype(DelayedDefaultedMemberExceptionSpecs) Specs;
5428 
5429  std::swap(Checks, DelayedExceptionSpecChecks);
5430  std::swap(Specs, DelayedDefaultedMemberExceptionSpecs);
5431 
5432  // Perform any deferred checking of exception specifications for virtual
5433  // destructors.
5434  for (auto &Check : Checks)
5435  CheckOverridingFunctionExceptionSpec(Check.first, Check.second);
5436 
5437  // Check that any explicitly-defaulted methods have exception specifications
5438  // compatible with their implicit exception specifications.
5439  for (auto &Spec : Specs)
5440  CheckExplicitlyDefaultedMemberExceptionSpec(Spec.first, Spec.second);
5441 }
5442 
5443 namespace {
5444 struct SpecialMemberDeletionInfo {
5445  Sema &S;
5446  CXXMethodDecl *MD;
5448  bool Diagnose;
5449 
5450  // Properties of the special member, computed for convenience.
5451  bool IsConstructor, IsAssignment, IsMove, ConstArg;
5452  SourceLocation Loc;
5453 
5454  bool AllFieldsAreConst;
5455 
5456  SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD,
5457  Sema::CXXSpecialMember CSM, bool Diagnose)
5458  : S(S), MD(MD), CSM(CSM), Diagnose(Diagnose),
5459  IsConstructor(false), IsAssignment(false), IsMove(false),
5460  ConstArg(false), Loc(MD->getLocation()),
5461  AllFieldsAreConst(true) {
5462  switch (CSM) {
5465  IsConstructor = true;
5466  break;
5468  IsConstructor = true;
5469  IsMove = true;
5470  break;
5472  IsAssignment = true;
5473  break;
5475  IsAssignment = true;
5476  IsMove = true;
5477  break;
5478  case Sema::CXXDestructor:
5479  break;
5480  case Sema::CXXInvalid:
5481  llvm_unreachable("invalid special member kind");
5482  }
5483 
5484  if (MD->getNumParams()) {
5485  if (const ReferenceType *RT =
5486  MD->getParamDecl(0)->getType()->getAs<ReferenceType>())
5487  ConstArg = RT->getPointeeType().isConstQualified();
5488  }
5489  }
5490 
5491  bool inUnion() const { return MD->getParent()->isUnion(); }
5492 
5493  /// Look up the corresponding special member in the given class.
5495  unsigned Quals, bool IsMutable) {
5496  return lookupCallFromSpecialMember(S, Class, CSM, Quals,
5497  ConstArg && !IsMutable);
5498  }
5499 
5500  typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
5501 
5502  bool shouldDeleteForBase(CXXBaseSpecifier *Base);
5503  bool shouldDeleteForField(FieldDecl *FD);
5504  bool shouldDeleteForAllConstMembers();
5505 
5506  bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
5507  unsigned Quals);
5508  bool shouldDeleteForSubobjectCall(Subobject Subobj,
5510  bool IsDtorCallInCtor);
5511 
5512  bool isAccessible(Subobject Subobj, CXXMethodDecl *D);
5513 };
5514 }
5515 
5516 /// Is the given special member inaccessible when used on the given
5517 /// sub-object.
5518 bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
5519  CXXMethodDecl *target) {
5520  /// If we're operating on a base class, the object type is the
5521  /// type of this special member.
5522  QualType objectTy;
5523  AccessSpecifier access = target->getAccess();
5524  if (CXXBaseSpecifier *base = Subobj.dyn_cast<CXXBaseSpecifier*>()) {
5525  objectTy = S.Context.getTypeDeclType(MD->getParent());
5526  access = CXXRecordDecl::MergeAccess(base->getAccessSpecifier(), access);
5527 
5528  // If we're operating on a field, the object type is the type of the field.
5529  } else {
5530  objectTy = S.Context.getTypeDeclType(target->getParent());
5531  }
5532 
5533  return S.isSpecialMemberAccessibleForDeletion(target, access, objectTy);
5534 }
5535 
5536 /// Check whether we should delete a special member due to the implicit
5537 /// definition containing a call to a special member of a subobject.
5538 bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
5539  Subobject Subobj, Sema::SpecialMemberOverloadResult *SMOR,
5540  bool IsDtorCallInCtor) {
5541  CXXMethodDecl *Decl = SMOR->getMethod();
5542  FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
5543 
5544  int DiagKind = -1;
5545 
5547  DiagKind = !Decl ? 0 : 1;
5549  DiagKind = 2;
5550  else if (!isAccessible(Subobj, Decl))
5551  DiagKind = 3;
5552  else if (!IsDtorCallInCtor && Field && Field->getParent()->isUnion() &&
5553  !Decl->isTrivial()) {
5554  // A member of a union must have a trivial corresponding special member.
5555  // As a weird special case, a destructor call from a union's constructor
5556  // must be accessible and non-deleted, but need not be trivial. Such a
5557  // destructor is never actually called, but is semantically checked as
5558  // if it were.
5559  DiagKind = 4;
5560  }
5561 
5562  if (DiagKind == -1)
5563  return false;
5564 
5565  if (Diagnose) {
5566  if (Field) {
5567  S.Diag(Field->getLocation(),
5568  diag::note_deleted_special_member_class_subobject)
5569  << CSM << MD->getParent() << /*IsField*/true
5570  << Field << DiagKind << IsDtorCallInCtor;
5571  } else {
5572  CXXBaseSpecifier *Base = Subobj.get<CXXBaseSpecifier*>();
5573  S.Diag(Base->getLocStart(),
5574  diag::note_deleted_special_member_class_subobject)
5575  << CSM << MD->getParent() << /*IsField*/false
5576  << Base->getType() << DiagKind << IsDtorCallInCtor;
5577  }
5578 
5579  if (DiagKind == 1)
5580  S.NoteDeletedFunction(Decl);
5581  // FIXME: Explain inaccessibility if DiagKind == 3.
5582  }
5583 
5584  return true;
5585 }
5586 
5587 /// Check whether we should delete a special member function due to having a
5588 /// direct or virtual base class or non-static data member of class type M.
5589 bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
5590  CXXRecordDecl *Class, Subobject Subobj, unsigned Quals) {
5591  FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
5592  bool IsMutable = Field && Field->isMutable();
5593 
5594  // C++11 [class.ctor]p5:
5595  // -- any direct or virtual base class, or non-static data member with no
5596  // brace-or-equal-initializer, has class type M (or array thereof) and
5597  // either M has no default constructor or overload resolution as applied
5598  // to M's default constructor results in an ambiguity or in a function
5599  // that is deleted or inaccessible
5600  // C++11 [class.copy]p11, C++11 [class.copy]p23:
5601  // -- a direct or virtual base class B that cannot be copied/moved because
5602  // overload resolution, as applied to B's corresponding special member,
5603  // results in an ambiguity or a function that is deleted or inaccessible
5604  // from the defaulted special member
5605  // C++11 [class.dtor]p5:
5606  // -- any direct or virtual base class [...] has a type with a destructor
5607  // that is deleted or inaccessible
5608  if (!(CSM == Sema::CXXDefaultConstructor &&
5609  Field && Field->hasInClassInitializer()) &&
5610  shouldDeleteForSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable),
5611  false))
5612  return true;
5613 
5614  // C++11 [class.ctor]p5, C++11 [class.copy]p11:
5615  // -- any direct or virtual base class or non-static data member has a
5616  // type with a destructor that is deleted or inaccessible
5617  if (IsConstructor) {
5620  false, false, false, false, false);
5621  if (shouldDeleteForSubobjectCall(Subobj, SMOR, true))
5622  return true;
5623  }
5624 
5625  return false;
5626 }
5627 
5628 /// Check whether we should delete a special member function due to the class
5629 /// having a particular direct or virtual base class.
5630 bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
5631  CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
5632  // If program is correct, BaseClass cannot be null, but if it is, the error
5633  // must be reported elsewhere.
5634  return BaseClass && shouldDeleteForClassSubobject(BaseClass, Base, 0);
5635 }
5636 
5637 /// Check whether we should delete a special member function due to the class
5638 /// having a particular non-static data member.
5639 bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) {
5640  QualType FieldType = S.Context.getBaseElementType(FD->getType());
5641  CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl();
5642 
5643  if (CSM == Sema::CXXDefaultConstructor) {
5644  // For a default constructor, all references must be initialized in-class
5645  // and, if a union, it must have a non-const member.
5646  if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) {
5647  if (Diagnose)
5648  S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
5649  << MD->getParent() << FD << FieldType << /*Reference*/0;
5650  return true;
5651  }
5652  // C++11 [class.ctor]p5: any non-variant non-static data member of
5653  // const-qualified type (or array thereof) with no
5654  // brace-or-equal-initializer does not have a user-provided default
5655  // constructor.
5656  if (!inUnion() && FieldType.isConstQualified() &&
5657  !FD->hasInClassInitializer() &&
5658  (!FieldRecord || !FieldRecord->hasUserProvidedDefaultConstructor())) {
5659  if (Diagnose)
5660  S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
5661  << MD->getParent() << FD << FD->getType() << /*Const*/1;
5662  return true;
5663  }
5664 
5665  if (inUnion() && !FieldType.isConstQualified())
5666  AllFieldsAreConst = false;
5667  } else if (CSM == Sema::CXXCopyConstructor) {
5668  // For a copy constructor, data members must not be of rvalue reference
5669  // type.
5670  if (FieldType->isRValueReferenceType()) {
5671  if (Diagnose)
5672  S.Diag(FD->getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
5673  << MD->getParent() << FD << FieldType;
5674  return true;
5675  }
5676  } else if (IsAssignment) {
5677  // For an assignment operator, data members must not be of reference type.
5678  if (FieldType->isReferenceType()) {
5679  if (Diagnose)
5680  S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
5681  << IsMove << MD->getParent() << FD << FieldType << /*Reference*/0;
5682  return true;
5683  }
5684  if (!FieldRecord && FieldType.isConstQualified()) {
5685  // C++11 [class.copy]p23:
5686  // -- a non-static data member of const non-class type (or array thereof)
5687  if (Diagnose)
5688  S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
5689  << IsMove << MD->getParent() << FD << FD->getType() << /*Const*/1;
5690  return true;
5691  }
5692  }
5693 
5694  if (FieldRecord) {
5695  // Some additional restrictions exist on the variant members.
5696  if (!inUnion() && FieldRecord->isUnion() &&
5697  FieldRecord->isAnonymousStructOrUnion()) {
5698  bool AllVariantFieldsAreConst = true;
5699 
5700  // FIXME: Handle anonymous unions declared within anonymous unions.
5701  for (auto *UI : FieldRecord->fields()) {
5702  QualType UnionFieldType = S.Context.getBaseElementType(UI->getType());
5703 
5704  if (!UnionFieldType.isConstQualified())
5705  AllVariantFieldsAreConst = false;
5706 
5707  CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl();
5708  if (UnionFieldRecord &&
5709  shouldDeleteForClassSubobject(UnionFieldRecord, UI,
5710  UnionFieldType.getCVRQualifiers()))
5711  return true;
5712  }
5713 
5714  // At least one member in each anonymous union must be non-const
5715  if (CSM == Sema::CXXDefaultConstructor && AllVariantFieldsAreConst &&
5716  !FieldRecord->field_empty()) {
5717  if (Diagnose)
5718  S.Diag(FieldRecord->getLocation(),
5719  diag::note_deleted_default_ctor_all_const)
5720  << MD->getParent() << /*anonymous union*/1;
5721  return true;
5722  }
5723 
5724  // Don't check the implicit member of the anonymous union type.
5725  // This is technically non-conformant, but sanity demands it.
5726  return false;
5727  }
5728 
5729  if (shouldDeleteForClassSubobject(FieldRecord, FD,
5730  FieldType.getCVRQualifiers()))
5731  return true;
5732  }
5733 
5734  return false;
5735 }
5736 
5737 /// C++11 [class.ctor] p5:
5738 /// A defaulted default constructor for a class X is defined as deleted if
5739 /// X is a union and all of its variant members are of const-qualified type.
5740 bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
5741  // This is a silly definition, because it gives an empty union a deleted
5742  // default constructor. Don't do that.
5743  if (CSM == Sema::CXXDefaultConstructor && inUnion() && AllFieldsAreConst &&
5744  !MD->getParent()->field_empty()) {
5745  if (Diagnose)
5746  S.Diag(MD->getParent()->getLocation(),
5747  diag::note_deleted_default_ctor_all_const)
5748  << MD->getParent() << /*not anonymous union*/0;
5749  return true;
5750  }
5751  return false;
5752 }
5753 
5754 /// Determine whether a defaulted special member function should be defined as
5755 /// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11,
5756 /// C++11 [class.copy]p23, and C++11 [class.dtor]p5.
5758  bool Diagnose) {
5759  if (MD->isInvalidDecl())
5760  return false;
5761  CXXRecordDecl *RD = MD->getParent();
5762  assert(!RD->isDependentType() && "do deletion after instantiation");
5763  if (!LangOpts.CPlusPlus11 || RD->isInvalidDecl())
5764  return false;
5765 
5766  // C++11 [expr.lambda.prim]p19:
5767  // The closure type associated with a lambda-expression has a
5768  // deleted (8.4.3) default constructor and a deleted copy
5769  // assignment operator.
5770  if (RD->isLambda() &&
5771  (CSM == CXXDefaultConstructor || CSM == CXXCopyAssignment)) {
5772  if (Diagnose)
5773  Diag(RD->getLocation(), diag::note_lambda_decl);
5774  return true;
5775  }
5776 
5777  // For an anonymous struct or union, the copy and assignment special members
5778  // will never be used, so skip the check. For an anonymous union declared at
5779  // namespace scope, the constructor and destructor are used.
5780  if (CSM != CXXDefaultConstructor && CSM != CXXDestructor &&
5782  return false;
5783 
5784  // C++11 [class.copy]p7, p18:
5785  // If the class definition declares a move constructor or move assignment
5786  // operator, an implicitly declared copy constructor or copy assignment
5787  // operator is defined as deleted.
5788  if (MD->isImplicit() &&
5789  (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment)) {
5790  CXXMethodDecl *UserDeclaredMove = nullptr;
5791 
5792  // In Microsoft mode, a user-declared move only causes the deletion of the
5793  // corresponding copy operation, not both copy operations.
5794  if (RD->hasUserDeclaredMoveConstructor() &&
5795  (!getLangOpts().MSVCCompat || CSM == CXXCopyConstructor)) {
5796  if (!Diagnose) return true;
5797 
5798  // Find any user-declared move constructor.
5799  for (auto *I : RD->ctors()) {
5800  if (I->isMoveConstructor()) {
5801  UserDeclaredMove = I;
5802  break;
5803  }
5804  }
5805  assert(UserDeclaredMove);
5806  } else if (RD->hasUserDeclaredMoveAssignment() &&
5807  (!getLangOpts().MSVCCompat || CSM == CXXCopyAssignment)) {
5808  if (!Diagnose) return true;
5809 
5810  // Find any user-declared move assignment operator.
5811  for (auto *I : RD->methods()) {
5812  if (I->isMoveAssignmentOperator()) {
5813  UserDeclaredMove = I;
5814  break;
5815  }
5816  }
5817  assert(UserDeclaredMove);
5818  }
5819 
5820  if (UserDeclaredMove) {
5821  Diag(UserDeclaredMove->getLocation(),
5822  diag::note_deleted_copy_user_declared_move)
5823  << (CSM == CXXCopyAssignment) << RD
5824  << UserDeclaredMove->isMoveAssignmentOperator();
5825  return true;
5826  }
5827  }
5828 
5829  // Do access control from the special member function
5830  ContextRAII MethodContext(*this, MD);
5831 
5832  // C++11 [class.dtor]p5:
5833  // -- for a virtual destructor, lookup of the non-array deallocation function
5834  // results in an ambiguity or in a function that is deleted or inaccessible
5835  if (CSM == CXXDestructor && MD->isVirtual()) {
5836  FunctionDecl *OperatorDelete = nullptr;
5840  OperatorDelete, false)) {
5841  if (Diagnose)
5842  Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete);
5843  return true;
5844  }
5845  }
5846 
5847  SpecialMemberDeletionInfo SMI(*this, MD, CSM, Diagnose);
5848 
5849  for (auto &BI : RD->bases())
5850  if (!BI.isVirtual() &&
5851  SMI.shouldDeleteForBase(&BI))
5852  return true;
5853 
5854  // Per DR1611, do not consider virtual bases of constructors of abstract
5855  // classes, since we are not going to construct them.
5856  if (!RD->isAbstract() || !SMI.IsConstructor) {
5857  for (auto &BI : RD->vbases())
5858  if (SMI.shouldDeleteForBase(&BI))
5859  return true;
5860  }
5861 
5862  for (auto *FI : RD->fields())
5863  if (!FI->isInvalidDecl() && !FI->isUnnamedBitfield() &&
5864  SMI.shouldDeleteForField(FI))
5865  return true;
5866 
5867  if (SMI.shouldDeleteForAllConstMembers())
5868  return true;
5869 
5870  if (getLangOpts().CUDA) {
5871  // We should delete the special member in CUDA mode if target inference
5872  // failed.
5873  return inferCUDATargetForImplicitSpecialMember(RD, CSM, MD, SMI.ConstArg,
5874  Diagnose);
5875  }
5876 
5877  return false;
5878 }
5879 
5880 /// Perform lookup for a special member of the specified kind, and determine
5881 /// whether it is trivial. If the triviality can be determined without the
5882 /// lookup, skip it. This is intended for use when determining whether a
5883 /// special member of a containing object is trivial, and thus does not ever
5884 /// perform overload resolution for default constructors.
5885 ///
5886 /// If \p Selected is not \c NULL, \c *Selected will be filled in with the
5887 /// member that was most likely to be intended to be trivial, if any.
5889  Sema::CXXSpecialMember CSM, unsigned Quals,
5890  bool ConstRHS, CXXMethodDecl **Selected) {
5891  if (Selected)
5892  *Selected = nullptr;
5893 
5894  switch (CSM) {
5895  case Sema::CXXInvalid:
5896  llvm_unreachable("not a special member");
5897 
5899  // C++11 [class.ctor]p5:
5900  // A default constructor is trivial if:
5901  // - all the [direct subobjects] have trivial default constructors
5902  //
5903  // Note, no overload resolution is performed in this case.
5904  if (RD->hasTrivialDefaultConstructor())
5905  return true;
5906 
5907  if (Selected) {
5908  // If there's a default constructor which could have been trivial, dig it
5909  // out. Otherwise, if there's any user-provided default constructor, point
5910  // to that as an example of why there's not a trivial one.
5911  CXXConstructorDecl *DefCtor = nullptr;
5914  for (auto *CI : RD->ctors()) {
5915  if (!CI->isDefaultConstructor())
5916  continue;
5917  DefCtor = CI;
5918  if (!DefCtor->isUserProvided())
5919  break;
5920  }
5921 
5922  *Selected = DefCtor;
5923  }
5924 
5925  return false;
5926 
5927  case Sema::CXXDestructor:
5928  // C++11 [class.dtor]p5:
5929  // A destructor is trivial if:
5930  // - all the direct [subobjects] have trivial destructors
5931  if (RD->hasTrivialDestructor())
5932  return true;
5933 
5934  if (Selected) {
5935  if (RD->needsImplicitDestructor())
5937  *Selected = RD->getDestructor();
5938  }
5939 
5940  return false;
5941 
5943  // C++11 [class.copy]p12:
5944  // A copy constructor is trivial if:
5945  // - the constructor selected to copy each direct [subobject] is trivial
5946  if (RD->hasTrivialCopyConstructor()) {
5947  if (Quals == Qualifiers::Const)
5948  // We must either select the trivial copy constructor or reach an
5949  // ambiguity; no need to actually perform overload resolution.
5950  return true;
5951  } else if (!Selected) {
5952  return false;
5953  }
5954  // In C++98, we are not supposed to perform overload resolution here, but we
5955  // treat that as a language defect, as suggested on cxx-abi-dev, to treat
5956  // cases like B as having a non-trivial copy constructor:
5957  // struct A { template<typename T> A(T&); };
5958  // struct B { mutable A a; };
5959  goto NeedOverloadResolution;
5960 
5962  // C++11 [class.copy]p25:
5963  // A copy assignment operator is trivial if:
5964  // - the assignment operator selected to copy each direct [subobject] is
5965  // trivial
5966  if (RD->hasTrivialCopyAssignment()) {
5967  if (Quals == Qualifiers::Const)
5968  return true;
5969  } else if (!Selected) {
5970  return false;
5971  }
5972  // In C++98, we are not supposed to perform overload resolution here, but we
5973  // treat that as a language defect.
5974  goto NeedOverloadResolution;
5975 
5978  NeedOverloadResolution:
5980  lookupCallFromSpecialMember(S, RD, CSM, Quals, ConstRHS);
5981 
5982  // The standard doesn't describe how to behave if the lookup is ambiguous.
5983  // We treat it as not making the member non-trivial, just like the standard
5984  // mandates for the default constructor. This should rarely matter, because
5985  // the member will also be deleted.
5987  return true;
5988 
5989  if (!SMOR->getMethod()) {
5990  assert(SMOR->getKind() ==
5992  return false;
5993  }
5994 
5995  // We deliberately don't check if we found a deleted special member. We're
5996  // not supposed to!
5997  if (Selected)
5998  *Selected = SMOR->getMethod();
5999  return SMOR->getMethod()->isTrivial();
6000  }
6001 
6002  llvm_unreachable("unknown special method kind");
6003 }
6004 
6006  for (auto *CI : RD->ctors())
6007  if (!CI->isImplicit())
6008  return CI;
6009 
6010  // Look for constructor templates.
6011  typedef CXXRecordDecl::specific_decl_iterator<FunctionTemplateDecl> tmpl_iter;
6012  for (tmpl_iter TI(RD->decls_begin()), TE(RD->decls_end()); TI != TE; ++TI) {
6013  if (CXXConstructorDecl *CD =
6014  dyn_cast<CXXConstructorDecl>(TI->getTemplatedDecl()))
6015  return CD;
6016  }
6017 
6018  return nullptr;
6019 }
6020 
6021 /// The kind of subobject we are checking for triviality. The values of this
6022 /// enumeration are used in diagnostics.
6024  /// The subobject is a base class.
6026  /// The subobject is a non-static data member.
6028  /// The object is actually the complete object.
6030 };
6031 
6032 /// Check whether the special member selected for a given type would be trivial.
6034  QualType SubType, bool ConstRHS,
6037  bool Diagnose) {
6038  CXXRecordDecl *SubRD = SubType->getAsCXXRecordDecl();
6039  if (!SubRD)
6040  return true;
6041 
6042  CXXMethodDecl *Selected;
6043  if (findTrivialSpecialMember(S, SubRD, CSM, SubType.getCVRQualifiers(),
6044  ConstRHS, Diagnose ? &Selected : nullptr))
6045  return true;
6046 
6047  if (Diagnose) {
6048  if (ConstRHS)
6049  SubType.addConst();
6050 
6051  if (!Selected && CSM == Sema::CXXDefaultConstructor) {
6052  S.Diag(SubobjLoc, diag::note_nontrivial_no_def_ctor)
6053  << Kind << SubType.getUnqualifiedType();
6054  if (CXXConstructorDecl *CD = findUserDeclaredCtor(SubRD))
6055  S.Diag(CD->getLocation(), diag::note_user_declared_ctor);
6056  } else if (!Selected)
6057  S.Diag(SubobjLoc, diag::note_nontrivial_no_copy)
6058  << Kind << SubType.getUnqualifiedType() << CSM << SubType;
6059  else if (Selected->isUserProvided()) {
6060  if (Kind == TSK_CompleteObject)
6061  S.Diag(Selected->getLocation(), diag::note_nontrivial_user_provided)
6062  << Kind << SubType.getUnqualifiedType() << CSM;
6063  else {
6064  S.Diag(SubobjLoc, diag::note_nontrivial_user_provided)
6065  << Kind << SubType.getUnqualifiedType() << CSM;
6066  S.Diag(Selected->getLocation(), diag::note_declared_at);
6067  }
6068  } else {
6069  if (Kind != TSK_CompleteObject)
6070  S.Diag(SubobjLoc, diag::note_nontrivial_subobject)
6071  << Kind << SubType.getUnqualifiedType() << CSM;
6072 
6073  // Explain why the defaulted or deleted special member isn't trivial.
6074  S.SpecialMemberIsTrivial(Selected, CSM, Diagnose);
6075  }
6076  }
6077 
6078  return false;
6079 }
6080 
6081 /// Check whether the members of a class type allow a special member to be
6082 /// trivial.
6085  bool ConstArg, bool Diagnose) {
6086  for (const auto *FI : RD->fields()) {
6087  if (FI->isInvalidDecl() || FI->isUnnamedBitfield())
6088  continue;
6089 
6090  QualType FieldType = S.Context.getBaseElementType(FI->getType());
6091 
6092  // Pretend anonymous struct or union members are members of this class.
6093  if (FI->isAnonymousStructOrUnion()) {
6094  if (!checkTrivialClassMembers(S, FieldType->getAsCXXRecordDecl(),
6095  CSM, ConstArg, Diagnose))
6096  return false;
6097  continue;
6098  }
6099 
6100  // C++11 [class.ctor]p5:
6101  // A default constructor is trivial if [...]
6102  // -- no non-static data member of its class has a
6103  // brace-or-equal-initializer
6104  if (CSM == Sema::CXXDefaultConstructor && FI->hasInClassInitializer()) {
6105  if (Diagnose)
6106  S.Diag(FI->getLocation(), diag::note_nontrivial_in_class_init) << FI;
6107  return false;
6108  }
6109 
6110  // Objective C ARC 4.3.5:
6111  // [...] nontrivally ownership-qualified types are [...] not trivially
6112  // default constructible, copy constructible, move constructible, copy
6113  // assignable, move assignable, or destructible [...]
6114  if (S.getLangOpts().ObjCAutoRefCount &&
6115  FieldType.hasNonTrivialObjCLifetime()) {
6116  if (Diagnose)
6117  S.Diag(FI->getLocation(), diag::note_nontrivial_objc_ownership)
6118  << RD << FieldType.getObjCLifetime();
6119  return false;
6120  }
6121 
6122  bool ConstRHS = ConstArg && !FI->isMutable();
6123  if (!checkTrivialSubobjectCall(S, FI->getLocation(), FieldType, ConstRHS,
6124  CSM, TSK_Field, Diagnose))
6125  return false;
6126  }
6127 
6128  return true;
6129 }
6130 
6131 /// Diagnose why the specified class does not have a trivial special member of
6132 /// the given kind.
6134  QualType Ty = Context.getRecordType(RD);
6135 
6136  bool ConstArg = (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment);
6137  checkTrivialSubobjectCall(*this, RD->getLocation(), Ty, ConstArg, CSM,
6138  TSK_CompleteObject, /*Diagnose*/true);
6139 }
6140 
6141 /// Determine whether a defaulted or deleted special member function is trivial,
6142 /// as specified in C++11 [class.ctor]p5, C++11 [class.copy]p12,
6143 /// C++11 [class.copy]p25, and C++11 [class.dtor]p5.
6145  bool Diagnose) {
6146  assert(!MD->isUserProvided() && CSM != CXXInvalid && "not special enough");
6147 
6148  CXXRecordDecl *RD = MD->getParent();
6149 
6150  bool ConstArg = false;
6151 
6152  // C++11 [class.copy]p12, p25: [DR1593]
6153  // A [special member] is trivial if [...] its parameter-type-list is
6154  // equivalent to the parameter-type-list of an implicit declaration [...]
6155  switch (CSM) {
6156  case CXXDefaultConstructor:
6157  case CXXDestructor:
6158  // Trivial default constructors and destructors cannot have parameters.
6159  break;
6160 
6161  case CXXCopyConstructor:
6162  case CXXCopyAssignment: {
6163  // Trivial copy operations always have const, non-volatile parameter types.
6164  ConstArg = true;
6165  const ParmVarDecl *Param0 = MD->getParamDecl(0);
6166  const ReferenceType *RT = Param0->getType()->getAs<ReferenceType>();
6167  if (!RT || RT->getPointeeType().getCVRQualifiers() != Qualifiers::Const) {
6168  if (Diagnose)
6169  Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
6170  << Param0->getSourceRange() << Param0->getType()
6173  return false;
6174  }
6175  break;
6176  }
6177 
6178  case CXXMoveConstructor:
6179  case CXXMoveAssignment: {
6180  // Trivial move operations always have non-cv-qualified parameters.
6181  const ParmVarDecl *Param0 = MD->getParamDecl(0);
6182  const RValueReferenceType *RT =
6183  Param0->getType()->getAs<RValueReferenceType>();
6184  if (!RT || RT->getPointeeType().getCVRQualifiers()) {
6185  if (Diagnose)
6186  Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
6187  << Param0->getSourceRange() << Param0->getType()
6189  return false;
6190  }
6191  break;
6192  }
6193 
6194  case CXXInvalid:
6195  llvm_unreachable("not a special member");
6196  }
6197 
6198  if (MD->getMinRequiredArguments() < MD->getNumParams()) {
6199  if (Diagnose)
6200  Diag(MD->getParamDecl(MD->getMinRequiredArguments())->getLocation(),
6201  diag::note_nontrivial_default_arg)
6202  << MD->getParamDecl(MD->getMinRequiredArguments())->getSourceRange();
6203  return false;
6204  }
6205  if (MD->isVariadic()) {
6206  if (Diagnose)
6207  Diag(MD->getLocation(), diag::note_nontrivial_variadic);
6208  return false;
6209  }
6210 
6211  // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
6212  // A copy/move [constructor or assignment operator] is trivial if
6213  // -- the [member] selected to copy/move each direct base class subobject
6214  // is trivial
6215  //
6216  // C++11 [class.copy]p12, C++11 [class.copy]p25:
6217  // A [default constructor or destructor] is trivial if
6218  // -- all the direct base classes have trivial [default constructors or
6219  // destructors]
6220  for (const auto &BI : RD->bases())
6221  if (!checkTrivialSubobjectCall(*this, BI.getLocStart(), BI.getType(),
6222  ConstArg, CSM, TSK_BaseClass, Diagnose))
6223  return false;
6224 
6225  // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
6226  // A copy/move [constructor or assignment operator] for a class X is
6227  // trivial if
6228  // -- for each non-static data member of X that is of class type (or array
6229  // thereof), the constructor selected to copy/move that member is
6230  // trivial
6231  //
6232  // C++11 [class.copy]p12, C++11 [class.copy]p25:
6233  // A [default constructor or destructor] is trivial if
6234  // -- for all of the non-static data members of its class that are of class
6235  // type (or array thereof), each such class has a trivial [default
6236  // constructor or destructor]
6237  if (!checkTrivialClassMembers(*this, RD, CSM, ConstArg, Diagnose))
6238  return false;
6239 
6240  // C++11 [class.dtor]p5:
6241  // A destructor is trivial if [...]
6242  // -- the destructor is not virtual
6243  if (CSM == CXXDestructor && MD->isVirtual()) {
6244  if (Diagnose)
6245  Diag(MD->getLocation(), diag::note_nontrivial_virtual_dtor) << RD;
6246  return false;
6247  }
6248 
6249  // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
6250  // A [special member] for class X is trivial if [...]
6251  // -- class X has no virtual functions and no virtual base classes
6252  if (CSM != CXXDestructor && MD->getParent()->isDynamicClass()) {
6253  if (!Diagnose)
6254  return false;
6255 
6256  if (RD->getNumVBases()) {
6257  // Check for virtual bases. We already know that the corresponding
6258  // member in all bases is trivial, so vbases must all be direct.
6259  CXXBaseSpecifier &BS = *RD->vbases_begin();
6260  assert(BS.isVirtual());
6261  Diag(BS.getLocStart(), diag::note_nontrivial_has_virtual) << RD << 1;
6262  return false;
6263  }
6264 
6265  // Must have a virtual method.
6266  for (const auto *MI : RD->methods()) {
6267  if (MI->isVirtual()) {
6268  SourceLocation MLoc = MI->getLocStart();
6269  Diag(MLoc, diag::note_nontrivial_has_virtual) << RD << 0;
6270  return false;
6271  }
6272  }
6273 
6274  llvm_unreachable("dynamic class with no vbases and no virtual functions");
6275  }
6276 
6277  // Looks like it's trivial!
6278  return true;
6279 }
6280 
6281 namespace {
6282 struct FindHiddenVirtualMethod {
6283  Sema *S;
6284  CXXMethodDecl *Method;
6285  llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
6286  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
6287 
6288 private:
6289  /// Check whether any most overriden method from MD in Methods
6290  static bool CheckMostOverridenMethods(
6291  const CXXMethodDecl *MD,
6292  const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
6293  if (MD->size_overridden_methods() == 0)
6294  return Methods.count(MD->getCanonicalDecl());
6296  E = MD->end_overridden_methods();
6297  I != E; ++I)
6298  if (CheckMostOverridenMethods(*I, Methods))
6299  return true;
6300  return false;
6301  }
6302 
6303 public:
6304  /// Member lookup function that determines whether a given C++
6305  /// method overloads virtual methods in a base class without overriding any,
6306  /// to be used with CXXRecordDecl::lookupInBases().
6307  bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
6308  RecordDecl *BaseRecord =
6309  Specifier->getType()->getAs<RecordType>()->getDecl();
6310 
6311  DeclarationName Name = Method->getDeclName();
6312  assert(Name.getNameKind() == DeclarationName::Identifier);
6313 
6314  bool foundSameNameMethod = false;
6315  SmallVector<CXXMethodDecl *, 8> overloadedMethods;
6316  for (Path.Decls = BaseRecord->lookup(Name); !Path.Decls.empty();
6317  Path.Decls = Path.Decls.slice(1)) {
6318  NamedDecl *D = Path.Decls.front();
6319  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
6320  MD = MD->getCanonicalDecl();
6321  foundSameNameMethod = true;
6322  // Interested only in hidden virtual methods.
6323  if (!MD->isVirtual())
6324  continue;
6325  // If the method we are checking overrides a method from its base
6326  // don't warn about the other overloaded methods. Clang deviates from
6327  // GCC by only diagnosing overloads of inherited virtual functions that
6328  // do not override any other virtual functions in the base. GCC's
6329  // -Woverloaded-virtual diagnoses any derived function hiding a virtual
6330  // function from a base class. These cases may be better served by a
6331  // warning (not specific to virtual functions) on call sites when the
6332  // call would select a different function from the base class, were it
6333  // visible.
6334  // See FIXME in test/SemaCXX/warn-overload-virtual.cpp for an example.
6335  if (!S->IsOverload(Method, MD, false))
6336  return true;
6337  // Collect the overload only if its hidden.
6338  if (!CheckMostOverridenMethods(MD, OverridenAndUsingBaseMethods))
6339  overloadedMethods.push_back(MD);
6340  }
6341  }
6342 
6343  if (foundSameNameMethod)
6344  OverloadedMethods.append(overloadedMethods.begin(),
6345  overloadedMethods.end());
6346  return foundSameNameMethod;
6347  }
6348 };
6349 } // end anonymous namespace
6350 
6351 /// \brief Add the most overriden methods from MD to Methods
6353  llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
6354  if (MD->size_overridden_methods() == 0)
6355  Methods.insert(MD->getCanonicalDecl());
6357  E = MD->end_overridden_methods();
6358  I != E; ++I)
6359  AddMostOverridenMethods(*I, Methods);
6360 }
6361 
6362 /// \brief Check if a method overloads virtual methods in a base class without
6363 /// overriding any.
6365  SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
6366  if (!MD->getDeclName().isIdentifier())
6367  return;
6368 
6369  CXXBasePaths Paths(/*FindAmbiguities=*/true, // true to look in all bases.
6370  /*bool RecordPaths=*/false,
6371  /*bool DetectVirtual=*/false);
6372  FindHiddenVirtualMethod FHVM;
6373  FHVM.Method = MD;
6374  FHVM.S = this;
6375 
6376  // Keep the base methods that were overriden or introduced in the subclass
6377  // by 'using' in a set. A base method not in this set is hidden.
6378  CXXRecordDecl *DC = MD->getParent();
6380  for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
6381  NamedDecl *ND = *I;
6382  if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*I))
6383  ND = shad->getTargetDecl();
6384  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND))
6385  AddMostOverridenMethods(MD, FHVM.OverridenAndUsingBaseMethods);
6386  }
6387 
6388  if (DC->lookupInBases(FHVM, Paths))
6389  OverloadedMethods = FHVM.OverloadedMethods;
6390 }
6391 
6393  SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
6394  for (unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) {
6395  CXXMethodDecl *overloadedMD = OverloadedMethods[i];
6396  PartialDiagnostic PD = PDiag(
6397  diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
6398  HandleFunctionTypeMismatch(PD, MD->getType(), overloadedMD->getType());
6399  Diag(overloadedMD->getLocation(), PD);
6400  }
6401 }
6402 
6403 /// \brief Diagnose methods which overload virtual methods in a base class
6404 /// without overriding any.
6406  if (MD->isInvalidDecl())
6407  return;
6408 
6409  if (Diags.isIgnored(diag::warn_overloaded_virtual, MD->getLocation()))
6410  return;
6411 
6412  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
6413  FindHiddenVirtualMethods(MD, OverloadedMethods);
6414  if (!OverloadedMethods.empty()) {
6415  Diag(MD->getLocation(), diag::warn_overloaded_virtual)
6416  << MD << (OverloadedMethods.size() > 1);
6417 
6418  NoteHiddenVirtualMethods(MD, OverloadedMethods);
6419  }
6420 }
6421 
6423  Decl *TagDecl,
6424  SourceLocation LBrac,
6425  SourceLocation RBrac,
6426  AttributeList *AttrList) {
6427  if (!TagDecl)
6428  return;
6429 
6430  AdjustDeclIfTemplate(TagDecl);
6431 
6432  for (const AttributeList* l = AttrList; l; l = l->getNext()) {
6433  if (l->getKind() != AttributeList::AT_Visibility)
6434  continue;
6435  l->setInvalid();
6436  Diag(l->getLoc(), diag::warn_attribute_after_definition_ignored) <<
6437  l->getName();
6438  }
6439 
6440  ActOnFields(S, RLoc, TagDecl, llvm::makeArrayRef(
6441  // strict aliasing violation!
6442  reinterpret_cast<Decl**>(FieldCollector->getCurFields()),
6443  FieldCollector->getCurNumFields()), LBrac, RBrac, AttrList);
6444 
6446  dyn_cast_or_null<CXXRecordDecl>(TagDecl));
6447 }
6448 
6449 /// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
6450 /// special functions, such as the default constructor, copy
6451 /// constructor, or destructor, to the given C++ class (C++
6452 /// [special]p1). This routine can only be executed just before the
6453 /// definition of the class is complete.
6455  if (!ClassDecl->hasUserDeclaredConstructor())
6457 
6458  if (!ClassDecl->hasUserDeclaredCopyConstructor()) {
6460 
6461  // If the properties or semantics of the copy constructor couldn't be
6462  // determined while the class was being declared, force a declaration
6463  // of it now.
6465  DeclareImplicitCopyConstructor(ClassDecl);
6466  }
6467 
6468  if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveConstructor()) {
6470 
6472  DeclareImplicitMoveConstructor(ClassDecl);
6473  }
6474 
6475  if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
6477 
6478  // If we have a dynamic class, then the copy assignment operator may be
6479  // virtual, so we have to declare it immediately. This ensures that, e.g.,
6480  // it shows up in the right place in the vtable and that we diagnose
6481  // problems with the implicit exception specification.
6482  if (ClassDecl->isDynamicClass() ||
6484  DeclareImplicitCopyAssignment(ClassDecl);
6485  }
6486 
6487  if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveAssignment()) {
6489 
6490  // Likewise for the move assignment operator.
6491  if (ClassDecl->isDynamicClass() ||
6493  DeclareImplicitMoveAssignment(ClassDecl);
6494  }
6495 
6496  if (!ClassDecl->hasUserDeclaredDestructor()) {
6498 
6499  // If we have a dynamic class, then the destructor may be virtual, so we
6500  // have to declare the destructor immediately. This ensures that, e.g., it
6501  // shows up in the right place in the vtable and that we diagnose problems
6502  // with the implicit exception specification.
6503  if (ClassDecl->isDynamicClass() ||
6505  DeclareImplicitDestructor(ClassDecl);
6506  }
6507 }
6508 
6510  if (!D)
6511  return 0;
6512 
6513  // The order of template parameters is not important here. All names
6514  // get added to the same scope.
6516 
6517  if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
6518  D = TD->getTemplatedDecl();
6519 
6520  if (auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
6521  ParameterLists.push_back(PSD->getTemplateParameters());
6522 
6523  if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
6524  for (unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
6525  ParameterLists.push_back(DD->getTemplateParameterList(i));
6526 
6527  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
6528  if (FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
6529  ParameterLists.push_back(FTD->getTemplateParameters());
6530  }
6531  }
6532 
6533  if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
6534  for (unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
6535  ParameterLists.push_back(TD->getTemplateParameterList(i));
6536 
6537  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD)) {
6539  ParameterLists.push_back(CTD->getTemplateParameters());
6540  }
6541  }
6542 
6543  unsigned Count = 0;
6544  for (TemplateParameterList *Params : ParameterLists) {
6545  if (Params->size() > 0)
6546  // Ignore explicit specializations; they don't contribute to the template
6547  // depth.
6548  ++Count;
6549  for (NamedDecl *Param : *Params) {
6550  if (Param->getDeclName()) {
6551  S->AddDecl(Param);
6552  IdResolver.AddDecl(Param);
6553  }
6554  }
6555  }
6556 
6557  return Count;
6558 }
6559 
6561  if (!RecordD) return;
6562  AdjustDeclIfTemplate(RecordD);
6563  CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD);
6564  PushDeclContext(S, Record);
6565 }
6566 
6568  if (!RecordD) return;
6569  PopDeclContext();
6570 }
6571 
6572 /// This is used to implement the constant expression evaluation part of the
6573 /// attribute enable_if extension. There is nothing in standard C++ which would
6574 /// require reentering parameters.
6576  if (!Param)
6577  return;
6578 
6579  S->AddDecl(Param);
6580  if (Param->getDeclName())
6581  IdResolver.AddDecl(Param);
6582 }
6583 
6584 /// ActOnStartDelayedCXXMethodDeclaration - We have completed
6585 /// parsing a top-level (non-nested) C++ class, and we are now
6586 /// parsing those parts of the given Method declaration that could
6587 /// not be parsed earlier (C++ [class.mem]p2), such as default
6588 /// arguments. This action should enter the scope of the given
6589 /// Method declaration as if we had just parsed the qualified method
6590 /// name. However, it should not bring the parameters into scope;
6591 /// that will be performed by ActOnDelayedCXXMethodParameter.
6593 }
6594 
6595 /// ActOnDelayedCXXMethodParameter - We've already started a delayed
6596 /// C++ method declaration. We're (re-)introducing the given
6597 /// function parameter into scope for use in parsing later parts of
6598 /// the method declaration. For example, we could see an
6599 /// ActOnParamDefaultArgument event for this parameter.
6601  if (!ParamD)
6602  return;
6603 
6604  ParmVarDecl *Param = cast<ParmVarDecl>(ParamD);
6605 
6606  // If this parameter has an unparsed default argument, clear it out
6607  // to make way for the parsed default argument.
6608  if (Param->hasUnparsedDefaultArg())
6609  Param->setDefaultArg(nullptr);
6610 
6611  S->AddDecl(Param);
6612  if (Param->getDeclName())
6613  IdResolver.AddDecl(Param);
6614 }
6615 
6616 /// ActOnFinishDelayedCXXMethodDeclaration - We have finished
6617 /// processing the delayed method declaration for Method. The method
6618 /// declaration is now considered finished. There may be a separate
6619 /// ActOnStartOfFunctionDef action later (not necessarily
6620 /// immediately!) for this method, if it was also defined inside the
6621 /// class body.
6623  if (!MethodD)
6624  return;
6625 
6626  AdjustDeclIfTemplate(MethodD);
6627 
6628  FunctionDecl *Method = cast<FunctionDecl>(MethodD);
6629 
6630  // Now that we have our default arguments, check the constructor
6631  // again. It could produce additional diagnostics or affect whether
6632  // the class has implicitly-declared destructors, among other
6633  // things.
6634  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
6635  CheckConstructor(Constructor);
6636 
6637  // Check the default arguments, which we may have added.
6638  if (!Method->isInvalidDecl())
6639  CheckCXXDefaultArguments(Method);
6640 }
6641 
6642 /// CheckConstructorDeclarator - Called by ActOnDeclarator to check
6643 /// the well-formedness of the constructor declarator @p D with type @p
6644 /// R. If there are any errors in the declarator, this routine will
6645 /// emit diagnostics and set the invalid bit to true. In any case, the type
6646 /// will be updated to reflect a well-formed type for the constructor and
6647 /// returned.
6649  StorageClass &SC) {
6650  bool isVirtual = D.getDeclSpec().isVirtualSpecified();
6651 
6652  // C++ [class.ctor]p3:
6653  // A constructor shall not be virtual (10.3) or static (9.4). A
6654  // constructor can be invoked for a const, volatile or const
6655  // volatile object. A constructor shall not be declared const,
6656  // volatile, or const volatile (9.3.2).
6657  if (isVirtual) {
6658  if (!D.isInvalidType())
6659  Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
6660  << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
6661  << SourceRange(D.getIdentifierLoc());
6662  D.setInvalidType();
6663  }
6664  if (SC == SC_Static) {
6665  if (!D.isInvalidType())
6666  Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
6667  << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
6668  << SourceRange(D.getIdentifierLoc());
6669  D.setInvalidType();
6670  SC = SC_None;
6671  }
6672 
6673  if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
6675  diag::err_constructor_return_type, TypeQuals, SourceLocation(),
6679  D.setInvalidType();
6680  }
6681 
6683  if (FTI.TypeQuals != 0) {
6684  if (FTI.TypeQuals & Qualifiers::Const)
6685  Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
6686  << "const" << SourceRange(D.getIdentifierLoc());
6687  if (FTI.TypeQuals & Qualifiers::Volatile)
6688  Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
6689  << "volatile" << SourceRange(D.getIdentifierLoc());
6690  if (FTI.TypeQuals & Qualifiers::Restrict)
6691  Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
6692  << "restrict" << SourceRange(D.getIdentifierLoc());
6693  D.setInvalidType();
6694  }
6695 
6696  // C++0x [class.ctor]p4:
6697  // A constructor shall not be declared with a ref-qualifier.
6698  if (FTI.hasRefQualifier()) {
6699  Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_constructor)
6700  << FTI.RefQualifierIsLValueRef
6702  D.setInvalidType();
6703  }
6704 
6705  // Rebuild the function type "R" without any type qualifiers (in
6706  // case any of the errors above fired) and with "void" as the
6707  // return type, since constructors don't have return types.
6708  const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
6709  if (Proto->getReturnType() == Context.VoidTy && !D.isInvalidType())
6710  return R;
6711 
6713  EPI.TypeQuals = 0;
6714  EPI.RefQualifier = RQ_None;
6715 
6716  return Context.getFunctionType(Context.VoidTy, Proto->getParamTypes(), EPI);
6717 }
6718 
6719 /// CheckConstructor - Checks a fully-formed constructor for
6720 /// well-formedness, issuing any diagnostics required. Returns true if
6721 /// the constructor declarator is invalid.
6723  CXXRecordDecl *ClassDecl
6724  = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
6725  if (!ClassDecl)
6726  return Constructor->setInvalidDecl();
6727 
6728  // C++ [class.copy]p3:
6729  // A declaration of a constructor for a class X is ill-formed if
6730  // its first parameter is of type (optionally cv-qualified) X and
6731  // either there are no other parameters or else all other
6732  // parameters have default arguments.
6733  if (!Constructor->isInvalidDecl() &&
6734  ((Constructor->getNumParams() == 1) ||
6735  (Constructor->getNumParams() > 1 &&
6736  Constructor->getParamDecl(1)->hasDefaultArg())) &&
6737  Constructor->getTemplateSpecializationKind()
6739  QualType ParamType = Constructor->getParamDecl(0)->getType();
6740  QualType ClassTy = Context.getTagDeclType(ClassDecl);
6741  if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
6742  SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
6743  const char *ConstRef
6744  = Constructor->getParamDecl(0)->getIdentifier() ? "const &"
6745  : " const &";
6746  Diag(ParamLoc, diag::err_constructor_byvalue_arg)
6747  << FixItHint::CreateInsertion(ParamLoc, ConstRef);
6748 
6749  // FIXME: Rather that making the constructor invalid, we should endeavor
6750  // to fix the type.
6751  Constructor->setInvalidDecl();
6752  }
6753  }
6754 }
6755 
6756 /// CheckDestructor - Checks a fully-formed destructor definition for
6757 /// well-formedness, issuing any diagnostics required. Returns true
6758 /// on error.
6760  CXXRecordDecl *RD = Destructor->getParent();
6761 
6762  if (!Destructor->getOperatorDelete() && Destructor->isVirtual()) {
6763  SourceLocation Loc;
6764 
6765  if (!Destructor->isImplicit())
6766  Loc = Destructor->getLocation();
6767  else
6768  Loc = RD->getLocation();
6769 
6770  // If we have a virtual destructor, look up the deallocation function
6771  FunctionDecl *OperatorDelete = nullptr;
6772  DeclarationName Name =
6774  if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
6775  return true;
6776  // If there's no class-specific operator delete, look up the global
6777  // non-array delete.
6778  if (!OperatorDelete)
6779  OperatorDelete = FindUsualDeallocationFunction(Loc, true, Name);
6780 
6781  MarkFunctionReferenced(Loc, OperatorDelete);
6782 
6783  Destructor->setOperatorDelete(OperatorDelete);
6784  }
6785 
6786  return false;
6787 }
6788 
6789 /// CheckDestructorDeclarator - Called by ActOnDeclarator to check
6790 /// the well-formednes of the destructor declarator @p D with type @p
6791 /// R. If there are any errors in the declarator, this routine will
6792 /// emit diagnostics and set the declarator to invalid. Even if this happens,
6793 /// will be updated to reflect a well-formed type for the destructor and
6794 /// returned.
6796  StorageClass& SC) {
6797  // C++ [class.dtor]p1:
6798  // [...] A typedef-name that names a class is a class-name
6799  // (7.1.3); however, a typedef-name that names a class shall not
6800  // be used as the identifier in the declarator for a destructor
6801  // declaration.
6802  QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
6803  if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
6804  Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
6805  << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
6806  else if (const TemplateSpecializationType *TST =
6807  DeclaratorType->getAs<TemplateSpecializationType>())
6808  if (TST->isTypeAlias())
6809  Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
6810  << DeclaratorType << 1;
6811 
6812  // C++ [class.dtor]p2:
6813  // A destructor is used to destroy objects of its class type. A
6814  // destructor takes no parameters, and no return type can be
6815  // specified for it (not even void). The address of a destructor
6816  // shall not be taken. A destructor shall not be static. A
6817  // destructor can be invoked for a const, volatile or const
6818  // volatile object. A destructor shall not be declared const,
6819  // volatile or const volatile (9.3.2).
6820  if (SC == SC_Static) {
6821  if (!D.isInvalidType())
6822  Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
6823  << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
6826 
6827  SC = SC_None;
6828  }
6829  if (!D.isInvalidType()) {
6830  // Destructors don't have return types, but the parser will
6831  // happily parse something like:
6832  //
6833  // class X {
6834  // float ~X();
6835  // };
6836  //
6837  // The return type will be eliminated later.
6838  if (D.getDeclSpec().hasTypeSpecifier())
6839  Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
6841  << SourceRange(D.getIdentifierLoc());
6842  else if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
6843  diagnoseIgnoredQualifiers(diag::err_destructor_return_type, TypeQuals,
6844  SourceLocation(),
6849  D.setInvalidType();
6850  }
6851  }
6852 
6854  if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
6855  if (FTI.TypeQuals & Qualifiers::Const)
6856  Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
6857  << "const" << SourceRange(D.getIdentifierLoc());
6858  if (FTI.TypeQuals & Qualifiers::Volatile)
6859  Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
6860  << "volatile" << SourceRange(D.getIdentifierLoc());
6861  if (FTI.TypeQuals & Qualifiers::Restrict)
6862  Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
6863  << "restrict" << SourceRange(D.getIdentifierLoc());
6864  D.setInvalidType();
6865  }
6866 
6867  // C++0x [class.dtor]p2:
6868  // A destructor shall not be declared with a ref-qualifier.
6869  if (FTI.hasRefQualifier()) {
6870  Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_destructor)
6873  D.setInvalidType();
6874  }
6875 
6876  // Make sure we don't have any parameters.
6877  if (FTIHasNonVoidParameters(FTI)) {
6878  Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
6879 
6880  // Delete the parameters.
6881  FTI.freeParams();
6882  D.setInvalidType();
6883  }
6884 
6885  // Make sure the destructor isn't variadic.
6886  if (FTI.isVariadic) {
6887  Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
6888  D.setInvalidType();
6889  }
6890 
6891  // Rebuild the function type "R" without any type qualifiers or
6892  // parameters (in case any of the errors above fired) and with
6893  // "void" as the return type, since destructors don't have return
6894  // types.
6895  if (!D.isInvalidType())
6896  return R;
6897 
6898  const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
6900  EPI.Variadic = false;
6901  EPI.TypeQuals = 0;
6902  EPI.RefQualifier = RQ_None;
6903  return Context.getFunctionType(Context.VoidTy, None, EPI);
6904 }
6905 
6906 static void extendLeft(SourceRange &R, SourceRange Before) {
6907  if (Before.isInvalid())
6908  return;
6909  R.setBegin(Before.getBegin());
6910  if (R.getEnd().isInvalid())
6911  R.setEnd(Before.getEnd());
6912 }
6913 
6915  if (After.isInvalid())
6916  return;
6917  if (R.getBegin().isInvalid())
6918  R.setBegin(After.getBegin());
6919  R.setEnd(After.getEnd());
6920 }
6921 
6922 /// CheckConversionDeclarator - Called by ActOnDeclarator to check the
6923 /// well-formednes of the conversion function declarator @p D with
6924 /// type @p R. If there are any errors in the declarator, this routine
6925 /// will emit diagnostics and return true. Otherwise, it will return
6926 /// false. Either way, the type @p R will be updated to reflect a
6927 /// well-formed type for the conversion operator.
6929  StorageClass& SC) {
6930  // C++ [class.conv.fct]p1:
6931  // Neither parameter types nor return type can be specified. The
6932  // type of a conversion function (8.3.5) is "function taking no
6933  // parameter returning conversion-type-id."
6934  if (SC == SC_Static) {
6935  if (!D.isInvalidType())
6936  Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
6938  << D.getName().getSourceRange();
6939  D.setInvalidType();
6940  SC = SC_None;
6941  }
6942 
6943  TypeSourceInfo *ConvTSI = nullptr;
6944  QualType ConvType =
6946 
6947  if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
6948  // Conversion functions don't have return types, but the parser will
6949  // happily parse something like:
6950  //
6951  // class X {
6952  // float operator bool();
6953  // };
6954  //
6955  // The return type will be changed later anyway.
6956  Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
6958  << SourceRange(D.getIdentifierLoc());
6959  D.setInvalidType();
6960  }
6961 
6962  const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
6963 
6964  // Make sure we don't have any parameters.
6965  if (Proto->getNumParams() > 0) {
6966  Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
6967 
6968  // Delete the parameters.
6970  D.setInvalidType();
6971  } else if (Proto->isVariadic()) {
6972  Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
6973  D.setInvalidType();
6974  }
6975 
6976  // Diagnose "&operator bool()" and other such nonsense. This
6977  // is actually a gcc extension which we don't support.
6978  if (Proto->getReturnType() != ConvType) {
6979  bool NeedsTypedef = false;
6980  SourceRange Before, After;
6981 
6982  // Walk the chunks and extract information on them for our diagnostic.
6983  bool PastFunctionChunk = false;
6984  for (auto &Chunk : D.type_objects()) {
6985  switch (Chunk.Kind) {
6987  if (!PastFunctionChunk) {
6988  if (Chunk.Fun.HasTrailingReturnType) {
6989  TypeSourceInfo *TRT = nullptr;
6990  GetTypeFromParser(Chunk.Fun.getTrailingReturnType(), &TRT);
6991  if (TRT) extendRight(After, TRT->getTypeLoc().getSourceRange());
6992  }
6993  PastFunctionChunk = true;
6994  break;
6995  }
6996  // Fall through.
6998  NeedsTypedef = true;
6999  extendRight(After, Chunk.getSourceRange());
7000  break;
7001 
7006  case DeclaratorChunk::Pipe:
7007  extendLeft(Before, Chunk.getSourceRange());
7008  break;
7009 
7011  extendLeft(Before, Chunk.Loc);
7012  extendRight(After, Chunk.EndLoc);
7013  break;
7014  }
7015  }
7016 
7017  SourceLocation Loc = Before.isValid() ? Before.getBegin() :
7018  After.isValid() ? After.getBegin() :
7019  D.getIdentifierLoc();
7020  auto &&DB = Diag(Loc, diag::err_conv_function_with_complex_decl);
7021  DB << Before << After;
7022 
7023  if (!NeedsTypedef) {
7024  DB << /*don't need a typedef*/0;
7025 
7026  // If we can provide a correct fix-it hint, do so.
7027  if (After.isInvalid() && ConvTSI) {
7028  SourceLocation InsertLoc =
7030  DB << FixItHint::CreateInsertion(InsertLoc, " ")
7032  InsertLoc, CharSourceRange::getTokenRange(Before))
7033  << FixItHint::CreateRemoval(Before);
7034  }
7035  } else if (!Proto->getReturnType()->isDependentType()) {
7036  DB << /*typedef*/1 << Proto->getReturnType();
7037  } else if (getLangOpts().CPlusPlus11) {
7038  DB << /*alias template*/2 << Proto->getReturnType();
7039  } else {
7040  DB << /*might not be fixable*/3;
7041  }
7042 
7043  // Recover by incorporating the other type chunks into the result type.
7044  // Note, this does *not* change the name of the function. This is compatible
7045  // with the GCC extension:
7046  // struct S { &operator int(); } s;
7047  // int &r = s.operator int(); // ok in GCC
7048  // S::operator int&() {} // error in GCC, function name is 'operator int'.
7049  ConvType = Proto->getReturnType();
7050  }
7051 
7052  // C++ [class.conv.fct]p4:
7053  // The conversion-type-id shall not represent a function type nor
7054  // an array type.
7055  if (ConvType->isArrayType()) {
7056  Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
7057  ConvType = Context.getPointerType(ConvType);
7058  D.setInvalidType();
7059  } else if (ConvType->isFunctionType()) {
7060  Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
7061  ConvType = Context.getPointerType(ConvType);
7062  D.setInvalidType();
7063  }
7064 
7065  // Rebuild the function type "R" without any parameters (in case any
7066  // of the errors above fired) and with the conversion type as the
7067  // return type.
7068  if (D.isInvalidType())
7069  R = Context.getFunctionType(ConvType, None, Proto->getExtProtoInfo());
7070 
7071  // C++0x explicit conversion operators.
7072  if (D.getDeclSpec().isExplicitSpecified())
7074  getLangOpts().CPlusPlus11 ?
7075  diag::warn_cxx98_compat_explicit_conversion_functions :
7076  diag::ext_explicit_conversion_functions)
7078 }
7079 
7080 /// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
7081 /// the declaration of the given C++ conversion function. This routine
7082 /// is responsible for recording the conversion function in the C++
7083 /// class, if possible.
7085  assert(Conversion && "Expected to receive a conversion function declaration");
7086 
7087  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
7088 
7089  // Make sure we aren't redeclaring the conversion function.
7090  QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
7091 
7092  // C++ [class.conv.fct]p1:
7093  // [...] A conversion function is never used to convert a
7094  // (possibly cv-qualified) object to the (possibly cv-qualified)
7095  // same object type (or a reference to it), to a (possibly
7096  // cv-qualified) base class of that type (or a reference to it),
7097  // or to (possibly cv-qualified) void.
7098  // FIXME: Suppress this warning if the conversion function ends up being a
7099  // virtual function that overrides a virtual function in a base class.
7100  QualType ClassType
7102  if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
7103  ConvType = ConvTypeRef->getPointeeType();
7104  if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared &&
7106  /* Suppress diagnostics for instantiations. */;
7107  else if (ConvType->isRecordType()) {
7108  ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
7109  if (ConvType == ClassType)
7110  Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
7111  << ClassType;
7112  else if (IsDerivedFrom(Conversion->getLocation(), ClassType, ConvType))
7113  Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
7114  << ClassType << ConvType;
7115  } else if (ConvType->isVoidType()) {
7116  Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
7117  << ClassType << ConvType;
7118  }
7119 
7120  if (FunctionTemplateDecl *ConversionTemplate
7121  = Conversion->getDescribedFunctionTemplate())
7122  return ConversionTemplate;
7123 
7124  return Conversion;
7125 }
7126 
7127 //===----------------------------------------------------------------------===//
7128 // Namespace Handling
7129 //===----------------------------------------------------------------------===//
7130 
7131 /// \brief Diagnose a mismatch in 'inline' qualifiers when a namespace is
7132 /// reopened.
7134  SourceLocation Loc,
7135  IdentifierInfo *II, bool *IsInline,
7136  NamespaceDecl *PrevNS) {
7137  assert(*IsInline != PrevNS->isInline());
7138 
7139  // HACK: Work around a bug in libstdc++4.6's <atomic>, where
7140  // std::__atomic[0,1,2] are defined as non-inline namespaces, then reopened as
7141  // inline namespaces, with the intention of bringing names into namespace std.
7142  //
7143  // We support this just well enough to get that case working; this is not
7144  // sufficient to support reopening namespaces as inline in general.
7145  if (*IsInline && II && II->getName().startswith("__atomic") &&
7147  // Mark all prior declarations of the namespace as inline.
7148  for (NamespaceDecl *NS = PrevNS->getMostRecentDecl(); NS;
7149  NS = NS->getPreviousDecl())
7150  NS->setInline(*IsInline);
7151  // Patch up the lookup table for the containing namespace. This isn't really
7152  // correct, but it's good enough for this particular case.
7153  for (auto *I : PrevNS->decls())
7154  if (auto *ND = dyn_cast<NamedDecl>(I))
7155  PrevNS->getParent()->makeDeclVisibleInContext(ND);
7156  return;
7157  }
7158 
7159  if (PrevNS->isInline())
7160  // The user probably just forgot the 'inline', so suggest that it
7161  // be added back.
7162  S.Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
7163  << FixItHint::CreateInsertion(KeywordLoc, "inline ");
7164  else
7165  S.Diag(Loc, diag::err_inline_namespace_mismatch) << *IsInline;
7166 
7167  S.Diag(PrevNS->getLocation(), diag::note_previous_definition);
7168  *IsInline = PrevNS->isInline();
7169 }
7170 
7171 /// ActOnStartNamespaceDef - This is called at the start of a namespace
7172 /// definition.
7174  SourceLocation InlineLoc,
7175  SourceLocation NamespaceLoc,
7176  SourceLocation IdentLoc,
7177  IdentifierInfo *II,
7178  SourceLocation LBrace,
7179  AttributeList *AttrList,
7180  UsingDirectiveDecl *&UD) {
7181  SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc;
7182  // For anonymous namespace, take the location of the left brace.
7183  SourceLocation Loc = II ? IdentLoc : LBrace;
7184  bool IsInline = InlineLoc.isValid();
7185  bool IsInvalid = false;
7186  bool IsStd = false;
7187  bool AddToKnown = false;
7188  Scope *DeclRegionScope = NamespcScope->getParent();
7189 
7190  NamespaceDecl *PrevNS = nullptr;
7191  if (II) {
7192  // C++ [namespace.def]p2:
7193  // The identifier in an original-namespace-definition shall not
7194  // have been previously defined in the declarative region in
7195  // which the original-namespace-definition appears. The
7196  // identifier in an original-namespace-definition is the name of
7197  // the namespace. Subsequently in that declarative region, it is
7198  // treated as an original-namespace-name.
7199  //
7200  // Since namespace names are unique in their scope, and we don't
7201  // look through using directives, just look for any ordinary names
7202  // as if by qualified name lookup.
7203  LookupResult R(*this, II, IdentLoc, LookupOrdinaryName, ForRedeclaration);
7205  NamedDecl *PrevDecl =
7206  R.isSingleResult() ? R.getRepresentativeDecl() : nullptr;
7207  PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
7208 
7209  if (PrevNS) {
7210  // This is an extended namespace definition.
7211  if (IsInline != PrevNS->isInline())
7212  DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, Loc, II,
7213  &IsInline, PrevNS);
7214  } else if (PrevDecl) {
7215  // This is an invalid name redefinition.
7216  Diag(Loc, diag::err_redefinition_different_kind)
7217  << II;
7218  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
7219  IsInvalid = true;
7220  // Continue on to push Namespc as current DeclContext and return it.
7221  } else if (II->isStr("std") &&
7223  // This is the first "real" definition of the namespace "std", so update
7224  // our cache of the "std" namespace to point at this definition.
7225  PrevNS = getStdNamespace();
7226  IsStd = true;
7227  AddToKnown = !IsInline;
7228  } else {
7229  // We've seen this namespace for the first time.
7230  AddToKnown = !IsInline;
7231  }
7232  } else {
7233  // Anonymous namespaces.
7234 
7235  // Determine whether the parent already has an anonymous namespace.
7237  if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
7238  PrevNS = TU->getAnonymousNamespace();
7239  } else {
7240  NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
7241  PrevNS = ND->getAnonymousNamespace();
7242  }
7243 
7244  if (PrevNS && IsInline != PrevNS->isInline())
7245  DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, NamespaceLoc, II,
7246  &IsInline, PrevNS);
7247  }
7248 
7249  NamespaceDecl *Namespc = NamespaceDecl::Create(Context, CurContext, IsInline,
7250  StartLoc, Loc, II, PrevNS);
7251  if (IsInvalid)
7252  Namespc->setInvalidDecl();
7253 
7254  ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
7255 
7256  // FIXME: Should we be merging attributes?
7257  if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
7259 
7260  if (IsStd)
7261  StdNamespace = Namespc;
7262  if (AddToKnown)
7263  KnownNamespaces[Namespc] = false;
7264 
7265  if (II) {
7266  PushOnScopeChains(Namespc, DeclRegionScope);
7267  } else {
7268  // Link the anonymous namespace into its parent.
7270  if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
7271  TU->setAnonymousNamespace(Namespc);
7272  } else {
7273  cast<NamespaceDecl>(Parent)->setAnonymousNamespace(Namespc);
7274  }
7275 
7276  CurContext->addDecl(Namespc);
7277 
7278  // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
7279  // behaves as if it were replaced by
7280  // namespace unique { /* empty body */ }
7281  // using namespace unique;
7282  // namespace unique { namespace-body }
7283  // where all occurrences of 'unique' in a translation unit are
7284  // replaced by the same identifier and this identifier differs
7285  // from all other identifiers in the entire program.
7286 
7287  // We just create the namespace with an empty name and then add an
7288  // implicit using declaration, just like the standard suggests.
7289  //
7290  // CodeGen enforces the "universally unique" aspect by giving all
7291  // declarations semantically contained within an anonymous
7292  // namespace internal linkage.
7293 
7294  if (!PrevNS) {
7295  UD = UsingDirectiveDecl::Create(Context, Parent,
7296  /* 'using' */ LBrace,
7297  /* 'namespace' */ SourceLocation(),
7298  /* qualifier */ NestedNameSpecifierLoc(),
7299  /* identifier */ SourceLocation(),
7300  Namespc,
7301  /* Ancestor */ Parent);
7302  UD->setImplicit();
7303  Parent->addDecl(UD);
7304  }
7305  }
7306 
7307  ActOnDocumentableDecl(Namespc);
7308 
7309  // Although we could have an invalid decl (i.e. the namespace name is a
7310  // redefinition), push it as current DeclContext and try to continue parsing.
7311  // FIXME: We should be able to push Namespc here, so that the each DeclContext
7312  // for the namespace has the declarations that showed up in that particular
7313  // namespace definition.
7314  PushDeclContext(NamespcScope, Namespc);
7315  return Namespc;
7316 }
7317 
7318 /// getNamespaceDecl - Returns the namespace a decl represents. If the decl
7319 /// is a namespace alias, returns the namespace it points to.
7321  if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
7322  return AD->getNamespace();
7323  return dyn_cast_or_null<NamespaceDecl>(D);
7324 }
7325 
7326 /// ActOnFinishNamespaceDef - This callback is called after a namespace is
7327 /// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
7329  NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
7330  assert(Namespc && "Invalid parameter, expected NamespaceDecl");
7331  Namespc->setRBraceLoc(RBrace);
7332  PopDeclContext();
7333  if (Namespc->hasAttr<VisibilityAttr>())
7334  PopPragmaVisibility(true, RBrace);
7335 }
7336 
7338  return cast_or_null<CXXRecordDecl>(
7340 }
7341 
7343  return cast_or_null<NamespaceDecl>(
7345 }
7346 
7347 /// \brief Retrieve the special "std" namespace, which may require us to
7348 /// implicitly define the namespace.
7350  if (!StdNamespace) {
7351  // The "std" namespace has not yet been defined, so build one implicitly.
7354  /*Inline=*/false,
7356  &PP.getIdentifierTable().get("std"),
7357  /*PrevDecl=*/nullptr);
7358  getStdNamespace()->setImplicit(true);
7359  }
7360 
7361  return getStdNamespace();
7362 }
7363 
7365  assert(getLangOpts().CPlusPlus &&
7366  "Looking for std::initializer_list outside of C++.");
7367 
7368  // We're looking for implicit instantiations of
7369  // template <typename E> class std::initializer_list.
7370 
7371  if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it.
7372  return false;
7373 
7374  ClassTemplateDecl *Template = nullptr;
7375  const TemplateArgument *Arguments = nullptr;
7376 
7377  if (const RecordType *RT = Ty->getAs<RecordType>()) {
7378 
7379  ClassTemplateSpecializationDecl *Specialization =
7380  dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
7381  if (!Specialization)
7382  return false;
7383 
7384  Template = Specialization->getSpecializedTemplate();
7385  Arguments = Specialization->getTemplateArgs().data();
7386  } else if (const TemplateSpecializationType *TST =
7388  Template = dyn_cast_or_null<ClassTemplateDecl>(
7389  TST->getTemplateName().getAsTemplateDecl());
7390  Arguments = TST->getArgs();
7391  }
7392  if (!Template)
7393  return false;
7394 
7395  if (!StdInitializerList) {
7396  // Haven't recognized std::initializer_list yet, maybe this is it.
7397  CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
7398  if (TemplateClass->getIdentifier() !=
7399  &PP.getIdentifierTable().get("initializer_list") ||
7401  TemplateClass->getDeclContext()))
7402  return false;
7403  // This is a template called std::initializer_list, but is it the right
7404  // template?
7405  TemplateParameterList *Params = Template->getTemplateParameters();
7406  if (Params->getMinRequiredArguments() != 1)
7407  return false;
7408  if (!isa<TemplateTypeParmDecl>(Params->getParam(0)))
7409  return false;
7410 
7411  // It's the right template.
7412  StdInitializerList = Template;
7413  }
7414 
7416  return false;
7417 
7418  // This is an instance of std::initializer_list. Find the argument type.
7419  if (Element)
7420  *Element = Arguments[0].getAsType();
7421  return true;
7422 }
7423 
7425  NamespaceDecl *Std = S.getStdNamespace();
7426  if (!Std) {
7427  S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
7428  return nullptr;
7429  }
7430 
7431  LookupResult Result(S, &S.PP.getIdentifierTable().get("initializer_list"),
7433  if (!S.LookupQualifiedName(Result, Std)) {
7434  S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
7435  return nullptr;
7436  }
7437  ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>();
7438  if (!Template) {
7439  Result.suppressDiagnostics();
7440  // We found something weird. Complain about the first thing we found.
7441  NamedDecl *Found = *Result.begin();
7442  S.Diag(Found->getLocation(), diag::err_malformed_std_initializer_list);
7443  return nullptr;
7444  }
7445 
7446  // We found some template called std::initializer_list. Now verify that it's
7447  // correct.
7448  TemplateParameterList *Params = Template->getTemplateParameters();
7449  if (Params->getMinRequiredArguments() != 1 ||
7450  !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
7451  S.Diag(Template->getLocation(), diag::err_malformed_std_initializer_list);
7452  return nullptr;
7453  }
7454 
7455  return Template;
7456 }
7457 
7459  if (!StdInitializerList) {
7461  if (!StdInitializerList)
7462  return QualType();
7463  }
7464 
7465  TemplateArgumentListInfo Args(Loc, Loc);
7468  Loc)));
7469  return Context.getCanonicalType(
7471 }
7472 
7474  // C++ [dcl.init.list]p2:
7475  // A constructor is an initializer-list constructor if its first parameter
7476  // is of type std::initializer_list<E> or reference to possibly cv-qualified
7477  // std::initializer_list<E> for some type E, and either there are no other
7478  // parameters or else all other parameters have default arguments.
7479  if (Ctor->getNumParams() < 1 ||
7480  (Ctor->getNumParams() > 1 && !Ctor->getParamDecl(1)->hasDefaultArg()))
7481  return false;
7482 
7483  QualType ArgType = Ctor->getParamDecl(0)->getType();
7484  if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
7485  ArgType = RT->getPointeeType().getUnqualifiedType();
7486 
7487  return isStdInitializerList(ArgType, nullptr);
7488 }
7489 
7490 /// \brief Determine whether a using statement is in a context where it will be
7491 /// apply in all contexts.
7493  switch (CurContext->getDeclKind()) {
7494  case Decl::TranslationUnit:
7495  return true;
7496  case Decl::LinkageSpec:
7497  return IsUsingDirectiveInToplevelContext(CurContext->getParent());
7498  default:
7499  return false;
7500  }
7501 }
7502 
7503 namespace {
7504 
7505 // Callback to only accept typo corrections that are namespaces.
7506 class NamespaceValidatorCCC : public CorrectionCandidateCallback {
7507 public:
7508  bool ValidateCandidate(const TypoCorrection &candidate) override {
7509  if (NamedDecl *ND = candidate.getCorrectionDecl())
7510  return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
7511  return false;
7512  }
7513 };
7514 
7515 }
7516 
7518  CXXScopeSpec &SS,
7519  SourceLocation IdentLoc,
7520  IdentifierInfo *Ident) {
7521  R.clear();
7522  if (TypoCorrection Corrected =
7523  S.CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), Sc, &SS,
7524  llvm::make_unique<NamespaceValidatorCCC>(),
7526  if (DeclContext *DC = S.computeDeclContext(SS, false)) {
7527  std::string CorrectedStr(Corrected.getAsString(S.getLangOpts()));
7528  bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
7529  Ident->getName().equals(CorrectedStr);
7530  S.diagnoseTypo(Corrected,
7531  S.PDiag(diag::err_using_directive_member_suggest)
7532  << Ident << DC << DroppedSpecifier << SS.getRange(),
7533  S.PDiag(diag::note_namespace_defined_here));
7534  } else {
7535  S.diagnoseTypo(Corrected,
7536  S.PDiag(diag::err_using_directive_suggest) << Ident,
7537  S.PDiag(diag::note_namespace_defined_here));
7538  }
7539  R.addDecl(Corrected.getFoundDecl());
7540  return true;
7541  }
7542  return false;
7543 }
7544 
7546  SourceLocation UsingLoc,
7547  SourceLocation NamespcLoc,
7548  CXXScopeSpec &SS,
7549  SourceLocation IdentLoc,
7550  IdentifierInfo *NamespcName,
7551  AttributeList *AttrList) {
7552  assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
7553  assert(NamespcName && "Invalid NamespcName.");
7554  assert(IdentLoc.isValid() && "Invalid NamespceName location.");
7555 
7556  // This can only happen along a recovery path.
7557  while (S->isTemplateParamScope())
7558  S = S->getParent();
7559  assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
7560 
7561  UsingDirectiveDecl *UDir = nullptr;
7562  NestedNameSpecifier *Qualifier = nullptr;
7563  if (SS.isSet())
7564  Qualifier = SS.getScopeRep();
7565 
7566  // Lookup namespace name.
7567  LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
7568  LookupParsedName(R, S, &SS);
7569  if (R.isAmbiguous())
7570  return nullptr;
7571 
7572  if (R.empty()) {
7573  R.clear();
7574  // Allow "using namespace std;" or "using namespace ::std;" even if
7575  // "std" hasn't been defined yet, for GCC compatibility.
7576  if ((!Qualifier || Qualifier->getKind() == NestedNameSpecifier::Global) &&
7577  NamespcName->isStr("std")) {
7578  Diag(IdentLoc, diag::ext_using_undefined_std);
7580  R.resolveKind();
7581  }
7582  // Otherwise, attempt typo correction.
7583  else TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, NamespcName);
7584  }
7585 
7586  if (!R.empty()) {
7587  NamedDecl *Named = R.getRepresentativeDecl();
7589  assert(NS && "expected namespace decl");
7590 
7591  // The use of a nested name specifier may trigger deprecation warnings.
7592  DiagnoseUseOfDecl(Named, IdentLoc);
7593 
7594  // C++ [namespace.udir]p1:
7595  // A using-directive specifies that the names in the nominated
7596  // namespace can be used in the scope in which the
7597  // using-directive appears after the using-directive. During
7598  // unqualified name lookup (3.4.1), the names appear as if they
7599  // were declared in the nearest enclosing namespace which
7600  // contains both the using-directive and the nominated
7601  // namespace. [Note: in this context, "contains" means "contains
7602  // directly or indirectly". ]
7603 
7604  // Find enclosing context containing both using-directive and
7605  // nominated namespace.
7606  DeclContext *CommonAncestor = cast<DeclContext>(NS);
7607  while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
7608  CommonAncestor = CommonAncestor->getParent();
7609 
7610  UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
7612  IdentLoc, Named, CommonAncestor);
7613 
7616  Diag(IdentLoc, diag::warn_using_directive_in_header);
7617  }
7618 
7619  PushUsingDirective(S, UDir);
7620  } else {
7621  Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
7622  }
7623 
7624  if (UDir)
7625  ProcessDeclAttributeList(S, UDir, AttrList);
7626 
7627  return UDir;
7628 }
7629 
7631  // If the scope has an associated entity and the using directive is at
7632  // namespace or translation unit scope, add the UsingDirectiveDecl into
7633  // its lookup structure so qualified name lookup can find it.
7634  DeclContext *Ctx = S->getEntity();
7635  if (Ctx && !Ctx->isFunctionOrMethod())
7636  Ctx->addDecl(UDir);
7637  else
7638  // Otherwise, it is at block scope. The using-directives will affect lookup
7639  // only to the end of the scope.
7640  S->PushUsingDirective(UDir);
7641 }
7642 
7643 
7645  AccessSpecifier AS,
7646  bool HasUsingKeyword,
7647  SourceLocation UsingLoc,
7648  CXXScopeSpec &SS,
7649  UnqualifiedId &Name,
7650  AttributeList *AttrList,
7651  bool HasTypenameKeyword,
7652  SourceLocation TypenameLoc) {
7653  assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
7654 
7655  switch (Name.getKind()) {
7661  break;
7662 
7665  // C++11 inheriting constructors.
7666  Diag(Name.getLocStart(),
7667  getLangOpts().CPlusPlus11 ?
7668  diag::warn_cxx98_compat_using_decl_constructor :
7669  diag::err_using_decl_constructor)
7670  << SS.getRange();
7671 
7672  if (getLangOpts().CPlusPlus11) break;
7673 
7674  return nullptr;
7675 
7677  Diag(Name.getLocStart(), diag::err_using_decl_destructor)
7678  << SS.getRange();
7679  return nullptr;
7680 
7682  Diag(Name.getLocStart(), diag::err_using_decl_template_id)
7684  return nullptr;
7685  }
7686 
7687  DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
7688  DeclarationName TargetName = TargetNameInfo.getName();
7689  if (!TargetName)
7690  return nullptr;
7691 
7692  // Warn about access declarations.
7693  if (!HasUsingKeyword) {
7694  Diag(Name.getLocStart(),
7695  getLangOpts().CPlusPlus11 ? diag::err_access_decl
7696  : diag::warn_access_decl_deprecated)
7697  << FixItHint::CreateInsertion(SS.getRange().getBegin(), "using ");
7698  }
7699 
7702  return nullptr;
7703 
7704  NamedDecl *UD = BuildUsingDeclaration(S, AS, UsingLoc, SS,
7705  TargetNameInfo, AttrList,
7706  /* IsInstantiation */ false,
7707  HasTypenameKeyword, TypenameLoc);
7708  if (UD)
7709  PushOnScopeChains(UD, S, /*AddToContext*/ false);
7710 
7711  return UD;
7712 }
7713 
7714 /// \brief Determine whether a using declaration considers the given
7715 /// declarations as "equivalent", e.g., if they are redeclarations of
7716 /// the same entity or are both typedefs of the same type.
7717 static bool
7719  if (D1->getCanonicalDecl() == D2->getCanonicalDecl())
7720  return true;
7721 
7722  if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(D1))
7723  if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2))
7724  return Context.hasSameType(TD1->getUnderlyingType(),
7725  TD2->getUnderlyingType());
7726 
7727  return false;
7728 }
7729 
7730 
7731 /// Determines whether to create a using shadow decl for a particular
7732 /// decl, given the set of decls existing prior to this using lookup.
7734  const LookupResult &Previous,
7735  UsingShadowDecl *&PrevShadow) {
7736  // Diagnose finding a decl which is not from a base class of the
7737  // current class. We do this now because there are cases where this
7738  // function will silently decide not to build a shadow decl, which
7739  // will pre-empt further diagnostics.
7740  //
7741  // We don't need to do this in C++0x because we do the check once on
7742  // the qualifier.
7743  //
7744  // FIXME: diagnose the following if we care enough:
7745  // struct A { int foo; };
7746  // struct B : A { using A::foo; };
7747  // template <class T> struct C : A {};
7748  // template <class T> struct D : C<T> { using B::foo; } // <---
7749  // This is invalid (during instantiation) in C++03 because B::foo
7750  // resolves to the using decl in B, which is not a base class of D<T>.
7751  // We can't diagnose it immediately because C<T> is an unknown
7752  // specialization. The UsingShadowDecl in D<T> then points directly
7753  // to A::foo, which will look well-formed when we instantiate.
7754  // The right solution is to not collapse the shadow-decl chain.
7755  if (!getLangOpts().CPlusPlus11 && CurContext->isRecord()) {
7756  DeclContext *OrigDC = Orig->getDeclContext();
7757 
7758  // Handle enums and anonymous structs.
7759  if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
7760  CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
7761  while (OrigRec->isAnonymousStructOrUnion())
7762  OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
7763 
7764  if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
7765  if (OrigDC == CurContext) {
7766  Diag(Using->getLocation(),
7767  diag::err_using_decl_nested_name_specifier_is_current_class)
7768  << Using->getQualifierLoc().getSourceRange();
7769  Diag(Orig->getLocation(), diag::note_using_decl_target);
7770  return true;
7771  }
7772 
7773  Diag(Using->getQualifierLoc().getBeginLoc(),
7774  diag::err_using_decl_nested_name_specifier_is_not_base_class)
7775  << Using->getQualifier()
7776  << cast<CXXRecordDecl>(CurContext)
7777  << Using->getQualifierLoc().getSourceRange();
7778  Diag(Orig->getLocation(), diag::note_using_decl_target);
7779  return true;
7780  }
7781  }
7782 
7783  if (Previous.empty()) return false;
7784 
7785  NamedDecl *Target = Orig;
7786  if (isa<UsingShadowDecl>(Target))
7787  Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
7788 
7789  // If the target happens to be one of the previous declarations, we
7790  // don't have a conflict.
7791  //
7792  // FIXME: but we might be increasing its access, in which case we
7793  // should redeclare it.
7794  NamedDecl *NonTag = nullptr, *Tag = nullptr;
7795  bool FoundEquivalentDecl = false;
7796  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
7797  I != E; ++I) {
7798  NamedDecl *D = (*I)->getUnderlyingDecl();
7799  if (IsEquivalentForUsingDecl(Context, D, Target)) {
7800  if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(*I))
7801  PrevShadow = Shadow;
7802  FoundEquivalentDecl = true;
7803  } else if (isEquivalentInternalLinkageDeclaration(D, Target)) {
7804  // We don't conflict with an existing using shadow decl of an equivalent
7805  // declaration, but we're not a redeclaration of it.
7806  FoundEquivalentDecl = true;
7807  }
7808 
7809  if (isVisible(D))
7810  (isa<TagDecl>(D) ? Tag : NonTag) = D;
7811  }
7812 
7813  if (FoundEquivalentDecl)
7814  return false;
7815 
7816  if (FunctionDecl *FD = Target->getAsFunction()) {
7817  NamedDecl *OldDecl = nullptr;
7818  switch (CheckOverload(nullptr, FD, Previous, OldDecl,
7819  /*IsForUsingDecl*/ true)) {
7820  case Ovl_Overload:
7821  return false;
7822 
7823  case Ovl_NonFunction:
7824  Diag(Using->getLocation(), diag::err_using_decl_conflict);
7825  break;
7826 
7827  // We found a decl with the exact signature.
7828  case Ovl_Match:
7829  // If we're in a record, we want to hide the target, so we
7830  // return true (without a diagnostic) to tell the caller not to
7831  // build a shadow decl.
7832  if (CurContext->isRecord())
7833  return true;
7834 
7835  // If we're not in a record, this is an error.
7836  Diag(Using->getLocation(), diag::err_using_decl_conflict);
7837  break;
7838  }
7839 
7840  Diag(Target->getLocation(), diag::note_using_decl_target);
7841  Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
7842  return true;
7843  }
7844 
7845  // Target is not a function.
7846 
7847  if (isa<TagDecl>(Target)) {
7848  // No conflict between a tag and a non-tag.
7849  if (!Tag) return false;
7850 
7851  Diag(Using->getLocation(), diag::err_using_decl_conflict);
7852  Diag(Target->getLocation(), diag::note_using_decl_target);
7853  Diag(Tag->getLocation(), diag::note_using_decl_conflict);
7854  return true;
7855  }
7856 
7857  // No conflict between a tag and a non-tag.
7858  if (!NonTag) return false;
7859 
7860  Diag(Using->getLocation(), diag::err_using_decl_conflict);
7861  Diag(Target->getLocation(), diag::note_using_decl_target);
7862  Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
7863  return true;
7864 }
7865 
7866 /// Builds a shadow declaration corresponding to a 'using' declaration.
7868  UsingDecl *UD,
7869  NamedDecl *Orig,
7870  UsingShadowDecl *PrevDecl) {
7871 
7872  // If we resolved to another shadow declaration, just coalesce them.
7873  NamedDecl *Target = Orig;
7874  if (isa<UsingShadowDecl>(Target)) {
7875  Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
7876  assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
7877  }
7878 
7879  UsingShadowDecl *Shadow
7881  UD->getLocation(), UD, Target);
7882  UD->addShadowDecl(Shadow);
7883 
7884  Shadow->setAccess(UD->getAccess());
7885  if (Orig->isInvalidDecl() || UD->isInvalidDecl())
7886  Shadow->setInvalidDecl();
7887 
7888  Shadow->setPreviousDecl(PrevDecl);
7889 
7890  if (S)
7891  PushOnScopeChains(Shadow, S);
7892  else
7893  CurContext->addDecl(Shadow);
7894 
7895 
7896  return Shadow;
7897 }
7898 
7899 /// Hides a using shadow declaration. This is required by the current
7900 /// using-decl implementation when a resolvable using declaration in a
7901 /// class is followed by a declaration which would hide or override
7902 /// one or more of the using decl's targets; for example:
7903 ///
7904 /// struct Base { void foo(int); };
7905 /// struct Derived : Base {
7906 /// using Base::foo;
7907 /// void foo(int);
7908 /// };
7909 ///
7910 /// The governing language is C++03 [namespace.udecl]p12:
7911 ///
7912 /// When a using-declaration brings names from a base class into a
7913 /// derived class scope, member functions in the derived class
7914 /// override and/or hide member functions with the same name and
7915 /// parameter types in a base class (rather than conflicting).
7916 ///
7917 /// There are two ways to implement this:
7918 /// (1) optimistically create shadow decls when they're not hidden
7919 /// by existing declarations, or
7920 /// (2) don't create any shadow decls (or at least don't make them
7921 /// visible) until we've fully parsed/instantiated the class.
7922 /// The problem with (1) is that we might have to retroactively remove
7923 /// a shadow decl, which requires several O(n) operations because the
7924 /// decl structures are (very reasonably) not designed for removal.
7925 /// (2) avoids this but is very fiddly and phase-dependent.
7927  if (Shadow->getDeclName().getNameKind() ==
7929  cast<CXXRecordDecl>(Shadow->getDeclContext())->removeConversion(Shadow);
7930 
7931  // Remove it from the DeclContext...
7932  Shadow->getDeclContext()->removeDecl(Shadow);
7933 
7934  // ...and the scope, if applicable...
7935  if (S) {
7936  S->RemoveDecl(Shadow);
7937  IdResolver.RemoveDecl(Shadow);
7938  }
7939 
7940  // ...and the using decl.
7941  Shadow->getUsingDecl()->removeShadowDecl(Shadow);
7942 
7943  // TODO: complain somehow if Shadow was used. It shouldn't
7944  // be possible for this to happen, because...?
7945 }
7946 
7947 /// Find the base specifier for a base class with the given type.
7949  QualType DesiredBase,
7950  bool &AnyDependentBases) {
7951  // Check whether the named type is a direct base class.
7952  CanQualType CanonicalDesiredBase = DesiredBase->getCanonicalTypeUnqualified();
7953  for (auto &Base : Derived->bases()) {
7954  CanQualType BaseType = Base.getType()->getCanonicalTypeUnqualified();
7955  if (CanonicalDesiredBase == BaseType)
7956  return &Base;
7957  if (BaseType->isDependentType())
7958  AnyDependentBases = true;
7959  }
7960  return nullptr;
7961 }
7962 
7963 namespace {
7964 class UsingValidatorCCC : public CorrectionCandidateCallback {
7965 public:
7966  UsingValidatorCCC(bool HasTypenameKeyword, bool IsInstantiation,
7967  NestedNameSpecifier *NNS, CXXRecordDecl *RequireMemberOf)
7968  : HasTypenameKeyword(HasTypenameKeyword),
7969  IsInstantiation(IsInstantiation), OldNNS(NNS),
7970  RequireMemberOf(RequireMemberOf) {}
7971 
7972  bool ValidateCandidate(const TypoCorrection &Candidate) override {
7973  NamedDecl *ND = Candidate.getCorrectionDecl();
7974 
7975  // Keywords are not valid here.
7976  if (!ND || isa<NamespaceDecl>(ND))
7977  return false;
7978 
7979  // Completely unqualified names are invalid for a 'using' declaration.
7980  if (Candidate.WillReplaceSpecifier() && !Candidate.getCorrectionSpecifier())
7981  return false;
7982 
7983  if (RequireMemberOf) {
7984  auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
7985  if (FoundRecord && FoundRecord->isInjectedClassName()) {
7986  // No-one ever wants a using-declaration to name an injected-class-name
7987  // of a base class, unless they're declaring an inheriting constructor.
7988  ASTContext &Ctx = ND->getASTContext();
7989  if (!Ctx.getLangOpts().CPlusPlus11)
7990  return false;
7991  QualType FoundType = Ctx.getRecordType(FoundRecord);
7992 
7993  // Check that the injected-class-name is named as a member of its own
7994  // type; we don't want to suggest 'using Derived::Base;', since that
7995  // means something else.
7996  NestedNameSpecifier *Specifier =
7997  Candidate.WillReplaceSpecifier()
7998  ? Candidate.getCorrectionSpecifier()
7999  : OldNNS;
8000  if (!Specifier->getAsType() ||
8001  !Ctx.hasSameType(QualType(Specifier->getAsType(), 0), FoundType))
8002  return false;
8003 
8004  // Check that this inheriting constructor declaration actually names a
8005  // direct base class of the current class.
8006  bool AnyDependentBases = false;
8007  if (!findDirectBaseWithType(RequireMemberOf,
8008  Ctx.getRecordType(FoundRecord),
8009  AnyDependentBases) &&
8010  !AnyDependentBases)
8011  return false;
8012  } else {
8013  auto *RD = dyn_cast<CXXRecordDecl>(ND->getDeclContext());
8014  if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(RD))
8015  return false;
8016 
8017  // FIXME: Check that the base class member is accessible?
8018  }
8019  } else {
8020  auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
8021  if (FoundRecord && FoundRecord->isInjectedClassName())
8022  return false;
8023  }
8024 
8025  if (isa<TypeDecl>(ND))
8026  return HasTypenameKeyword || !IsInstantiation;
8027 
8028  return !HasTypenameKeyword;
8029  }
8030 
8031 private:
8032  bool HasTypenameKeyword;
8033  bool IsInstantiation;
8034  NestedNameSpecifier *OldNNS;
8035  CXXRecordDecl *RequireMemberOf;
8036 };
8037 } // end anonymous namespace
8038 
8039 /// Builds a using declaration.
8040 ///
8041 /// \param IsInstantiation - Whether this call arises from an
8042 /// instantiation of an unresolved using declaration. We treat
8043 /// the lookup differently for these declarations.
8045  SourceLocation UsingLoc,
8046  CXXScopeSpec &SS,
8047  DeclarationNameInfo NameInfo,
8048  AttributeList *AttrList,
8049  bool IsInstantiation,
8050  bool HasTypenameKeyword,
8051  SourceLocation TypenameLoc) {
8052  assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
8053  SourceLocation IdentLoc = NameInfo.getLoc();
8054  assert(IdentLoc.isValid() && "Invalid TargetName location.");
8055 
8056  // FIXME: We ignore attributes for now.
8057 
8058  if (SS.isEmpty()) {
8059  Diag(IdentLoc, diag::err_using_requires_qualname);
8060  return nullptr;
8061  }
8062 
8063  // Do the redeclaration lookup in the current scope.
8064  LookupResult Previous(*this, NameInfo, LookupUsingDeclName,
8066  Previous.setHideTags(false);
8067  if (S) {
8068  LookupName(Previous, S);
8069 
8070  // It is really dumb that we have to do this.
8071  LookupResult::Filter F = Previous.makeFilter();
8072  while (F.hasNext()) {
8073  NamedDecl *D = F.next();
8074  if (!isDeclInScope(D, CurContext, S))
8075  F.erase();
8076  // If we found a local extern declaration that's not ordinarily visible,
8077  // and this declaration is being added to a non-block scope, ignore it.
8078  // We're only checking for scope conflicts here, not also for violations
8079  // of the linkage rules.
8080  else if (!CurContext->isFunctionOrMethod() && D->isLocalExternDecl() &&
8082  F.erase();
8083  }
8084  F.done();
8085  } else {
8086  assert(IsInstantiation && "no scope in non-instantiation");
8087  assert(CurContext->isRecord() && "scope not record in instantiation");
8088  LookupQualifiedName(Previous, CurContext);
8089  }
8090 
8091  // Check for invalid redeclarations.
8092  if (CheckUsingDeclRedeclaration(UsingLoc, HasTypenameKeyword,
8093  SS, IdentLoc, Previous))
8094  return nullptr;
8095 
8096  // Check for bad qualifiers.
8097  if (CheckUsingDeclQualifier(UsingLoc, SS, NameInfo, IdentLoc))
8098  return nullptr;
8099 
8100  DeclContext *LookupContext = computeDeclContext(SS);
8101  NamedDecl *D;
8103  if (!LookupContext) {
8104  if (HasTypenameKeyword) {
8105  // FIXME: not all declaration name kinds are legal here
8107  UsingLoc, TypenameLoc,
8108  QualifierLoc,
8109  IdentLoc, NameInfo.getName());
8110  } else {
8112  QualifierLoc, NameInfo);
8113  }
8114  D->setAccess(AS);
8115  CurContext->addDecl(D);
8116  return D;
8117  }
8118 
8119  auto Build = [&](bool Invalid) {
8120  UsingDecl *UD =
8121  UsingDecl::Create(Context, CurContext, UsingLoc, QualifierLoc, NameInfo,
8122  HasTypenameKeyword);
8123  UD->setAccess(AS);
8124  CurContext->addDecl(UD);
8125  UD->setInvalidDecl(Invalid);
8126  return UD;
8127  };
8128  auto BuildInvalid = [&]{ return Build(true); };
8129  auto BuildValid = [&]{ return Build(false); };
8130 
8131  if (RequireCompleteDeclContext(SS, LookupContext))
8132  return BuildInvalid();
8133 
8134  // Look up the target name.
8135  LookupResult R(*this, NameInfo, LookupOrdinaryName);
8136 
8137  // Unlike most lookups, we don't always want to hide tag
8138  // declarations: tag names are visible through the using declaration
8139  // even if hidden by ordinary names, *except* in a dependent context
8140  // where it's important for the sanity of two-phase lookup.
8141  if (!IsInstantiation)
8142  R.setHideTags(false);
8143 
8144  // For the purposes of this lookup, we have a base object type
8145  // equal to that of the current context.
8146  if (CurContext->isRecord()) {
8148  Context.getTypeDeclType(cast<CXXRecordDecl>(CurContext)));
8149  }
8150 
8151  LookupQualifiedName(R, LookupContext);
8152 
8153  // Try to correct typos if possible. If constructor name lookup finds no
8154  // results, that means the named class has no explicit constructors, and we
8155  // suppressed declaring implicit ones (probably because it's dependent or
8156  // invalid).
8157  if (R.empty() &&
8159  if (TypoCorrection Corrected = CorrectTypo(
8160  R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
8161  llvm::make_unique<UsingValidatorCCC>(
8162  HasTypenameKeyword, IsInstantiation, SS.getScopeRep(),
8163  dyn_cast<CXXRecordDecl>(CurContext)),
8164  CTK_ErrorRecovery)) {
8165  // We reject any correction for which ND would be NULL.
8166  NamedDecl *ND = Corrected.getCorrectionDecl();
8167 
8168  // We reject candidates where DroppedSpecifier == true, hence the
8169  // literal '0' below.
8170  diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
8171  << NameInfo.getName() << LookupContext << 0
8172  << SS.getRange());
8173 
8174  // If we corrected to an inheriting constructor, handle it as one.
8175  auto *RD = dyn_cast<CXXRecordDecl>(ND);
8176  if (RD && RD->isInjectedClassName()) {
8177  // Fix up the information we'll use to build the using declaration.
8178  if (Corrected.WillReplaceSpecifier()) {
8180  Builder.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
8181  QualifierLoc.getSourceRange());
8182  QualifierLoc = Builder.getWithLocInContext(Context);
8183  }
8184 
8187  NameInfo.setNamedTypeInfo(nullptr);
8188  for (auto *Ctor : LookupConstructors(RD))
8189  R.addDecl(Ctor);
8190  } else {
8191  // FIXME: Pick up all the declarations if we found an overloaded function.
8192  R.addDecl(ND);
8193  }
8194  } else {
8195  Diag(IdentLoc, diag::err_no_member)
8196  << NameInfo.getName() << LookupContext << SS.getRange();
8197  return BuildInvalid();
8198  }
8199  }
8200 
8201  if (R.isAmbiguous())
8202  return BuildInvalid();
8203 
8204  if (HasTypenameKeyword) {
8205  // If we asked for a typename and got a non-type decl, error out.
8206  if (!R.getAsSingle<TypeDecl>()) {
8207  Diag(IdentLoc, diag::err_using_typename_non_type);
8208  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
8209  Diag((*I)->getUnderlyingDecl()->getLocation(),
8210  diag::note_using_decl_target);
8211  return BuildInvalid();
8212  }
8213  } else {
8214  // If we asked for a non-typename and we got a type, error out,
8215  // but only if this is an instantiation of an unresolved using
8216  // decl. Otherwise just silently find the type name.
8217  if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
8218  Diag(IdentLoc, diag::err_using_dependent_value_is_type);
8219  Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
8220  return BuildInvalid();
8221  }
8222  }
8223 
8224  // C++0x N2914 [namespace.udecl]p6:
8225  // A using-declaration shall not name a namespace.
8226  if (R.getAsSingle<NamespaceDecl>()) {
8227  Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
8228  << SS.getRange();
8229  return BuildInvalid();
8230  }
8231 
8232  UsingDecl *UD = BuildValid();
8233 
8234  // The normal rules do not apply to inheriting constructor declarations.
8236  // Suppress access diagnostics; the access check is instead performed at the
8237  // point of use for an inheriting constructor.
8238  R.suppressDiagnostics();
8240  return UD;
8241  }
8242 
8243  // Otherwise, look up the target name.
8244 
8245  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
8246  UsingShadowDecl *PrevDecl = nullptr;
8247  if (!CheckUsingShadowDecl(UD, *I, Previous, PrevDecl))
8248  BuildUsingShadowDecl(S, UD, *I, PrevDecl);
8249  }
8250 
8251  return UD;
8252 }
8253 
8254 /// Additional checks for a using declaration referring to a constructor name.
8256  assert(!UD->hasTypename() && "expecting a constructor name");
8257 
8258  const Type *SourceType = UD->getQualifier()->getAsType();
8259  assert(SourceType &&
8260  "Using decl naming constructor doesn't have type in scope spec.");
8261  CXXRecordDecl *TargetClass = cast<CXXRecordDecl>(CurContext);
8262 
8263  // Check whether the named type is a direct base class.
8264  bool AnyDependentBases = false;
8265  auto *Base = findDirectBaseWithType(TargetClass, QualType(SourceType, 0),
8266  AnyDependentBases);
8267  if (!Base && !AnyDependentBases) {
8268  Diag(UD->getUsingLoc(),
8269  diag::err_using_decl_constructor_not_in_direct_base)
8270  << UD->getNameInfo().getSourceRange()
8271  << QualType(SourceType, 0) << TargetClass;
8272  UD->setInvalidDecl();
8273  return true;
8274  }
8275 
8276  if (Base)
8277  Base->setInheritConstructors();
8278 
8279  return false;
8280 }
8281 
8282 /// Checks that the given using declaration is not an invalid
8283 /// redeclaration. Note that this is checking only for the using decl
8284 /// itself, not for any ill-formedness among the UsingShadowDecls.
8286  bool HasTypenameKeyword,
8287  const CXXScopeSpec &SS,
8288  SourceLocation NameLoc,
8289  const LookupResult &Prev) {
8290  // C++03 [namespace.udecl]p8:
8291  // C++0x [namespace.udecl]p10:
8292  // A using-declaration is a declaration and can therefore be used
8293  // repeatedly where (and only where) multiple declarations are
8294  // allowed.
8295  //
8296  // That's in non-member contexts.
8298  return false;
8299 
8300  NestedNameSpecifier *Qual = SS.getScopeRep();
8301 
8302  for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
8303  NamedDecl *D = *I;
8304 
8305  bool DTypename;
8306  NestedNameSpecifier *DQual;
8307  if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
8308  DTypename = UD->hasTypename();
8309  DQual = UD->getQualifier();
8310  } else if (UnresolvedUsingValueDecl *UD
8311  = dyn_cast<UnresolvedUsingValueDecl>(D)) {
8312  DTypename = false;
8313  DQual = UD->getQualifier();
8314  } else if (UnresolvedUsingTypenameDecl *UD
8315  = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
8316  DTypename = true;
8317  DQual = UD->getQualifier();
8318  } else continue;
8319 
8320  // using decls differ if one says 'typename' and the other doesn't.
8321  // FIXME: non-dependent using decls?
8322  if (HasTypenameKeyword != DTypename) continue;
8323 
8324  // using decls differ if they name different scopes (but note that
8325  // template instantiation can cause this check to trigger when it
8326  // didn't before instantiation).
8329  continue;
8330 
8331  Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
8332  Diag(D->getLocation(), diag::note_using_decl) << 1;
8333  return true;
8334  }
8335 
8336  return false;
8337 }
8338 
8339 
8340 /// Checks that the given nested-name qualifier used in a using decl
8341 /// in the current context is appropriately related to the current
8342 /// scope. If an error is found, diagnoses it and returns true.
8344  const CXXScopeSpec &SS,
8345  const DeclarationNameInfo &NameInfo,
8346  SourceLocation NameLoc) {
8347  DeclContext *NamedContext = computeDeclContext(SS);
8348 
8349  if (!CurContext->isRecord()) {
8350  // C++03 [namespace.udecl]p3:
8351  // C++0x [namespace.udecl]p8:
8352  // A using-declaration for a class member shall be a member-declaration.
8353 
8354  // If we weren't able to compute a valid scope, it must be a
8355  // dependent class scope.
8356  if (!NamedContext || NamedContext->isRecord()) {
8357  auto *RD = dyn_cast_or_null<CXXRecordDecl>(NamedContext);
8358  if (RD && RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), RD))
8359  RD = nullptr;
8360 
8361  Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member)
8362  << SS.getRange();
8363 
8364  // If we have a complete, non-dependent source type, try to suggest a
8365  // way to get the same effect.
8366  if (!RD)
8367  return true;
8368 
8369  // Find what this using-declaration was referring to.
8370  LookupResult R(*this, NameInfo, LookupOrdinaryName);
8371  R.setHideTags(false);
8372  R.suppressDiagnostics();
8373  LookupQualifiedName(R, RD);
8374 
8375  if (R.getAsSingle<TypeDecl>()) {
8376  if (getLangOpts().CPlusPlus11) {
8377  // Convert 'using X::Y;' to 'using Y = X::Y;'.
8378  Diag(SS.getBeginLoc(), diag::note_using_decl_class_member_workaround)
8379  << 0 // alias declaration
8381  NameInfo.getName().getAsString() +
8382  " = ");
8383  } else {
8384  // Convert 'using X::Y;' to 'typedef X::Y Y;'.
8385  SourceLocation InsertLoc =
8386  getLocForEndOfToken(NameInfo.getLocEnd());
8387  Diag(InsertLoc, diag::note_using_decl_class_member_workaround)
8388  << 1 // typedef declaration
8389  << FixItHint::CreateReplacement(UsingLoc, "typedef")
8391  InsertLoc, " " + NameInfo.getName().getAsString());
8392  }
8393  } else if (R.getAsSingle<VarDecl>()) {
8394  // Don't provide a fixit outside C++11 mode; we don't want to suggest
8395  // repeating the type of the static data member here.
8396  FixItHint FixIt;
8397  if (getLangOpts().CPlusPlus11) {
8398  // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
8400  UsingLoc, "auto &" + NameInfo.getName().getAsString() + " = ");
8401  }
8402 
8403  Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
8404  << 2 // reference declaration
8405  << FixIt;
8406  }
8407  return true;
8408  }
8409 
8410  // Otherwise, everything is known to be fine.
8411  return false;
8412  }
8413 
8414  // The current scope is a record.
8415 
8416  // If the named context is dependent, we can't decide much.
8417  if (!NamedContext) {
8418  // FIXME: in C++0x, we can diagnose if we can prove that the
8419  // nested-name-specifier does not refer to a base class, which is
8420  // still possible in some cases.
8421 
8422  // Otherwise we have to conservatively report that things might be
8423  // okay.
8424  return false;
8425  }
8426 
8427  if (!NamedContext->isRecord()) {
8428  // Ideally this would point at the last name in the specifier,
8429  // but we don't have that level of source info.
8430  Diag(SS.getRange().getBegin(),
8431  diag::err_using_decl_nested_name_specifier_is_not_class)
8432  << SS.getScopeRep() << SS.getRange();
8433  return true;
8434  }
8435 
8436  if (!NamedContext->isDependentContext() &&
8437  RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), NamedContext))
8438  return true;
8439 
8440  if (getLangOpts().CPlusPlus11) {
8441  // C++0x [namespace.udecl]p3:
8442  // In a using-declaration used as a member-declaration, the
8443  // nested-name-specifier shall name a base class of the class
8444  // being defined.
8445 
8446  if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
8447  cast<CXXRecordDecl>(NamedContext))) {
8448  if (CurContext == NamedContext) {
8449  Diag(NameLoc,
8450  diag::err_using_decl_nested_name_specifier_is_current_class)
8451  << SS.getRange();
8452  return true;
8453  }
8454 
8455  Diag(SS.getRange().getBegin(),
8456  diag::err_using_decl_nested_name_specifier_is_not_base_class)
8457  << SS.getScopeRep()
8458  << cast<CXXRecordDecl>(CurContext)
8459  << SS.getRange();
8460  return true;
8461  }
8462 
8463  return false;
8464  }
8465 
8466  // C++03 [namespace.udecl]p4:
8467  // A using-declaration used as a member-declaration shall refer
8468  // to a member of a base class of the class being defined [etc.].
8469 
8470  // Salient point: SS doesn't have to name a base class as long as
8471  // lookup only finds members from base classes. Therefore we can
8472  // diagnose here only if we can prove that that can't happen,
8473  // i.e. if the class hierarchies provably don't intersect.
8474 
8475  // TODO: it would be nice if "definitely valid" results were cached
8476  // in the UsingDecl and UsingShadowDecl so that these checks didn't
8477  // need to be repeated.
8478 
8479  llvm::SmallPtrSet<const CXXRecordDecl *, 4> Bases;
8480  auto Collect = [&Bases](const CXXRecordDecl *Base) {
8481  Bases.insert(Base);
8482  return true;
8483  };
8484 
8485  // Collect all bases. Return false if we find a dependent base.
8486  if (!cast<CXXRecordDecl>(CurContext)->forallBases(Collect))
8487  return false;
8488 
8489  // Returns true if the base is dependent or is one of the accumulated base
8490  // classes.
8491  auto IsNotBase = [&Bases](const CXXRecordDecl *Base) {
8492  return !Bases.count(Base);
8493  };
8494 
8495  // Return false if the class has a dependent base or if it or one
8496  // of its bases is present in the base set of the current context.
8497  if (Bases.count(cast<CXXRecordDecl>(NamedContext)) ||
8498  !cast<CXXRecordDecl>(NamedContext)->forallBases(IsNotBase))
8499  return false;
8500 
8501  Diag(SS.getRange().getBegin(),
8502  diag::err_using_decl_nested_name_specifier_is_not_base_class)
8503  << SS.getScopeRep()
8504  << cast<CXXRecordDecl>(CurContext)
8505  << SS.getRange();
8506 
8507  return true;
8508 }
8509 
8511  AccessSpecifier AS,
8512  MultiTemplateParamsArg TemplateParamLists,
8513  SourceLocation UsingLoc,
8514  UnqualifiedId &Name,
8515  AttributeList *AttrList,
8516  TypeResult Type,
8517  Decl *DeclFromDeclSpec) {
8518  // Skip up to the relevant declaration scope.
8519  while (S->isTemplateParamScope())
8520  S = S->getParent();
8521  assert((S->getFlags() & Scope::DeclScope) &&
8522  "got alias-declaration outside of declaration scope");
8523 
8524  if (Type.isInvalid())
8525  return nullptr;
8526 
8527  bool Invalid = false;
8529  TypeSourceInfo *TInfo = nullptr;
8530  GetTypeFromParser(Type.get(), &TInfo);
8531 
8532  if (DiagnoseClassNameShadow(CurContext, NameInfo))
8533  return nullptr;
8534 
8537  Invalid = true;
8539  TInfo->getTypeLoc().getBeginLoc());
8540  }
8541 
8543  LookupName(Previous, S);
8544 
8545  // Warn about shadowing the name of a template parameter.
8546  if (Previous.isSingleResult() &&
8547  Previous.getFoundDecl()->isTemplateParameter()) {
8549  Previous.clear();
8550  }
8551 
8552  assert(Name.Kind == UnqualifiedId::IK_Identifier &&
8553  "name in alias declaration must be an identifier");
8555  Name.StartLocation,
8556  Name.Identifier, TInfo);
8557 
8558  NewTD->setAccess(AS);
8559 
8560  if (Invalid)
8561  NewTD->setInvalidDecl();
8562 
8563  ProcessDeclAttributeList(S, NewTD, AttrList);
8564 
8566  Invalid |= NewTD->isInvalidDecl();
8567 
8568  bool Redeclaration = false;
8569 
8570  NamedDecl *NewND;
8571  if (TemplateParamLists.size()) {
8572  TypeAliasTemplateDecl *OldDecl = nullptr;
8573  TemplateParameterList *OldTemplateParams = nullptr;
8574 
8575  if (TemplateParamLists.size() != 1) {
8576  Diag(UsingLoc, diag::err_alias_template_extra_headers)
8577  << SourceRange(TemplateParamLists[1]->getTemplateLoc(),
8578  TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
8579  }
8580  TemplateParameterList *TemplateParams = TemplateParamLists[0];
8581 
8582  // Only consider previous declarations in the same scope.
8583  FilterLookupForScope(Previous, CurContext, S, /*ConsiderLinkage*/false,
8584  /*ExplicitInstantiationOrSpecialization*/false);
8585  if (!Previous.empty()) {
8586  Redeclaration = true;
8587 
8588  OldDecl = Previous.getAsSingle<TypeAliasTemplateDecl>();
8589  if (!OldDecl && !Invalid) {
8590  Diag(UsingLoc, diag::err_redefinition_different_kind)
8591  << Name.Identifier;
8592 
8593  NamedDecl *OldD = Previous.getRepresentativeDecl();
8594  if (OldD->getLocation().isValid())
8595  Diag(OldD->getLocation(), diag::note_previous_definition);
8596 
8597  Invalid = true;
8598  }
8599 
8600  if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) {
8601  if (TemplateParameterListsAreEqual(TemplateParams,
8602  OldDecl->getTemplateParameters(),
8603  /*Complain=*/true,
8605  OldTemplateParams = OldDecl->getTemplateParameters();
8606  else
8607  Invalid = true;
8608 
8609  TypeAliasDecl *OldTD = OldDecl->getTemplatedDecl();
8610  if (!Invalid &&
8612  NewTD->getUnderlyingType())) {
8613  // FIXME: The C++0x standard does not clearly say this is ill-formed,
8614  // but we can't reasonably accept it.
8615  Diag(NewTD->getLocation(), diag::err_redefinition_different_typedef)
8616  << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType();
8617  if (OldTD->getLocation().isValid())
8618  Diag(OldTD->getLocation(), diag::note_previous_definition);
8619  Invalid = true;
8620  }
8621  }
8622  }
8623 
8624  // Merge any previous default template arguments into our parameters,
8625  // and check the parameter list.
8626  if (CheckTemplateParameterList(TemplateParams, OldTemplateParams,
8628  return nullptr;
8629 
8630  TypeAliasTemplateDecl *NewDecl =
8632  Name.Identifier, TemplateParams,
8633  NewTD);
8634  NewTD->setDescribedAliasTemplate(NewDecl);
8635 
8636  NewDecl->setAccess(AS);
8637 
8638  if (Invalid)
8639  NewDecl->setInvalidDecl();
8640  else if (OldDecl)
8641  NewDecl->setPreviousDecl(OldDecl);
8642 
8643  NewND = NewDecl;
8644  } else {
8645  if (auto *TD = dyn_cast_or_null<TagDecl>(DeclFromDeclSpec)) {
8646  setTagNameForLinkagePurposes(TD, NewTD);
8647  handleTagNumbering(TD, S);
8648  }
8649  ActOnTypedefNameDecl(S, CurContext, NewTD, Previous, Redeclaration);
8650  NewND = NewTD;
8651  }
8652 
8653  if (!Redeclaration)
8654  PushOnScopeChains(NewND, S);
8655 
8656  ActOnDocumentableDecl(NewND);
8657  return NewND;
8658 }
8659 
8661  SourceLocation AliasLoc,
8662  IdentifierInfo *Alias, CXXScopeSpec &SS,
8663  SourceLocation IdentLoc,
8664  IdentifierInfo *Ident) {
8665 
8666  // Lookup the namespace name.
8667  LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
8668  LookupParsedName(R, S, &SS);
8669 
8670  if (R.isAmbiguous())
8671  return nullptr;
8672 
8673  if (R.empty()) {
8674  if (!TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, Ident)) {
8675  Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
8676  return nullptr;
8677  }
8678  }
8679  assert(!R.isAmbiguous() && !R.empty());
8680  NamedDecl *ND = R.getRepresentativeDecl();
8681 
8682  // Check if we have a previous declaration with the same name.
8683  LookupResult PrevR(*this, Alias, AliasLoc, LookupOrdinaryName,
8685  LookupName(PrevR, S);
8686 
8687  // Check we're not shadowing a template parameter.
8688  if (PrevR.isSingleResult() && PrevR.getFoundDecl()->isTemplateParameter()) {
8689  DiagnoseTemplateParameterShadow(AliasLoc, PrevR.getFoundDecl());
8690  PrevR.clear();
8691  }
8692 
8693  // Filter out any other lookup result from an enclosing scope.
8694  FilterLookupForScope(PrevR, CurContext, S, /*ConsiderLinkage*/false,
8695  /*AllowInlineNamespace*/false);
8696 
8697  // Find the previous declaration and check that we can redeclare it.
8698  NamespaceAliasDecl *Prev = nullptr;
8699  if (PrevR.isSingleResult()) {
8700  NamedDecl *PrevDecl = PrevR.getRepresentativeDecl();
8701  if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
8702  // We already have an alias with the same name that points to the same
8703  // namespace; check that it matches.
8704  if (AD->getNamespace()->Equals(getNamespaceDecl(ND))) {
8705  Prev = AD;
8706  } else if (isVisible(PrevDecl)) {
8707  Diag(AliasLoc, diag::err_redefinition_different_namespace_alias)
8708  << Alias;
8709  Diag(AD->getLocation(), diag::note_previous_namespace_alias)
8710  << AD->getNamespace();
8711  return nullptr;
8712  }
8713  } else if (isVisible(PrevDecl)) {
8714  unsigned DiagID = isa<NamespaceDecl>(PrevDecl->getUnderlyingDecl())
8715  ? diag::err_redefinition
8716  : diag::err_redefinition_different_kind;
8717  Diag(AliasLoc, DiagID) << Alias;
8718  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
8719  return nullptr;
8720  }
8721  }
8722 
8723  // The use of a nested name specifier may trigger deprecation warnings.
8724  DiagnoseUseOfDecl(ND, IdentLoc);
8725 
8726  NamespaceAliasDecl *AliasDecl =
8727  NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
8728  Alias, SS.getWithLocInContext(Context),
8729  IdentLoc, ND);
8730  if (Prev)
8731  AliasDecl->setPreviousDecl(Prev);
8732 
8733  PushOnScopeChains(AliasDecl, S);
8734  return AliasDecl;
8735 }
8736 
8739  CXXMethodDecl *MD) {
8740  CXXRecordDecl *ClassDecl = MD->getParent();
8741 
8742  // C++ [except.spec]p14:
8743  // An implicitly declared special member function (Clause 12) shall have an
8744  // exception-specification. [...]
8745  ImplicitExceptionSpecification ExceptSpec(*this);
8746  if (ClassDecl->isInvalidDecl())
8747  return ExceptSpec;
8748 
8749  // Direct base-class constructors.
8750  for (const auto &B : ClassDecl->bases()) {
8751  if (B.isVirtual()) // Handled below.
8752  continue;
8753 
8754  if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
8755  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
8756  CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
8757  // If this is a deleted function, add it anyway. This might be conformant
8758  // with the standard. This might not. I'm not sure. It might not matter.
8759  if (Constructor)
8760  ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
8761  }
8762  }
8763 
8764  // Virtual base-class constructors.
8765  for (const auto &B : ClassDecl->vbases()) {
8766  if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
8767  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
8768  CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
8769  // If this is a deleted function, add it anyway. This might be conformant
8770  // with the standard. This might not. I'm not sure. It might not matter.
8771  if (Constructor)
8772  ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
8773  }
8774  }
8775 
8776  // Field constructors.
8777  for (const auto *F : ClassDecl->fields()) {
8778  if (F->hasInClassInitializer()) {
8779  if (Expr *E = F->getInClassInitializer())
8780  ExceptSpec.CalledExpr(E);
8781  } else if (const RecordType *RecordTy
8782  = Context.getBaseElementType(F->getType())->getAs<RecordType>()) {
8783  CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
8784  CXXConstructorDecl *Constructor = LookupDefaultConstructor(FieldRecDecl);
8785  // If this is a deleted function, add it anyway. This might be conformant
8786  // with the standard. This might not. I'm not sure. It might not matter.
8787  // In particular, the problem is that this function never gets called. It
8788  // might just be ill-formed because this function attempts to refer to
8789  // a deleted function here.
8790  if (Constructor)
8791  ExceptSpec.CalledDecl(F->getLocation(), Constructor);
8792  }
8793  }
8794 
8795  return ExceptSpec;
8796 }
8797 
8800  CXXRecordDecl *ClassDecl = CD->getParent();
8801 
8802  // C++ [except.spec]p14:
8803  // An inheriting constructor [...] shall have an exception-specification. [...]
8804  ImplicitExceptionSpecification ExceptSpec(*this);
8805  if (ClassDecl->isInvalidDecl())
8806  return ExceptSpec;
8807 
8808  // Inherited constructor.
8809  const CXXConstructorDecl *InheritedCD = CD->getInheritedConstructor();
8810  const CXXRecordDecl *InheritedDecl = InheritedCD->getParent();
8811  // FIXME: Copying or moving the parameters could add extra exceptions to the
8812  // set, as could the default arguments for the inherited constructor. This
8813  // will be addressed when we implement the resolution of core issue 1351.
8814  ExceptSpec.CalledDecl(CD->getLocStart(), InheritedCD);
8815 
8816  // Direct base-class constructors.
8817  for (const auto &B : ClassDecl->bases()) {
8818  if (B.isVirtual()) // Handled below.
8819  continue;
8820 
8821  if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
8822  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
8823  if (BaseClassDecl == InheritedDecl)
8824  continue;
8825  CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
8826  if (Constructor)
8827  ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
8828  }
8829  }
8830 
8831  // Virtual base-class constructors.
8832  for (const auto &B : ClassDecl->vbases()) {
8833  if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
8834  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
8835  if (BaseClassDecl == InheritedDecl)
8836  continue;
8837  CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
8838  if (Constructor)
8839  ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
8840  }
8841  }
8842 
8843  // Field constructors.
8844  for (const auto *F : ClassDecl->fields()) {
8845  if (F->hasInClassInitializer()) {
8846  if (Expr *E = F->getInClassInitializer())
8847  ExceptSpec.CalledExpr(E);
8848  } else if (const RecordType *RecordTy
8849  = Context.getBaseElementType(F->getType())->getAs<RecordType>()) {
8850  CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
8851  CXXConstructorDecl *Constructor = LookupDefaultConstructor(FieldRecDecl);
8852  if (Constructor)
8853  ExceptSpec.CalledDecl(F->getLocation(), Constructor);
8854  }
8855  }
8856 
8857  return ExceptSpec;
8858 }
8859 
8860 namespace {
8861 /// RAII object to register a special member as being currently declared.
8862 struct DeclaringSpecialMember {
8863  Sema &S;
8865  bool WasAlreadyBeingDeclared;
8866 
8867  DeclaringSpecialMember(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM)
8868  : S(S), D(RD, CSM) {
8869  WasAlreadyBeingDeclared = !S.SpecialMembersBeingDeclared.insert(D).second;
8870  if (WasAlreadyBeingDeclared)
8871  // This almost never happens, but if it does, ensure that our cache
8872  // doesn't contain a stale result.
8873  S.SpecialMemberCache.clear();
8874 
8875  // FIXME: Register a note to be produced if we encounter an error while
8876  // declaring the special member.
8877  }
8878  ~DeclaringSpecialMember() {
8879  if (!WasAlreadyBeingDeclared)
8880  S.SpecialMembersBeingDeclared.erase(D);
8881  }
8882 
8883  /// \brief Are we already trying to declare this special member?
8884  bool isAlreadyBeingDeclared() const {
8885  return WasAlreadyBeingDeclared;
8886  }
8887 };
8888 }
8889 
8891  CXXRecordDecl *ClassDecl) {
8892  // C++ [class.ctor]p5:
8893  // A default constructor for a class X is a constructor of class X
8894  // that can be called without an argument. If there is no
8895  // user-declared constructor for class X, a default constructor is
8896  // implicitly declared. An implicitly-declared default constructor
8897  // is an inline public member of its class.
8898  assert(ClassDecl->needsImplicitDefaultConstructor() &&
8899  "Should not build implicit default constructor!");
8900 
8901  DeclaringSpecialMember DSM(*this, ClassDecl, CXXDefaultConstructor);
8902  if (DSM.isAlreadyBeingDeclared())
8903  return nullptr;
8904 
8905  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
8907  false);
8908 
8909  // Create the actual constructor declaration.
8910  CanQualType ClassType
8912  SourceLocation ClassLoc = ClassDecl->getLocation();
8913  DeclarationName Name
8915  DeclarationNameInfo NameInfo(Name, ClassLoc);
8917  Context, ClassDecl, ClassLoc, NameInfo, /*Type*/QualType(),
8918  /*TInfo=*/nullptr, /*isExplicit=*/false, /*isInline=*/true,
8919  /*isImplicitlyDeclared=*/true, Constexpr);
8920  DefaultCon->setAccess(AS_public);
8921  DefaultCon->setDefaulted();
8922 
8923  if (getLangOpts().CUDA) {
8925  DefaultCon,
8926  /* ConstRHS */ false,
8927  /* Diagnose */ false);
8928  }
8929 
8930  // Build an exception specification pointing back at this constructor.
8931  FunctionProtoType::ExtProtoInfo EPI = getImplicitMethodEPI(*this, DefaultCon);
8932  DefaultCon->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
8933 
8934  // We don't need to use SpecialMemberIsTrivial here; triviality for default
8935  // constructors is easy to compute.
8936  DefaultCon->setTrivial(ClassDecl->hasTrivialDefaultConstructor());
8937 
8939  SetDeclDeleted(DefaultCon, ClassLoc);
8940 
8941  // Note that we have declared this constructor.
8943 
8944  if (Scope *S = getScopeForContext(ClassDecl))
8945  PushOnScopeChains(DefaultCon, S, false);
8946  ClassDecl->addDecl(DefaultCon);
8947 
8948  return DefaultCon;
8949 }
8950 
8952  CXXConstructorDecl *Constructor) {
8953  assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
8954  !Constructor->doesThisDeclarationHaveABody() &&
8955  !Constructor->isDeleted()) &&
8956  "DefineImplicitDefaultConstructor - call it for implicit default ctor");
8957 
8958  CXXRecordDecl *ClassDecl = Constructor->getParent();
8959  assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
8960 
8961  SynthesizedFunctionScope Scope(*this, Constructor);
8962  DiagnosticErrorTrap Trap(Diags);
8963  if (SetCtorInitializers(Constructor, /*AnyErrors=*/false) ||
8964  Trap.hasErrorOccurred()) {
8965  Diag(CurrentLocation, diag::note_member_synthesized_at)
8966  << CXXDefaultConstructor << Context.getTagDeclType(ClassDecl);
8967  Constructor->setInvalidDecl();
8968  return;
8969  }
8970 
8971  // The exception specification is needed because we are defining the
8972  // function.
8973  ResolveExceptionSpec(CurrentLocation,
8974  Constructor->getType()->castAs<FunctionProtoType>());
8975 
8976  SourceLocation Loc = Constructor->getLocEnd().isValid()
8977  ? Constructor->getLocEnd()
8978  : Constructor->getLocation();
8979  Constructor->setBody(new (Context) CompoundStmt(Loc));
8980 
8981  Constructor->markUsed(Context);
8982  MarkVTableUsed(CurrentLocation, ClassDecl);
8983 
8985  L->CompletedImplicitDefinition(Constructor);
8986  }
8987 
8988  DiagnoseUninitializedFields(*this, Constructor);
8989 }
8990 
8992  // Perform any delayed checks on exception specifications.
8994 }
8995 
8996 namespace {
8997 /// Information on inheriting constructors to declare.
8998 class InheritingConstructorInfo {
8999 public:
9000  InheritingConstructorInfo(Sema &SemaRef, CXXRecordDecl *Derived)
9001  : SemaRef(SemaRef), Derived(Derived) {
9002  // Mark the constructors that we already have in the derived class.
9003  //
9004  // C++11 [class.inhctor]p3: [...] a constructor is implicitly declared [...]
9005  // unless there is a user-declared constructor with the same signature in
9006  // the class where the using-declaration appears.
9007  visitAll(Derived, &InheritingConstructorInfo::noteDeclaredInDerived);
9008  }
9009 
9010  void inheritAll(CXXRecordDecl *RD) {
9011  visitAll(RD, &InheritingConstructorInfo::inherit);
9012  }
9013 
9014 private:
9015  /// Information about an inheriting constructor.
9016  struct InheritingConstructor {
9017  InheritingConstructor()
9018  : DeclaredInDerived(false), BaseCtor(nullptr), DerivedCtor(nullptr) {}
9019 
9020  /// If \c true, a constructor with this signature is already declared
9021  /// in the derived class.
9022  bool DeclaredInDerived;
9023 
9024  /// The constructor which is inherited.
9025  const CXXConstructorDecl *BaseCtor;
9026 
9027  /// The derived constructor we declared.
9028  CXXConstructorDecl *DerivedCtor;
9029  };
9030 
9031  /// Inheriting constructors with a given canonical type. There can be at
9032  /// most one such non-template constructor, and any number of templated
9033  /// constructors.
9034  struct InheritingConstructorsForType {
9035  InheritingConstructor NonTemplate;
9037  Templates;
9038 
9039  InheritingConstructor &getEntry(Sema &S, const CXXConstructorDecl *Ctor) {
9041  TemplateParameterList *ParamList = FTD->getTemplateParameters();
9042  for (unsigned I = 0, N = Templates.size(); I != N; ++I)
9043  if (S.TemplateParameterListsAreEqual(ParamList, Templates[I].first,
9044  false, S.TPL_TemplateMatch))
9045  return Templates[I].second;
9046  Templates.push_back(std::make_pair(ParamList, InheritingConstructor()));
9047  return Templates.back().second;
9048  }
9049 
9050  return NonTemplate;
9051  }
9052  };
9053 
9054  /// Get or create the inheriting constructor record for a constructor.
9055  InheritingConstructor &getEntry(const CXXConstructorDecl *Ctor,
9056  QualType CtorType) {
9057  return Map[CtorType.getCanonicalType()->castAs<FunctionProtoType>()]
9058  .getEntry(SemaRef, Ctor);
9059  }
9060 
9061  typedef void (InheritingConstructorInfo::*VisitFn)(const CXXConstructorDecl*);
9062 
9063  /// Process all constructors for a class.
9064  void visitAll(const CXXRecordDecl *RD, VisitFn Callback) {
9065  for (const auto *Ctor : RD->ctors())
9066  (this->*Callback)(Ctor);
9067  for (CXXRecordDecl::specific_decl_iterator<FunctionTemplateDecl>
9068  I(RD->decls_begin()), E(RD->decls_end());
9069  I != E; ++I) {
9070  const FunctionDecl *FD = (*I)->getTemplatedDecl();
9071  if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD))
9072  (this->*Callback)(CD);
9073  }
9074  }
9075 
9076  /// Note that a constructor (or constructor template) was declared in Derived.
9077  void noteDeclaredInDerived(const CXXConstructorDecl *Ctor) {
9078  getEntry(Ctor, Ctor->getType()).DeclaredInDerived = true;
9079  }
9080 
9081  /// Inherit a single constructor.
9082  void inherit(const CXXConstructorDecl *Ctor) {
9083  const FunctionProtoType *CtorType =
9084  Ctor->getType()->castAs<FunctionProtoType>();
9085  ArrayRef<QualType> ArgTypes = CtorType->getParamTypes();
9087 
9088  SourceLocation UsingLoc = getUsingLoc(Ctor->getParent());
9089 
9090  // Core issue (no number yet): the ellipsis is always discarded.
9091  if (EPI.Variadic) {
9092  SemaRef.Diag(UsingLoc, diag::warn_using_decl_constructor_ellipsis);
9093  SemaRef.Diag(Ctor->getLocation(),
9094  diag::note_using_decl_constructor_ellipsis);
9095  EPI.Variadic = false;
9096  }
9097 
9098  // Declare a constructor for each number of parameters.
9099  //
9100  // C++11 [class.inhctor]p1:
9101  // The candidate set of inherited constructors from the class X named in
9102  // the using-declaration consists of [... modulo defects ...] for each
9103  // constructor or constructor template of X, the set of constructors or
9104  // constructor templates that results from omitting any ellipsis parameter
9105  // specification and successively omitting parameters with a default
9106  // argument from the end of the parameter-type-list
9107  unsigned MinParams = minParamsToInherit(Ctor);
9108  unsigned Params = Ctor->getNumParams();
9109  if (Params >= MinParams) {
9110  do
9111  declareCtor(UsingLoc, Ctor,
9112  SemaRef.Context.getFunctionType(
9113  Ctor->getReturnType(), ArgTypes.slice(0, Params), EPI));
9114  while (Params > MinParams &&
9115  Ctor->getParamDecl(--Params)->hasDefaultArg());
9116  }
9117  }
9118 
9119  /// Find the using-declaration which specified that we should inherit the
9120  /// constructors of \p Base.
9121  SourceLocation getUsingLoc(const CXXRecordDecl *Base) {
9122  // No fancy lookup required; just look for the base constructor name
9123  // directly within the derived class.
9124  ASTContext &Context = SemaRef.Context;
9126  Context.getCanonicalType(Context.getRecordType(Base)));
9127  DeclContext::lookup_result Decls = Derived->lookup(Name);
9128  return Decls.empty() ? Derived->getLocation() : Decls[0]->getLocation();
9129  }
9130 
9131  unsigned minParamsToInherit(const CXXConstructorDecl *Ctor) {
9132  // C++11 [class.inhctor]p3:
9133  // [F]or each constructor template in the candidate set of inherited
9134  // constructors, a constructor template is implicitly declared
9135  if (Ctor->getDescribedFunctionTemplate())
9136  return 0;
9137 
9138  // For each non-template constructor in the candidate set of inherited
9139  // constructors other than a constructor having no parameters or a
9140  // copy/move constructor having a single parameter, a constructor is
9141  // implicitly declared [...]
9142  if (Ctor->getNumParams() == 0)
9143  return 1;
9144  if (Ctor->isCopyOrMoveConstructor())
9145  return 2;
9146 
9147  // Per discussion on core reflector, never inherit a constructor which
9148  // would become a default, copy, or move constructor of Derived either.
9149  const ParmVarDecl *PD = Ctor->getParamDecl(0);
9150  const ReferenceType *RT = PD->getType()->getAs<ReferenceType>();
9151  return (RT && RT->getPointeeCXXRecordDecl() == Derived) ? 2 : 1;
9152  }
9153 
9154  /// Declare a single inheriting constructor, inheriting the specified
9155  /// constructor, with the given type.
9156  void declareCtor(SourceLocation UsingLoc, const CXXConstructorDecl *BaseCtor,
9157  QualType DerivedType) {
9158  InheritingConstructor &Entry = getEntry(BaseCtor, DerivedType);
9159 
9160  // C++11 [class.inhctor]p3:
9161  // ... a constructor is implicitly declared with the same constructor
9162  // characteristics unless there is a user-declared constructor with
9163  // the same signature in the class where the using-declaration appears
9164  if (Entry.DeclaredInDerived)
9165  return;
9166 
9167  // C++11 [class.inhctor]p7:
9168  // If two using-declarations declare inheriting constructors with the
9169  // same signature, the program is ill-formed
9170  if (Entry.DerivedCtor) {
9171  if (BaseCtor->getParent() != Entry.BaseCtor->getParent()) {
9172  // Only diagnose this once per constructor.
9173  if (Entry.DerivedCtor->isInvalidDecl())
9174  return;
9175  Entry.DerivedCtor->setInvalidDecl();
9176 
9177  SemaRef.Diag(UsingLoc, diag::err_using_decl_constructor_conflict);
9178  SemaRef.Diag(BaseCtor->getLocation(),
9179  diag::note_using_decl_constructor_conflict_current_ctor);
9180  SemaRef.Diag(Entry.BaseCtor->getLocation(),
9181  diag::note_using_decl_constructor_conflict_previous_ctor);
9182  SemaRef.Diag(Entry.DerivedCtor->getLocation(),
9183  diag::note_using_decl_constructor_conflict_previous_using);
9184  } else {
9185  // Core issue (no number): if the same inheriting constructor is
9186  // produced by multiple base class constructors from the same base
9187  // class, the inheriting constructor is defined as deleted.
9188  SemaRef.SetDeclDeleted(Entry.DerivedCtor, UsingLoc);
9189  }
9190 
9191  return;
9192  }
9193 
9194  ASTContext &Context = SemaRef.Context;
9196  Context.getCanonicalType(Context.getRecordType(Derived)));
9197  DeclarationNameInfo NameInfo(Name, UsingLoc);
9198 
9199  TemplateParameterList *TemplateParams = nullptr;
9200  if (const FunctionTemplateDecl *FTD =
9201  BaseCtor->getDescribedFunctionTemplate()) {
9202  TemplateParams = FTD->getTemplateParameters();
9203  // We're reusing template parameters from a different DeclContext. This
9204  // is questionable at best, but works out because the template depth in
9205  // both places is guaranteed to be 0.
9206  // FIXME: Rebuild the template parameters in the new context, and
9207  // transform the function type to refer to them.
9208  }
9209 
9210  // Build type source info pointing at the using-declaration. This is
9211  // required by template instantiation.
9212  TypeSourceInfo *TInfo =
9213  Context.getTrivialTypeSourceInfo(DerivedType, UsingLoc);
9214  FunctionProtoTypeLoc ProtoLoc =
9216 
9218  Context, Derived, UsingLoc, NameInfo, DerivedType,
9219  TInfo, BaseCtor->isExplicit(), /*Inline=*/true,
9220  /*ImplicitlyDeclared=*/true, /*Constexpr=*/BaseCtor->isConstexpr());
9221 
9222  // Build an unevaluated exception specification for this constructor.
9223  const FunctionProtoType *FPT = DerivedType->castAs<FunctionProtoType>();
9224  FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
9226  EPI.ExceptionSpec.SourceDecl = DerivedCtor;
9227  DerivedCtor->setType(Context.getFunctionType(FPT->getReturnType(),
9228  FPT->getParamTypes(), EPI));
9229 
9230  // Build the parameter declarations.
9231  SmallVector<ParmVarDecl *, 16> ParamDecls;
9232  for (unsigned I = 0, N = FPT->getNumParams(); I != N; ++I) {
9233  TypeSourceInfo *TInfo =
9234  Context.getTrivialTypeSourceInfo(FPT->getParamType(I), UsingLoc);
9236  Context, DerivedCtor, UsingLoc, UsingLoc, /*IdentifierInfo=*/nullptr,
9237  FPT->getParamType(I), TInfo, SC_None, /*DefaultArg=*/nullptr);
9238  PD->setScopeInfo(0, I);
9239  PD->setImplicit();
9240  ParamDecls.push_back(PD);
9241  ProtoLoc.setParam(I, PD);
9242  }
9243 
9244  // Set up the new constructor.
9245  DerivedCtor->setAccess(BaseCtor->getAccess());
9246  DerivedCtor->setParams(ParamDecls);
9247  DerivedCtor->setInheritedConstructor(BaseCtor);
9248  if (BaseCtor->isDeleted())
9249  SemaRef.SetDeclDeleted(DerivedCtor, UsingLoc);
9250 
9251  // If this is a constructor template, build the template declaration.
9252  if (TemplateParams) {
9253  FunctionTemplateDecl *DerivedTemplate =
9254  FunctionTemplateDecl::Create(SemaRef.Context, Derived, UsingLoc, Name,
9255  TemplateParams, DerivedCtor);
9256  DerivedTemplate->setAccess(BaseCtor->getAccess());
9257  DerivedCtor->setDescribedFunctionTemplate(DerivedTemplate);
9258  Derived->addDecl(DerivedTemplate);
9259  } else {
9260  Derived->addDecl(DerivedCtor);
9261  }
9262 
9263  Entry.BaseCtor = BaseCtor;
9264  Entry.DerivedCtor = DerivedCtor;
9265  }
9266 
9267  Sema &SemaRef;
9268  CXXRecordDecl *Derived;
9269  typedef llvm::DenseMap<const Type *, InheritingConstructorsForType> MapType;
9270  MapType Map;
9271 };
9272 }
9273 
9275  // Defer declaring the inheriting constructors until the class is
9276  // instantiated.
9277  if (ClassDecl->isDependentContext())
9278  return;
9279 
9280  // Find base classes from which we might inherit constructors.
9281  SmallVector<CXXRecordDecl*, 4> InheritedBases;
9282  for (const auto &BaseIt : ClassDecl->bases())
9283  if (BaseIt.getInheritConstructors())
9284  InheritedBases.push_back(BaseIt.getType()->getAsCXXRecordDecl());
9285 
9286  // Go no further if we're not inheriting any constructors.
9287  if (InheritedBases.empty())
9288  return;
9289 
9290  // Declare the inherited constructors.
9291  InheritingConstructorInfo ICI(*this, ClassDecl);
9292  for (unsigned I = 0, N = InheritedBases.size(); I != N; ++I)
9293  ICI.inheritAll(InheritedBases[I]);
9294 }
9295 
9297  CXXConstructorDecl *Constructor) {
9298  CXXRecordDecl *ClassDecl = Constructor->getParent();
9299  assert(Constructor->getInheritedConstructor() &&
9300  !Constructor->doesThisDeclarationHaveABody() &&
9301  !Constructor->isDeleted());
9302 
9303  SynthesizedFunctionScope Scope(*this, Constructor);
9304  DiagnosticErrorTrap Trap(Diags);
9305  if (SetCtorInitializers(Constructor, /*AnyErrors=*/false) ||
9306  Trap.hasErrorOccurred()) {
9307  Diag(CurrentLocation, diag::note_inhctor_synthesized_at)
9308  << Context.getTagDeclType(ClassDecl);
9309  Constructor->setInvalidDecl();
9310  return;
9311  }
9312 
9313  SourceLocation Loc = Constructor->getLocation();
9314  Constructor->setBody(new (Context) CompoundStmt(Loc));
9315 
9316  Constructor->markUsed(Context);
9317  MarkVTableUsed(CurrentLocation, ClassDecl);
9318 
9320  L->CompletedImplicitDefinition(Constructor);
9321  }
9322 }
9323 
9324 
9327  CXXRecordDecl *ClassDecl = MD->getParent();
9328 
9329  // C++ [except.spec]p14:
9330  // An implicitly declared special member function (Clause 12) shall have
9331  // an exception-specification.
9332  ImplicitExceptionSpecification ExceptSpec(*this);
9333  if (ClassDecl->isInvalidDecl())
9334  return ExceptSpec;
9335 
9336  // Direct base-class destructors.
9337  for (const auto &B : ClassDecl->bases()) {
9338  if (B.isVirtual()) // Handled below.
9339  continue;
9340 
9341  if (const RecordType *BaseType = B.getType()->getAs<RecordType>())
9342  ExceptSpec.CalledDecl(B.getLocStart(),
9343  LookupDestructor(cast<CXXRecordDecl>(BaseType->getDecl())));
9344  }
9345 
9346  // Virtual base-class destructors.
9347  for (const auto &B : ClassDecl->vbases()) {
9348  if (const RecordType *BaseType = B.getType()->getAs<RecordType>())
9349  ExceptSpec.CalledDecl(B.getLocStart(),
9350  LookupDestructor(cast<CXXRecordDecl>(BaseType->getDecl())));
9351  }
9352 
9353  // Field destructors.
9354  for (const auto *F : ClassDecl->fields()) {
9355  if (const RecordType *RecordTy
9356  = Context.getBaseElementType(F->getType())->getAs<RecordType>())
9357  ExceptSpec.CalledDecl(F->getLocation(),
9358  LookupDestructor(cast<CXXRecordDecl>(RecordTy->getDecl())));
9359  }
9360 
9361  return ExceptSpec;
9362 }
9363 
9365  // C++ [class.dtor]p2:
9366  // If a class has no user-declared destructor, a destructor is
9367  // declared implicitly. An implicitly-declared destructor is an
9368  // inline public member of its class.
9369  assert(ClassDecl->needsImplicitDestructor());
9370 
9371  DeclaringSpecialMember DSM(*this, ClassDecl, CXXDestructor);
9372  if (DSM.isAlreadyBeingDeclared())
9373  return nullptr;
9374 
9375  // Create the actual destructor declaration.
9376  CanQualType ClassType
9377  = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
9378  SourceLocation ClassLoc = ClassDecl->getLocation();
9379  DeclarationName Name
9380  = Context.DeclarationNames.getCXXDestructorName(ClassType);
9381  DeclarationNameInfo NameInfo(Name, ClassLoc);
9382  CXXDestructorDecl *Destructor
9383  = CXXDestructorDecl::Create(Context, ClassDecl, ClassLoc, NameInfo,
9384  QualType(), nullptr, /*isInline=*/true,
9385  /*isImplicitlyDeclared=*/true);
9386  Destructor->setAccess(AS_public);
9387  Destructor->setDefaulted();
9388 
9389  if (getLangOpts().CUDA) {
9391  Destructor,
9392  /* ConstRHS */ false,
9393  /* Diagnose */ false);
9394  }
9395 
9396  // Build an exception specification pointing back at this destructor.
9397  FunctionProtoType::ExtProtoInfo EPI = getImplicitMethodEPI(*this, Destructor);
9398  Destructor->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
9399 
9400  AddOverriddenMethods(ClassDecl, Destructor);
9401 
9402  // We don't need to use SpecialMemberIsTrivial here; triviality for
9403  // destructors is easy to compute.
9404  Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
9405 
9406  if (ShouldDeleteSpecialMember(Destructor, CXXDestructor))
9407  SetDeclDeleted(Destructor, ClassLoc);
9408 
9409  // Note that we have declared this destructor.
9411 
9412  // Introduce this destructor into its scope.
9413  if (Scope *S = getScopeForContext(ClassDecl))
9414  PushOnScopeChains(Destructor, S, false);
9415  ClassDecl->addDecl(Destructor);
9416 
9417  return Destructor;
9418 }
9419 
9421  CXXDestructorDecl *Destructor) {
9422  assert((Destructor->isDefaulted() &&
9423  !Destructor->doesThisDeclarationHaveABody() &&
9424  !Destructor->isDeleted()) &&
9425  "DefineImplicitDestructor - call it for implicit default dtor");
9426  CXXRecordDecl *ClassDecl = Destructor->getParent();
9427  assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
9428 
9429  if (Destructor->isInvalidDecl())
9430  return;
9431 
9432  SynthesizedFunctionScope Scope(*this, Destructor);
9433 
9434  DiagnosticErrorTrap Trap(Diags);
9436  Destructor->getParent());
9437 
9438  if (CheckDestructor(Destructor) || Trap.hasErrorOccurred()) {
9439  Diag(CurrentLocation, diag::note_member_synthesized_at)
9440  << CXXDestructor << Context.getTagDeclType(ClassDecl);
9441 
9442  Destructor->setInvalidDecl();
9443  return;
9444  }
9445 
9446  // The exception specification is needed because we are defining the
9447  // function.
9448  ResolveExceptionSpec(CurrentLocation,
9449  Destructor->getType()->castAs<FunctionProtoType>());
9450 
9451  SourceLocation Loc = Destructor->getLocEnd().isValid()
9452  ? Destructor->getLocEnd()
9453  : Destructor->getLocation();
9454  Destructor->setBody(new (Context) CompoundStmt(Loc));
9455  Destructor->markUsed(Context);
9456  MarkVTableUsed(CurrentLocation, ClassDecl);
9457 
9459  L->CompletedImplicitDefinition(Destructor);
9460  }
9461 }
9462 
9463 /// \brief Perform any semantic analysis which needs to be delayed until all
9464 /// pending class member declarations have been parsed.
9466  // If the context is an invalid C++ class, just suppress these checks.
9467  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(CurContext)) {
9468  if (Record->isInvalidDecl()) {
9471  return;
9472  }
9473  }
9474 }
9475 
9477  // Don't do anything for template patterns.
9478  if (Class->getDescribedClassTemplate())
9479  return;
9480 
9481  CallingConv ExpectedCallingConv = S.Context.getDefaultCallingConvention(
9482  /*IsVariadic=*/false, /*IsCXXMethod=*/true);
9483 
9484  CXXConstructorDecl *LastExportedDefaultCtor = nullptr;
9485  for (Decl *Member : Class->decls()) {
9486  auto *CD = dyn_cast<CXXConstructorDecl>(Member);
9487  if (!CD) {
9488  // Recurse on nested classes.
9489  if (auto *NestedRD = dyn_cast<CXXRecordDecl>(Member))
9490  getDefaultArgExprsForConstructors(S, NestedRD);
9491  continue;
9492  } else if (!CD->isDefaultConstructor() || !CD->hasAttr<DLLExportAttr>()) {
9493  continue;
9494  }
9495 
9496  CallingConv ActualCallingConv =
9497  CD->getType()->getAs<FunctionProtoType>()->getCallConv();
9498 
9499  // Skip default constructors with typical calling conventions and no default
9500  // arguments.
9501  unsigned NumParams = CD->getNumParams();
9502  if (ExpectedCallingConv == ActualCallingConv && NumParams == 0)
9503  continue;
9504 
9505  if (LastExportedDefaultCtor) {
9506  S.Diag(LastExportedDefaultCtor->getLocation(),
9507  diag::err_attribute_dll_ambiguous_default_ctor) << Class;
9508  S.Diag(CD->getLocation(), diag::note_entity_declared_at)
9509  << CD->getDeclName();
9510  return;
9511  }
9512  LastExportedDefaultCtor = CD;
9513 
9514  for (unsigned I = 0; I != NumParams; ++I) {
9515  // Skip any default arguments that we've already instantiated.
9517  continue;
9518 
9519  Expr *DefaultArg = S.BuildCXXDefaultArgExpr(Class->getLocation(), CD,
9520  CD->getParamDecl(I)).get();
9522  S.Context.addDefaultArgExprForConstructor(CD, I, DefaultArg);
9523  }
9524  }
9525 }
9526 
9528  auto *RD = dyn_cast<CXXRecordDecl>(D);
9529 
9530  // Default constructors that are annotated with __declspec(dllexport) which
9531  // have default arguments or don't use the standard calling convention are
9532  // wrapped with a thunk called the default constructor closure.
9533  if (RD && Context.getTargetInfo().getCXXABI().isMicrosoft())
9535 
9536  if (!DelayedDllExportClasses.empty()) {
9537  // Calling ReferenceDllExportedMethods might cause the current function to
9538  // be called again, so use a local copy of DelayedDllExportClasses.
9540  std::swap(DelayedDllExportClasses, WorkList);
9541  for (CXXRecordDecl *Class : WorkList)
9542  ReferenceDllExportedMethods(*this, Class);
9543  }
9544 }
9545 
9547  CXXDestructorDecl *Destructor) {
9548  assert(getLangOpts().CPlusPlus11 &&
9549  "adjusting dtor exception specs was introduced in c++11");
9550 
9551  // C++11 [class.dtor]p3:
9552  // A declaration of a destructor that does not have an exception-
9553  // specification is implicitly considered to have the same exception-
9554  // specification as an implicit declaration.
9555  const FunctionProtoType *DtorType = Destructor->getType()->
9556  getAs<FunctionProtoType>();
9557  if (DtorType->hasExceptionSpec())
9558  return;
9559 
9560  // Replace the destructor's type, building off the existing one. Fortunately,
9561  // the only thing of interest in the destructor type is its extended info.
9562  // The return and arguments are fixed.
9565  EPI.ExceptionSpec.SourceDecl = Destructor;
9566  Destructor->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
9567 
9568  // FIXME: If the destructor has a body that could throw, and the newly created
9569  // spec doesn't allow exceptions, we should emit a warning, because this
9570  // change in behavior can break conforming C++03 programs at runtime.
9571  // However, we don't have a body or an exception specification yet, so it
9572  // needs to be done somewhere else.
9573 }
9574 
9575 namespace {
9576 /// \brief An abstract base class for all helper classes used in building the
9577 // copy/move operators. These classes serve as factory functions and help us
9578 // avoid using the same Expr* in the AST twice.
9579 class ExprBuilder {
9580  ExprBuilder(const ExprBuilder&) = delete;
9581  ExprBuilder &operator=(const ExprBuilder&) = delete;
9582 
9583 protected:
9584  static Expr *assertNotNull(Expr *E) {
9585  assert(E && "Expression construction must not fail.");
9586  return E;
9587  }
9588 
9589 public:
9590  ExprBuilder() {}
9591  virtual ~ExprBuilder() {}
9592 
9593  virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
9594 };
9595 
9596 class RefBuilder: public ExprBuilder {
9597  VarDecl *Var;
9598  QualType VarType;
9599 
9600 public:
9601  Expr *build(Sema &S, SourceLocation Loc) const override {
9602  return assertNotNull(S.BuildDeclRefExpr(Var, VarType, VK_LValue, Loc).get());
9603  }
9604 
9605  RefBuilder(VarDecl *Var, QualType VarType)
9606  : Var(Var), VarType(VarType) {}
9607 };
9608 
9609 class ThisBuilder: public ExprBuilder {
9610 public:
9611  Expr *build(Sema &S, SourceLocation Loc) const override {
9612  return assertNotNull(S.ActOnCXXThis(Loc).getAs<Expr>());
9613  }
9614 };
9615 
9616 class CastBuilder: public ExprBuilder {
9617  const ExprBuilder &Builder;
9618  QualType Type;
9620  const CXXCastPath &Path;
9621 
9622 public:
9623  Expr *build(Sema &S, SourceLocation Loc) const override {
9624  return assertNotNull(S.ImpCastExprToType(Builder.build(S, Loc), Type,
9626  &Path).get());
9627  }
9628 
9629  CastBuilder(const ExprBuilder &Builder, QualType Type, ExprValueKind Kind,
9630  const CXXCastPath &Path)
9631  : Builder(Builder), Type(Type), Kind(Kind), Path(Path) {}
9632 };
9633 
9634 class DerefBuilder: public ExprBuilder {
9635  const ExprBuilder &Builder;
9636 
9637 public:
9638  Expr *build(Sema &S, SourceLocation Loc) const override {
9639  return assertNotNull(
9640  S.CreateBuiltinUnaryOp(Loc, UO_Deref, Builder.build(S, Loc)).get());
9641  }
9642 
9643  DerefBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9644 };
9645 
9646 class MemberBuilder: public ExprBuilder {
9647  const ExprBuilder &Builder;
9648  QualType Type;
9649  CXXScopeSpec SS;
9650  bool IsArrow;
9651  LookupResult &MemberLookup;
9652 
9653 public:
9654  Expr *build(Sema &S, SourceLocation Loc) const override {
9655  return assertNotNull(S.BuildMemberReferenceExpr(
9656  Builder.build(S, Loc), Type, Loc, IsArrow, SS, SourceLocation(),
9657  nullptr, MemberLookup, nullptr, nullptr).get());
9658  }
9659 
9660  MemberBuilder(const ExprBuilder &Builder, QualType Type, bool IsArrow,
9661  LookupResult &MemberLookup)
9662  : Builder(Builder), Type(Type), IsArrow(IsArrow),
9663  MemberLookup(MemberLookup) {}
9664 };
9665 
9666 class MoveCastBuilder: public ExprBuilder {
9667  const ExprBuilder &Builder;
9668 
9669 public:
9670  Expr *build(Sema &S, SourceLocation Loc) const override {
9671  return assertNotNull(CastForMoving(S, Builder.build(S, Loc)));
9672  }
9673 
9674  MoveCastBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9675 };
9676 
9677 class LvalueConvBuilder: public ExprBuilder {
9678  const ExprBuilder &Builder;
9679 
9680 public:
9681  Expr *build(Sema &S, SourceLocation Loc) const override {
9682  return assertNotNull(
9683  S.DefaultLvalueConversion(Builder.build(S, Loc)).get());
9684  }
9685 
9686  LvalueConvBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9687 };
9688 
9689 class SubscriptBuilder: public ExprBuilder {
9690  const ExprBuilder &Base;
9691  const ExprBuilder &Index;
9692 
9693 public:
9694  Expr *build(Sema &S, SourceLocation Loc) const override {
9695  return assertNotNull(S.CreateBuiltinArraySubscriptExpr(
9696  Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).get());
9697  }
9698 
9699  SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index)
9700  : Base(Base), Index(Index) {}
9701 };
9702 
9703 } // end anonymous namespace
9704 
9705 /// When generating a defaulted copy or move assignment operator, if a field
9706 /// should be copied with __builtin_memcpy rather than via explicit assignments,
9707 /// do so. This optimization only applies for arrays of scalars, and for arrays
9708 /// of class type where the selected copy/move-assignment operator is trivial.
9709 static StmtResult
9711  const ExprBuilder &ToB, const ExprBuilder &FromB) {
9712  // Compute the size of the memory buffer to be copied.
9713  QualType SizeType = S.Context.getSizeType();
9714  llvm::APInt Size(S.Context.getTypeSize(SizeType),
9716 
9717  // Take the address of the field references for "from" and "to". We
9718  // directly construct UnaryOperators here because semantic analysis
9719  // does not permit us to take the address of an xvalue.
9720  Expr *From = FromB.build(S, Loc);
9721  From = new (S.Context) UnaryOperator(From, UO_AddrOf,
9722  S.Context.getPointerType(From->getType()),
9723  VK_RValue, OK_Ordinary, Loc);
9724  Expr *To = ToB.build(S, Loc);
9725  To = new (S.Context) UnaryOperator(To, UO_AddrOf,
9726  S.Context.getPointerType(To->getType()),
9727  VK_RValue, OK_Ordinary, Loc);
9728 
9729  const Type *E = T->getBaseElementTypeUnsafe();
9730  bool NeedsCollectableMemCpy =
9731  E->isRecordType() && E->getAs<RecordType>()->getDecl()->hasObjectMember();
9732 
9733  // Create a reference to the __builtin_objc_memmove_collectable function
9734  StringRef MemCpyName = NeedsCollectableMemCpy ?
9735  "__builtin_objc_memmove_collectable" :
9736  "__builtin_memcpy";
9737  LookupResult R(S, &S.Context.Idents.get(MemCpyName), Loc,
9739  S.LookupName(R, S.TUScope, true);
9740 
9741  FunctionDecl *MemCpy = R.getAsSingle<FunctionDecl>();
9742  if (!MemCpy)
9743  // Something went horribly wrong earlier, and we will have complained
9744  // about it.
9745  return StmtError();
9746 
9747  ExprResult MemCpyRef = S.BuildDeclRefExpr(MemCpy, S.Context.BuiltinFnTy,
9748  VK_RValue, Loc, nullptr);
9749  assert(MemCpyRef.isUsable() && "Builtin reference cannot fail");
9750 
9751  Expr *CallArgs[] = {
9752  To, From, IntegerLiteral::Create(S.Context, Size, SizeType, Loc)
9753  };
9754  ExprResult Call = S.ActOnCallExpr(/*Scope=*/nullptr, MemCpyRef.get(),
9755  Loc, CallArgs, Loc);
9756 
9757  assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!");
9758  return Call.getAs<Stmt>();
9759 }
9760 
9761 /// \brief Builds a statement that copies/moves the given entity from \p From to
9762 /// \c To.
9763 ///
9764 /// This routine is used to copy/move the members of a class with an
9765 /// implicitly-declared copy/move assignment operator. When the entities being
9766 /// copied are arrays, this routine builds for loops to copy them.
9767 ///
9768 /// \param S The Sema object used for type-checking.
9769 ///
9770 /// \param Loc The location where the implicit copy/move is being generated.
9771 ///
9772 /// \param T The type of the expressions being copied/moved. Both expressions
9773 /// must have this type.
9774 ///
9775 /// \param To The expression we are copying/moving to.
9776 ///
9777 /// \param From The expression we are copying/moving from.
9778 ///
9779 /// \param CopyingBaseSubobject Whether we're copying/moving a base subobject.
9780 /// Otherwise, it's a non-static member subobject.
9781 ///
9782 /// \param Copying Whether we're copying or moving.
9783 ///
9784 /// \param Depth Internal parameter recording the depth of the recursion.
9785 ///
9786 /// \returns A statement or a loop that copies the expressions, or StmtResult(0)
9787 /// if a memcpy should be used instead.
9788 static StmtResult
9790  const ExprBuilder &To, const ExprBuilder &From,
9791  bool CopyingBaseSubobject, bool Copying,
9792  unsigned Depth = 0) {
9793  // C++11 [class.copy]p28:
9794  // Each subobject is assigned in the manner appropriate to its type:
9795  //
9796  // - if the subobject is of class type, as if by a call to operator= with
9797  // the subobject as the object expression and the corresponding
9798  // subobject of x as a single function argument (as if by explicit
9799  // qualification; that is, ignoring any possible virtual overriding
9800  // functions in more derived classes);
9801  //
9802  // C++03 [class.copy]p13:
9803  // - if the subobject is of class type, the copy assignment operator for
9804  // the class is used (as if by explicit qualification; that is,
9805  // ignoring any possible virtual overriding functions in more derived
9806  // classes);
9807  if (const RecordType *RecordTy = T->getAs<RecordType>()) {
9808  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
9809 
9810  // Look for operator=.
9811  DeclarationName Name
9813  LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName);
9814  S.LookupQualifiedName(OpLookup, ClassDecl, false);
9815 
9816  // Prior to C++11, filter out any result that isn't a copy/move-assignment
9817  // operator.
9818  if (!S.getLangOpts().CPlusPlus11) {
9819  LookupResult::Filter F = OpLookup.makeFilter();
9820  while (F.hasNext()) {
9821  NamedDecl *D = F.next();
9822  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
9823  if (Method->isCopyAssignmentOperator() ||
9824  (!Copying && Method->isMoveAssignmentOperator()))
9825  continue;
9826 
9827  F.erase();
9828  }
9829  F.done();
9830  }
9831 
9832  // Suppress the protected check (C++ [class.protected]) for each of the
9833  // assignment operators we found. This strange dance is required when
9834  // we're assigning via a base classes's copy-assignment operator. To
9835  // ensure that we're getting the right base class subobject (without
9836  // ambiguities), we need to cast "this" to that subobject type; to
9837  // ensure that we don't go through the virtual call mechanism, we need
9838  // to qualify the operator= name with the base class (see below). However,
9839  // this means that if the base class has a protected copy assignment
9840  // operator, the protected member access check will fail. So, we
9841  // rewrite "protected" access to "public" access in this case, since we
9842  // know by construction that we're calling from a derived class.
9843  if (CopyingBaseSubobject) {
9844  for (LookupResult::iterator L = OpLookup.begin(), LEnd = OpLookup.end();
9845  L != LEnd; ++L) {
9846  if (L.getAccess() == AS_protected)
9847  L.setAccess(AS_public);
9848  }
9849  }
9850 
9851  // Create the nested-name-specifier that will be used to qualify the
9852  // reference to operator=; this is required to suppress the virtual
9853  // call mechanism.
9854  CXXScopeSpec SS;
9855  const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
9856  SS.MakeTrivial(S.Context,
9857  NestedNameSpecifier::Create(S.Context, nullptr, false,
9858  CanonicalT),
9859  Loc);
9860 
9861  // Create the reference to operator=.
9862  ExprResult OpEqualRef
9863  = S.BuildMemberReferenceExpr(To.build(S, Loc), T, Loc, /*isArrow=*/false,
9864  SS, /*TemplateKWLoc=*/SourceLocation(),
9865  /*FirstQualifierInScope=*/nullptr,
9866  OpLookup,
9867  /*TemplateArgs=*/nullptr, /*S*/nullptr,
9868  /*SuppressQualifierCheck=*/true);
9869  if (OpEqualRef.isInvalid())
9870  return StmtError();
9871 
9872  // Build the call to the assignment operator.
9873 
9874  Expr *FromInst = From.build(S, Loc);
9875  ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/nullptr,
9876  OpEqualRef.getAs<Expr>(),
9877  Loc, FromInst, Loc);
9878  if (Call.isInvalid())
9879  return StmtError();
9880 
9881  // If we built a call to a trivial 'operator=' while copying an array,
9882  // bail out. We'll replace the whole shebang with a memcpy.
9883  CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(Call.get());
9884  if (CE && CE->getMethodDecl()->isTrivial() && Depth)
9885  return StmtResult((Stmt*)nullptr);
9886 
9887  // Convert to an expression-statement, and clean up any produced
9888  // temporaries.
9889  return S.ActOnExprStmt(Call);
9890  }
9891 
9892  // - if the subobject is of scalar type, the built-in assignment
9893  // operator is used.
9894  const ConstantArrayType *ArrayTy = S.Context.getAsConstantArrayType(T);
9895  if (!ArrayTy) {
9897  Loc, BO_Assign, To.build(S, Loc), From.build(S, Loc));
9898  if (Assignment.isInvalid())
9899  return StmtError();
9900  return S.ActOnExprStmt(Assignment);
9901  }
9902 
9903  // - if the subobject is an array, each element is assigned, in the
9904  // manner appropriate to the element type;
9905 
9906  // Construct a loop over the array bounds, e.g.,
9907  //
9908  // for (__SIZE_TYPE__ i0 = 0; i0 != array-size; ++i0)
9909  //
9910  // that will copy each of the array elements.
9911  QualType SizeType = S.Context.getSizeType();
9912 
9913  // Create the iteration variable.
9914  IdentifierInfo *IterationVarName = nullptr;
9915  {
9916  SmallString<8> Str;
9917  llvm::raw_svector_ostream OS(Str);
9918  OS << "__i" << Depth;
9919  IterationVarName = &S.Context.Idents.get(OS.str());
9920  }
9921  VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
9922  IterationVarName, SizeType,
9923  S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
9924  SC_None);
9925 
9926  // Initialize the iteration variable to zero.
9927  llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
9928  IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
9929 
9930  // Creates a reference to the iteration variable.
9931  RefBuilder IterationVarRef(IterationVar, SizeType);
9932  LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
9933 
9934  // Create the DeclStmt that holds the iteration variable.
9935  Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);
9936 
9937  // Subscript the "from" and "to" expressions with the iteration variable.
9938  SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
9939  MoveCastBuilder FromIndexMove(FromIndexCopy);
9940  const ExprBuilder *FromIndex;
9941  if (Copying)
9942  FromIndex = &FromIndexCopy;
9943  else
9944  FromIndex = &FromIndexMove;
9945 
9946  SubscriptBuilder ToIndex(To, IterationVarRefRVal);
9947 
9948  // Build the copy/move for an individual element of the array.
9949  StmtResult Copy =
9951  ToIndex, *FromIndex, CopyingBaseSubobject,
9952  Copying, Depth + 1);
9953  // Bail out if copying fails or if we determined that we should use memcpy.
9954  if (Copy.isInvalid() || !Copy.get())
9955  return Copy;
9956 
9957  // Create the comparison against the array bound.
9958  llvm::APInt Upper
9959  = ArrayTy->getSize().zextOrTrunc(S.Context.getTypeSize(SizeType));
9960  Expr *Comparison
9961  = new (S.Context) BinaryOperator(IterationVarRefRVal.build(S, Loc),
9962  IntegerLiteral::Create(S.Context, Upper, SizeType, Loc),
9963  BO_NE, S.Context.BoolTy,
9964  VK_RValue, OK_Ordinary, Loc, false);
9965 
9966  // Create the pre-increment of the iteration variable.
9967  Expr *Increment
9968  = new (S.Context) UnaryOperator(IterationVarRef.build(S, Loc), UO_PreInc,
9969  SizeType, VK_LValue, OK_Ordinary, Loc);
9970 
9971  // Construct the loop that copies all elements of this array.
9972  return S.ActOnForStmt(Loc, Loc, InitStmt,
9973  S.MakeFullExpr(Comparison),
9974  nullptr, S.MakeFullDiscardedValueExpr(Increment),
9975  Loc, Copy.get());
9976 }
9977 
9978 static StmtResult
9980  const ExprBuilder &To, const ExprBuilder &From,
9981  bool CopyingBaseSubobject, bool Copying) {
9982  // Maybe we should use a memcpy?
9983  if (T->isArrayType() && !T.isConstQualified() && !T.isVolatileQualified() &&
9985  return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
9986 
9988  CopyingBaseSubobject,
9989  Copying, 0));
9990 
9991  // If we ended up picking a trivial assignment operator for an array of a
9992  // non-trivially-copyable class type, just emit a memcpy.
9993  if (!Result.isInvalid() && !Result.get())
9994  return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
9995 
9996  return Result;
9997 }
9998 
10001  CXXRecordDecl *ClassDecl = MD->getParent();
10002 
10003  ImplicitExceptionSpecification ExceptSpec(*this);
10004  if (ClassDecl->isInvalidDecl())
10005  return ExceptSpec;
10006 
10007  const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
10008  assert(T->getNumParams() == 1 && "not a copy assignment op");
10009  unsigned ArgQuals =
10011 
10012  // C++ [except.spec]p14:
10013  // An implicitly declared special member function (Clause 12) shall have an
10014  // exception-specification. [...]
10015 
10016  // It is unspecified whether or not an implicit copy assignment operator
10017  // attempts to deduplicate calls to assignment operators of virtual bases are
10018  // made. As such, this exception specification is effectively unspecified.
10019  // Based on a similar decision made for constness in C++0x, we're erring on
10020  // the side of assuming such calls to be made regardless of whether they
10021  // actually happen.
10022  for (const auto &Base : ClassDecl->bases()) {
10023  if (Base.isVirtual())
10024  continue;
10025 
10026  CXXRecordDecl *BaseClassDecl
10027  = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
10028  if (CXXMethodDecl *CopyAssign = LookupCopyingAssignment(BaseClassDecl,
10029  ArgQuals, false, 0))
10030  ExceptSpec.CalledDecl(Base.getLocStart(), CopyAssign);
10031  }
10032 
10033  for (const auto &Base : ClassDecl->vbases()) {
10034  CXXRecordDecl *BaseClassDecl
10035  = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
10036  if (CXXMethodDecl *CopyAssign = LookupCopyingAssignment(BaseClassDecl,
10037  ArgQuals, false, 0))
10038  ExceptSpec.CalledDecl(Base.getLocStart(), CopyAssign);
10039  }
10040 
10041  for (const auto *Field : ClassDecl->fields()) {
10042  QualType FieldType = Context.getBaseElementType(Field->getType());
10043  if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
10044  if (CXXMethodDecl *CopyAssign =
10045  LookupCopyingAssignment(FieldClassDecl,
10046  ArgQuals | FieldType.getCVRQualifiers(),
10047  false, 0))
10048  ExceptSpec.CalledDecl(Field->getLocation(), CopyAssign);
10049  }
10050  }
10051 
10052  return ExceptSpec;
10053 }
10054 
10056  // Note: The following rules are largely analoguous to the copy
10057  // constructor rules. Note that virtual bases are not taken into account
10058  // for determining the argument type of the operator. Note also that
10059  // operators taking an object instead of a reference are allowed.
10060  assert(ClassDecl->needsImplicitCopyAssignment());
10061 
10062  DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyAssignment);
10063  if (DSM.isAlreadyBeingDeclared())
10064  return nullptr;
10065 
10066  QualType ArgType = Context.getTypeDeclType(ClassDecl);
10067  QualType RetType = Context.getLValueReferenceType(ArgType);
10068  bool Const = ClassDecl->implicitCopyAssignmentHasConstParam();
10069  if (Const)
10070  ArgType = ArgType.withConst();
10071  ArgType = Context.getLValueReferenceType(ArgType);
10072 
10073  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
10075  Const);
10076 
10077  // An implicitly-declared copy assignment operator is an inline public
10078  // member of its class.
10079  DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
10080  SourceLocation ClassLoc = ClassDecl->getLocation();
10081  DeclarationNameInfo NameInfo(Name, ClassLoc);
10082  CXXMethodDecl *CopyAssignment =
10083  CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
10084  /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
10085  /*isInline=*/true, Constexpr, SourceLocation());
10086  CopyAssignment->setAccess(AS_public);
10087  CopyAssignment->setDefaulted();
10088  CopyAssignment->setImplicit();
10089 
10090  if (getLangOpts().CUDA) {
10092  CopyAssignment,
10093  /* ConstRHS */ Const,
10094  /* Diagnose */ false);
10095  }
10096 
10097  // Build an exception specification pointing back at this member.
10099  getImplicitMethodEPI(*this, CopyAssignment);
10100  CopyAssignment->setType(Context.getFunctionType(RetType, ArgType, EPI));
10101 
10102  // Add the parameter to the operator.
10103  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
10104  ClassLoc, ClassLoc,
10105  /*Id=*/nullptr, ArgType,
10106  /*TInfo=*/nullptr, SC_None,
10107  nullptr);
10108  CopyAssignment->setParams(FromParam);
10109 
10110  AddOverriddenMethods(ClassDecl, CopyAssignment);
10111 
10112  CopyAssignment->setTrivial(
10114  ? SpecialMemberIsTrivial(CopyAssignment, CXXCopyAssignment)
10115  : ClassDecl->hasTrivialCopyAssignment());
10116 
10117  if (ShouldDeleteSpecialMember(CopyAssignment, CXXCopyAssignment))
10118  SetDeclDeleted(CopyAssignment, ClassLoc);
10119 
10120  // Note that we have added this copy-assignment operator.
10122 
10123  if (Scope *S = getScopeForContext(ClassDecl))
10124  PushOnScopeChains(CopyAssignment, S, false);
10125  ClassDecl->addDecl(CopyAssignment);
10126 
10127  return CopyAssignment;
10128 }
10129 
10130 /// Diagnose an implicit copy operation for a class which is odr-used, but
10131 /// which is deprecated because the class has a user-declared copy constructor,
10132 /// copy assignment operator, or destructor.
10134  SourceLocation UseLoc) {
10135  assert(CopyOp->isImplicit());
10136 
10137  CXXRecordDecl *RD = CopyOp->getParent();
10138  CXXMethodDecl *UserDeclaredOperation = nullptr;
10139 
10140  // In Microsoft mode, assignment operations don't affect constructors and
10141  // vice versa.
10142  if (RD->hasUserDeclaredDestructor()) {
10143  UserDeclaredOperation = RD->getDestructor();
10144  } else if (!isa<CXXConstructorDecl>(CopyOp) &&
10145  RD->hasUserDeclaredCopyConstructor() &&
10146  !S.getLangOpts().MSVCCompat) {
10147  // Find any user-declared copy constructor.
10148  for (auto *I : RD->ctors()) {
10149  if (I->isCopyConstructor()) {
10150  UserDeclaredOperation = I;
10151  break;
10152  }
10153  }
10154  assert(UserDeclaredOperation);
10155  } else if (isa<CXXConstructorDecl>(CopyOp) &&
10156  RD->hasUserDeclaredCopyAssignment() &&
10157  !S.getLangOpts().MSVCCompat) {
10158  // Find any user-declared move assignment operator.
10159  for (auto *I : RD->methods()) {
10160  if (I->isCopyAssignmentOperator()) {
10161  UserDeclaredOperation = I;
10162  break;
10163  }
10164  }
10165  assert(UserDeclaredOperation);
10166  }
10167 
10168  if (UserDeclaredOperation) {
10169  S.Diag(UserDeclaredOperation->getLocation(),
10170  diag::warn_deprecated_copy_operation)
10171  << RD << /*copy assignment*/!isa<CXXConstructorDecl>(CopyOp)
10172  << /*destructor*/isa<CXXDestructorDecl>(UserDeclaredOperation);
10173  S.Diag(UseLoc, diag::note_member_synthesized_at)
10174  << (isa<CXXConstructorDecl>(CopyOp) ? Sema::CXXCopyConstructor
10176  << RD;
10177  }
10178 }
10179 
10181  CXXMethodDecl *CopyAssignOperator) {
10182  assert((CopyAssignOperator->isDefaulted() &&
10183  CopyAssignOperator->isOverloadedOperator() &&
10184  CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
10185  !CopyAssignOperator->doesThisDeclarationHaveABody() &&
10186  !CopyAssignOperator->isDeleted()) &&
10187  "DefineImplicitCopyAssignment called for wrong function");
10188 
10189  CXXRecordDecl *ClassDecl = CopyAssignOperator->getParent();
10190 
10191  if (ClassDecl->isInvalidDecl() || CopyAssignOperator->isInvalidDecl()) {
10192  CopyAssignOperator->setInvalidDecl();
10193  return;
10194  }
10195 
10196  // C++11 [class.copy]p18:
10197  // The [definition of an implicitly declared copy assignment operator] is
10198  // deprecated if the class has a user-declared copy constructor or a
10199  // user-declared destructor.
10200  if (getLangOpts().CPlusPlus11 && CopyAssignOperator->isImplicit())
10201  diagnoseDeprecatedCopyOperation(*this, CopyAssignOperator, CurrentLocation);
10202 
10203  CopyAssignOperator->markUsed(Context);
10204 
10205  SynthesizedFunctionScope Scope(*this, CopyAssignOperator);
10206  DiagnosticErrorTrap Trap(Diags);
10207 
10208  // C++0x [class.copy]p30:
10209  // The implicitly-defined or explicitly-defaulted copy assignment operator
10210  // for a non-union class X performs memberwise copy assignment of its
10211  // subobjects. The direct base classes of X are assigned first, in the
10212  // order of their declaration in the base-specifier-list, and then the
10213  // immediate non-static data members of X are assigned, in the order in
10214  // which they were declared in the class definition.
10215 
10216  // The statements that form the synthesized function body.
10217  SmallVector<Stmt*, 8> Statements;
10218 
10219  // The parameter for the "other" object, which we are copying from.
10220  ParmVarDecl *Other = CopyAssignOperator->getParamDecl(0);
10221  Qualifiers OtherQuals = Other->getType().getQualifiers();
10222  QualType OtherRefType = Other->getType();
10223  if (const LValueReferenceType *OtherRef
10224  = OtherRefType->getAs<LValueReferenceType>()) {
10225  OtherRefType = OtherRef->getPointeeType();
10226  OtherQuals = OtherRefType.getQualifiers();
10227  }
10228 
10229  // Our location for everything implicitly-generated.
10230  SourceLocation Loc = CopyAssignOperator->getLocEnd().isValid()
10231  ? CopyAssignOperator->getLocEnd()
10232  : CopyAssignOperator->getLocation();
10233 
10234  // Builds a DeclRefExpr for the "other" object.
10235  RefBuilder OtherRef(Other, OtherRefType);
10236 
10237  // Builds the "this" pointer.
10238  ThisBuilder This;
10239 
10240  // Assign base classes.
10241  bool Invalid = false;
10242  for (auto &Base : ClassDecl->bases()) {
10243  // Form the assignment:
10244  // static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other));
10245  QualType BaseType = Base.getType().getUnqualifiedType();
10246  if (!BaseType->isRecordType()) {
10247  Invalid = true;
10248  continue;
10249  }
10250 
10251  CXXCastPath BasePath;
10252  BasePath.push_back(&Base);
10253 
10254  // Construct the "from" expression, which is an implicit cast to the
10255  // appropriately-qualified base type.
10256  CastBuilder From(OtherRef, Context.getQualifiedType(BaseType, OtherQuals),
10257  VK_LValue, BasePath);
10258 
10259  // Dereference "this".
10260  DerefBuilder DerefThis(This);
10261  CastBuilder To(DerefThis,
10262  Context.getCVRQualifiedType(
10263  BaseType, CopyAssignOperator->getTypeQualifiers()),
10264  VK_LValue, BasePath);
10265 
10266  // Build the copy.
10267  StmtResult Copy = buildSingleCopyAssign(*this, Loc, BaseType,
10268  To, From,
10269  /*CopyingBaseSubobject=*/true,
10270  /*Copying=*/true);
10271  if (Copy.isInvalid()) {
10272  Diag(CurrentLocation, diag::note_member_synthesized_at)
10273  << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
10274  CopyAssignOperator->setInvalidDecl();
10275  return;
10276  }
10277 
10278  // Success! Record the copy.
10279  Statements.push_back(Copy.getAs<Expr>());
10280  }
10281 
10282  // Assign non-static members.
10283  for (auto *Field : ClassDecl->fields()) {
10284  // FIXME: We should form some kind of AST representation for the implied
10285  // memcpy in a union copy operation.
10286  if (Field->isUnnamedBitfield() || Field->getParent()->isUnion())
10287  continue;
10288 
10289  if (Field->isInvalidDecl()) {
10290  Invalid = true;
10291  continue;
10292  }
10293 
10294  // Check for members of reference type; we can't copy those.
10295  if (Field->getType()->isReferenceType()) {
10296  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
10297  << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
10298  Diag(Field->getLocation(), diag::note_declared_at);
10299  Diag(CurrentLocation, diag::note_member_synthesized_at)
10300  << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
10301  Invalid = true;
10302  continue;
10303  }
10304 
10305  // Check for members of const-qualified, non-class type.
10306  QualType BaseType = Context.getBaseElementType(Field->getType());
10307  if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
10308  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
10309  << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
10310  Diag(Field->getLocation(), diag::note_declared_at);
10311  Diag(CurrentLocation, diag::note_member_synthesized_at)
10312  << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
10313  Invalid = true;
10314  continue;
10315  }
10316 
10317  // Suppress assigning zero-width bitfields.
10318  if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
10319  continue;
10320 
10321  QualType FieldType = Field->getType().getNonReferenceType();
10322  if (FieldType->isIncompleteArrayType()) {
10323  assert(ClassDecl->hasFlexibleArrayMember() &&
10324  "Incomplete array type is not valid");
10325  continue;
10326  }
10327 
10328  // Build references to the field in the object we're copying from and to.
10329  CXXScopeSpec SS; // Intentionally empty
10330  LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
10332  MemberLookup.addDecl(Field);
10333  MemberLookup.resolveKind();
10334 
10335  MemberBuilder From(OtherRef, OtherRefType, /*IsArrow=*/false, MemberLookup);
10336 
10337  MemberBuilder To(This, getCurrentThisType(), /*IsArrow=*/true, MemberLookup);
10338 
10339  // Build the copy of this field.
10340  StmtResult Copy = buildSingleCopyAssign(*this, Loc, FieldType,
10341  To, From,
10342  /*CopyingBaseSubobject=*/false,
10343  /*Copying=*/true);
10344  if (Copy.isInvalid()) {
10345  Diag(CurrentLocation, diag::note_member_synthesized_at)
10346  << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
10347  CopyAssignOperator->setInvalidDecl();
10348  return;
10349  }
10350 
10351  // Success! Record the copy.
10352  Statements.push_back(Copy.getAs<Stmt>());
10353  }
10354 
10355  if (!Invalid) {
10356  // Add a "return *this;"
10357  ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
10358 
10359  StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
10360  if (Return.isInvalid())
10361  Invalid = true;
10362  else {
10363  Statements.push_back(Return.getAs<Stmt>());
10364 
10365  if (Trap.hasErrorOccurred()) {
10366  Diag(CurrentLocation, diag::note_member_synthesized_at)
10367  << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
10368  Invalid = true;
10369  }
10370  }
10371  }
10372 
10373  // The exception specification is needed because we are defining the
10374  // function.
10375  ResolveExceptionSpec(CurrentLocation,
10376  CopyAssignOperator->getType()->castAs<FunctionProtoType>());
10377 
10378  if (Invalid) {
10379  CopyAssignOperator->setInvalidDecl();
10380  return;
10381  }
10382 
10383  StmtResult Body;
10384  {
10385  CompoundScopeRAII CompoundScope(*this);
10386  Body = ActOnCompoundStmt(Loc, Loc, Statements,
10387  /*isStmtExpr=*/false);
10388  assert(!Body.isInvalid() && "Compound statement creation cannot fail");
10389  }
10390  CopyAssignOperator->setBody(Body.getAs<Stmt>());
10391 
10393  L->CompletedImplicitDefinition(CopyAssignOperator);
10394  }
10395 }
10396 
10399  CXXRecordDecl *ClassDecl = MD->getParent();
10400 
10401  ImplicitExceptionSpecification ExceptSpec(*this);
10402  if (ClassDecl->isInvalidDecl())
10403  return ExceptSpec;
10404 
10405  // C++0x [except.spec]p14:
10406  // An implicitly declared special member function (Clause 12) shall have an
10407  // exception-specification. [...]
10408 
10409  // It is unspecified whether or not an implicit move assignment operator
10410  // attempts to deduplicate calls to assignment operators of virtual bases are
10411  // made. As such, this exception specification is effectively unspecified.
10412  // Based on a similar decision made for constness in C++0x, we're erring on
10413  // the side of assuming such calls to be made regardless of whether they
10414  // actually happen.
10415  // Note that a move constructor is not implicitly declared when there are
10416  // virtual bases, but it can still be user-declared and explicitly defaulted.
10417  for (const auto &Base : ClassDecl->bases()) {
10418  if (Base.isVirtual())
10419  continue;
10420 
10421  CXXRecordDecl *BaseClassDecl
10422  = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
10423  if (CXXMethodDecl *MoveAssign = LookupMovingAssignment(BaseClassDecl,
10424  0, false, 0))
10425  ExceptSpec.CalledDecl(Base.getLocStart(), MoveAssign);
10426  }
10427 
10428  for (const auto &Base : ClassDecl->vbases()) {
10429  CXXRecordDecl *BaseClassDecl
10430  = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
10431  if (CXXMethodDecl *MoveAssign = LookupMovingAssignment(BaseClassDecl,
10432  0, false, 0))
10433  ExceptSpec.CalledDecl(Base.getLocStart(), MoveAssign);
10434  }
10435 
10436  for (const auto *Field : ClassDecl->fields()) {
10437  QualType FieldType = Context.getBaseElementType(Field->getType());
10438  if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
10439  if (CXXMethodDecl *MoveAssign =
10440  LookupMovingAssignment(FieldClassDecl,
10441  FieldType.getCVRQualifiers(),
10442  false, 0))
10443  ExceptSpec.CalledDecl(Field->getLocation(), MoveAssign);
10444  }
10445  }
10446 
10447  return ExceptSpec;
10448 }
10449 
10451  assert(ClassDecl->needsImplicitMoveAssignment());
10452 
10453  DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveAssignment);
10454  if (DSM.isAlreadyBeingDeclared())
10455  return nullptr;
10456 
10457  // Note: The following rules are largely analoguous to the move
10458  // constructor rules.
10459 
10460  QualType ArgType = Context.getTypeDeclType(ClassDecl);
10461  QualType RetType = Context.getLValueReferenceType(ArgType);
10462  ArgType = Context.getRValueReferenceType(ArgType);
10463 
10464  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
10466  false);
10467 
10468  // An implicitly-declared move assignment operator is an inline public
10469  // member of its class.
10470  DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
10471  SourceLocation ClassLoc = ClassDecl->getLocation();
10472  DeclarationNameInfo NameInfo(Name, ClassLoc);
10473  CXXMethodDecl *MoveAssignment =
10474  CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
10475  /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
10476  /*isInline=*/true, Constexpr, SourceLocation());
10477  MoveAssignment->setAccess(AS_public);
10478  MoveAssignment->setDefaulted();
10479  MoveAssignment->setImplicit();
10480 
10481  if (getLangOpts().CUDA) {
10483  MoveAssignment,
10484  /* ConstRHS */ false,
10485  /* Diagnose */ false);
10486  }
10487 
10488  // Build an exception specification pointing back at this member.
10490  getImplicitMethodEPI(*this, MoveAssignment);
10491  MoveAssignment->setType(Context.getFunctionType(RetType, ArgType, EPI));
10492 
10493  // Add the parameter to the operator.
10494  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveAssignment,
10495  ClassLoc, ClassLoc,
10496  /*Id=*/nullptr, ArgType,
10497  /*TInfo=*/nullptr, SC_None,
10498  nullptr);
10499  MoveAssignment->setParams(FromParam);
10500 
10501  AddOverriddenMethods(ClassDecl, MoveAssignment);
10502 
10503  MoveAssignment->setTrivial(
10505  ? SpecialMemberIsTrivial(MoveAssignment, CXXMoveAssignment)
10506  : ClassDecl->hasTrivialMoveAssignment());
10507 
10508  if (ShouldDeleteSpecialMember(MoveAssignment, CXXMoveAssignment)) {
10510  SetDeclDeleted(MoveAssignment, ClassLoc);
10511  }
10512 
10513  // Note that we have added this copy-assignment operator.
10515 
10516  if (Scope *S = getScopeForContext(ClassDecl))
10517  PushOnScopeChains(MoveAssignment, S, false);
10518  ClassDecl->addDecl(MoveAssignment);
10519 
10520  return MoveAssignment;
10521 }
10522 
10523 /// Check if we're implicitly defining a move assignment operator for a class
10524 /// with virtual bases. Such a move assignment might move-assign the virtual
10525 /// base multiple times.
10527  SourceLocation CurrentLocation) {
10528  assert(!Class->isDependentContext() && "should not define dependent move");
10529 
10530  // Only a virtual base could get implicitly move-assigned multiple times.
10531  // Only a non-trivial move assignment can observe this. We only want to
10532  // diagnose if we implicitly define an assignment operator that assigns
10533  // two base classes, both of which move-assign the same virtual base.
10534  if (Class->getNumVBases() == 0 || Class->hasTrivialMoveAssignment() ||
10535  Class->getNumBases() < 2)
10536  return;
10537 
10539  typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
10540  VBaseMap VBases;
10541 
10542  for (auto &BI : Class->bases()) {
10543  Worklist.push_back(&BI);
10544  while (!Worklist.empty()) {
10545  CXXBaseSpecifier *BaseSpec = Worklist.pop_back_val();
10546  CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
10547 
10548  // If the base has no non-trivial move assignment operators,
10549  // we don't care about moves from it.
10550  if (!Base->hasNonTrivialMoveAssignment())
10551  continue;
10552 
10553  // If there's nothing virtual here, skip it.
10554  if (!BaseSpec->isVirtual() && !Base->getNumVBases())
10555  continue;
10556 
10557  // If we're not actually going to call a move assignment for this base,
10558  // or the selected move assignment is trivial, skip it.
10561  /*ConstArg*/false, /*VolatileArg*/false,
10562  /*RValueThis*/true, /*ConstThis*/false,
10563  /*VolatileThis*/false);
10564  if (!SMOR->getMethod() || SMOR->getMethod()->isTrivial() ||
10565  !SMOR->getMethod()->isMoveAssignmentOperator())
10566  continue;
10567 
10568  if (BaseSpec->isVirtual()) {
10569  // We're going to move-assign this virtual base, and its move
10570  // assignment operator is not trivial. If this can happen for
10571  // multiple distinct direct bases of Class, diagnose it. (If it
10572  // only happens in one base, we'll diagnose it when synthesizing
10573  // that base class's move assignment operator.)
10574  CXXBaseSpecifier *&Existing =
10575  VBases.insert(std::make_pair(Base->getCanonicalDecl(), &BI))
10576  .first->second;
10577  if (Existing && Existing != &BI) {
10578  S.Diag(CurrentLocation, diag::warn_vbase_moved_multiple_times)
10579  << Class << Base;
10580  S.Diag(Existing->getLocStart(), diag::note_vbase_moved_here)
10581  << (Base->getCanonicalDecl() ==
10582  Existing->getType()->getAsCXXRecordDecl()->getCanonicalDecl())
10583  << Base << Existing->getType() << Existing->getSourceRange();
10584  S.Diag(BI.getLocStart(), diag::note_vbase_moved_here)
10585  << (Base->getCanonicalDecl() ==
10586  BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
10587  << Base << BI.getType() << BaseSpec->getSourceRange();
10588 
10589  // Only diagnose each vbase once.
10590  Existing = nullptr;
10591  }
10592  } else {
10593  // Only walk over bases that have defaulted move assignment operators.
10594  // We assume that any user-provided move assignment operator handles
10595  // the multiple-moves-of-vbase case itself somehow.
10596  if (!SMOR->getMethod()->isDefaulted())
10597  continue;
10598 
10599  // We're going to move the base classes of Base. Add them to the list.
10600  for (auto &BI : Base->bases())
10601  Worklist.push_back(&BI);
10602  }
10603  }
10604  }
10605 }
10606 
10608  CXXMethodDecl *MoveAssignOperator) {
10609  assert((MoveAssignOperator->isDefaulted() &&
10610  MoveAssignOperator->isOverloadedOperator() &&
10611  MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
10612  !MoveAssignOperator->doesThisDeclarationHaveABody() &&
10613  !MoveAssignOperator->isDeleted()) &&
10614  "DefineImplicitMoveAssignment called for wrong function");
10615 
10616  CXXRecordDecl *ClassDecl = MoveAssignOperator->getParent();
10617 
10618  if (ClassDecl->isInvalidDecl() || MoveAssignOperator->isInvalidDecl()) {
10619  MoveAssignOperator->setInvalidDecl();
10620  return;
10621  }
10622 
10623  MoveAssignOperator->markUsed(Context);
10624 
10625  SynthesizedFunctionScope Scope(*this, MoveAssignOperator);
10626  DiagnosticErrorTrap Trap(Diags);
10627 
10628  // C++0x [class.copy]p28:
10629  // The implicitly-defined or move assignment operator for a non-union class
10630  // X performs memberwise move assignment of its subobjects. The direct base
10631  // classes of X are assigned first, in the order of their declaration in the
10632  // base-specifier-list, and then the immediate non-static data members of X
10633  // are assigned, in the order in which they were declared in the class
10634  // definition.
10635 
10636  // Issue a warning if our implicit move assignment operator will move
10637  // from a virtual base more than once.
10638  checkMoveAssignmentForRepeatedMove(*this, ClassDecl, CurrentLocation);
10639 
10640  // The statements that form the synthesized function body.
10641  SmallVector<Stmt*, 8> Statements;
10642 
10643  // The parameter for the "other" object, which we are move from.
10644  ParmVarDecl *Other = MoveAssignOperator->getParamDecl(0);
10645  QualType OtherRefType = Other->getType()->
10646  getAs<RValueReferenceType>()->getPointeeType();
10647  assert(!OtherRefType.getQualifiers() &&
10648  "Bad argument type of defaulted move assignment");
10649 
10650  // Our location for everything implicitly-generated.
10651  SourceLocation Loc = MoveAssignOperator->getLocEnd().isValid()
10652  ? MoveAssignOperator->getLocEnd()
10653  : MoveAssignOperator->getLocation();
10654 
10655  // Builds a reference to the "other" object.
10656  RefBuilder OtherRef(Other, OtherRefType);
10657  // Cast to rvalue.
10658  MoveCastBuilder MoveOther(OtherRef);
10659 
10660  // Builds the "this" pointer.
10661  ThisBuilder This;
10662 
10663  // Assign base classes.
10664  bool Invalid = false;
10665  for (auto &Base : ClassDecl->bases()) {
10666  // C++11 [class.copy]p28:
10667  // It is unspecified whether subobjects representing virtual base classes
10668  // are assigned more than once by the implicitly-defined copy assignment
10669  // operator.
10670  // FIXME: Do not assign to a vbase that will be assigned by some other base
10671  // class. For a move-assignment, this can result in the vbase being moved
10672  // multiple times.
10673 
10674  // Form the assignment:
10675  // static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other));
10676  QualType BaseType = Base.getType().getUnqualifiedType();
10677  if (!BaseType->isRecordType()) {
10678  Invalid = true;
10679  continue;
10680  }
10681 
10682  CXXCastPath BasePath;
10683  BasePath.push_back(&Base);
10684 
10685  // Construct the "from" expression, which is an implicit cast to the
10686  // appropriately-qualified base type.
10687  CastBuilder From(OtherRef, BaseType, VK_XValue, BasePath);
10688 
10689  // Dereference "this".
10690  DerefBuilder DerefThis(This);
10691 
10692  // Implicitly cast "this" to the appropriately-qualified base type.
10693  CastBuilder To(DerefThis,
10694  Context.getCVRQualifiedType(
10695  BaseType, MoveAssignOperator->getTypeQualifiers()),
10696  VK_LValue, BasePath);
10697 
10698  // Build the move.
10699  StmtResult Move = buildSingleCopyAssign(*this, Loc, BaseType,
10700  To, From,
10701  /*CopyingBaseSubobject=*/true,
10702  /*Copying=*/false);
10703  if (Move.isInvalid()) {
10704  Diag(CurrentLocation, diag::note_member_synthesized_at)
10705  << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10706  MoveAssignOperator->setInvalidDecl();
10707  return;
10708  }
10709 
10710  // Success! Record the move.
10711  Statements.push_back(Move.getAs<Expr>());
10712  }
10713 
10714  // Assign non-static members.
10715  for (auto *Field : ClassDecl->fields()) {
10716  // FIXME: We should form some kind of AST representation for the implied
10717  // memcpy in a union copy operation.
10718  if (Field->isUnnamedBitfield() || Field->getParent()->isUnion())
10719  continue;
10720 
10721  if (Field->isInvalidDecl()) {
10722  Invalid = true;
10723  continue;
10724  }
10725 
10726  // Check for members of reference type; we can't move those.
10727  if (Field->getType()->isReferenceType()) {
10728  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
10729  << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
10730  Diag(Field->getLocation(), diag::note_declared_at);
10731  Diag(CurrentLocation, diag::note_member_synthesized_at)
10732  << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10733  Invalid = true;
10734  continue;
10735  }
10736 
10737  // Check for members of const-qualified, non-class type.
10738  QualType BaseType = Context.getBaseElementType(Field->getType());
10739  if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
10740  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
10741  << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
10742  Diag(Field->getLocation(), diag::note_declared_at);
10743  Diag(CurrentLocation, diag::note_member_synthesized_at)
10744  << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10745  Invalid = true;
10746  continue;
10747  }
10748 
10749  // Suppress assigning zero-width bitfields.
10750  if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
10751  continue;
10752 
10753  QualType FieldType = Field->getType().getNonReferenceType();
10754  if (FieldType->isIncompleteArrayType()) {
10755  assert(ClassDecl->hasFlexibleArrayMember() &&
10756  "Incomplete array type is not valid");
10757  continue;
10758  }
10759 
10760  // Build references to the field in the object we're copying from and to.
10761  LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
10763  MemberLookup.addDecl(Field);
10764  MemberLookup.resolveKind();
10765  MemberBuilder From(MoveOther, OtherRefType,
10766  /*IsArrow=*/false, MemberLookup);
10767  MemberBuilder To(This, getCurrentThisType(),
10768  /*IsArrow=*/true, MemberLookup);
10769 
10770  assert(!From.build(*this, Loc)->isLValue() && // could be xvalue or prvalue
10771  "Member reference with rvalue base must be rvalue except for reference "
10772  "members, which aren't allowed for move assignment.");
10773 
10774  // Build the move of this field.
10775  StmtResult Move = buildSingleCopyAssign(*this, Loc, FieldType,
10776  To, From,
10777  /*CopyingBaseSubobject=*/false,
10778  /*Copying=*/false);
10779  if (Move.isInvalid()) {
10780  Diag(CurrentLocation, diag::note_member_synthesized_at)
10781  << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10782  MoveAssignOperator->setInvalidDecl();
10783  return;
10784  }
10785 
10786  // Success! Record the copy.
10787  Statements.push_back(Move.getAs<Stmt>());
10788  }
10789 
10790  if (!Invalid) {
10791  // Add a "return *this;"
10792  ExprResult ThisObj =
10793  CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
10794 
10795  StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
10796  if (Return.isInvalid())
10797  Invalid = true;
10798  else {
10799  Statements.push_back(Return.getAs<Stmt>());
10800 
10801  if (Trap.hasErrorOccurred()) {
10802  Diag(CurrentLocation, diag::note_member_synthesized_at)
10803  << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10804  Invalid = true;
10805  }
10806  }
10807  }
10808 
10809  // The exception specification is needed because we are defining the
10810  // function.
10811  ResolveExceptionSpec(CurrentLocation,
10812  MoveAssignOperator->getType()->castAs<FunctionProtoType>());
10813 
10814  if (Invalid) {
10815  MoveAssignOperator->setInvalidDecl();
10816  return;
10817  }
10818 
10819  StmtResult Body;
10820  {
10821  CompoundScopeRAII CompoundScope(*this);
10822  Body = ActOnCompoundStmt(Loc, Loc, Statements,
10823  /*isStmtExpr=*/false);
10824  assert(!Body.isInvalid() && "Compound statement creation cannot fail");
10825  }
10826  MoveAssignOperator->setBody(Body.getAs<Stmt>());
10827 
10829  L->CompletedImplicitDefinition(MoveAssignOperator);
10830  }
10831 }
10832 
10835  CXXRecordDecl *ClassDecl = MD->getParent();
10836 
10837  ImplicitExceptionSpecification ExceptSpec(*this);
10838  if (ClassDecl->isInvalidDecl())
10839  return ExceptSpec;
10840 
10841  const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
10842  assert(T->getNumParams() >= 1 && "not a copy ctor");
10843  unsigned Quals = T->getParamType(0).getNonReferenceType().getCVRQualifiers();
10844 
10845  // C++ [except.spec]p14:
10846  // An implicitly declared special member function (Clause 12) shall have an
10847  // exception-specification. [...]
10848  for (const auto &Base : ClassDecl->bases()) {
10849  // Virtual bases are handled below.
10850  if (Base.isVirtual())
10851  continue;
10852 
10853  CXXRecordDecl *BaseClassDecl
10854  = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
10855  if (CXXConstructorDecl *CopyConstructor =
10856  LookupCopyingConstructor(BaseClassDecl, Quals))
10857  ExceptSpec.CalledDecl(Base.getLocStart(), CopyConstructor);
10858  }
10859  for (const auto &Base : ClassDecl->vbases()) {
10860  CXXRecordDecl *BaseClassDecl
10861  = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
10862  if (CXXConstructorDecl *CopyConstructor =
10863  LookupCopyingConstructor(BaseClassDecl, Quals))
10864  ExceptSpec.CalledDecl(Base.getLocStart(), CopyConstructor);
10865  }
10866  for (const auto *Field : ClassDecl->fields()) {
10867  QualType FieldType = Context.getBaseElementType(Field->getType());
10868  if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
10869  if (CXXConstructorDecl *CopyConstructor =
10870  LookupCopyingConstructor(FieldClassDecl,
10871  Quals | FieldType.getCVRQualifiers()))
10872  ExceptSpec.CalledDecl(Field->getLocation(), CopyConstructor);
10873  }
10874  }
10875 
10876  return ExceptSpec;
10877 }
10878 
10880  CXXRecordDecl *ClassDecl) {
10881  // C++ [class.copy]p4:
10882  // If the class definition does not explicitly declare a copy
10883  // constructor, one is declared implicitly.
10884  assert(ClassDecl->needsImplicitCopyConstructor());
10885 
10886  DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyConstructor);
10887  if (DSM.isAlreadyBeingDeclared())
10888  return nullptr;
10889 
10890  QualType ClassType = Context.getTypeDeclType(ClassDecl);
10891  QualType ArgType = ClassType;
10892  bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
10893  if (Const)
10894  ArgType = ArgType.withConst();
10895  ArgType = Context.getLValueReferenceType(ArgType);
10896 
10897  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
10899  Const);
10900 
10901  DeclarationName Name
10903  Context.getCanonicalType(ClassType));
10904  SourceLocation ClassLoc = ClassDecl->getLocation();
10905  DeclarationNameInfo NameInfo(Name, ClassLoc);
10906 
10907  // An implicitly-declared copy constructor is an inline public
10908  // member of its class.
10910  Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
10911  /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
10912  Constexpr);
10913  CopyConstructor->setAccess(AS_public);
10914  CopyConstructor->setDefaulted();
10915 
10916  if (getLangOpts().CUDA) {
10918  CopyConstructor,
10919  /* ConstRHS */ Const,
10920  /* Diagnose */ false);
10921  }
10922 
10923  // Build an exception specification pointing back at this member.
10925  getImplicitMethodEPI(*this, CopyConstructor);
10926  CopyConstructor->setType(
10927  Context.getFunctionType(Context.VoidTy, ArgType, EPI));
10928 
10929  // Add the parameter to the constructor.
10930  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
10931  ClassLoc, ClassLoc,
10932  /*IdentifierInfo=*/nullptr,
10933  ArgType, /*TInfo=*/nullptr,
10934  SC_None, nullptr);
10935  CopyConstructor->setParams(FromParam);
10936 
10937  CopyConstructor->setTrivial(
10939  ? SpecialMemberIsTrivial(CopyConstructor, CXXCopyConstructor)
10940  : ClassDecl->hasTrivialCopyConstructor());
10941 
10942  if (ShouldDeleteSpecialMember(CopyConstructor, CXXCopyConstructor))
10943  SetDeclDeleted(CopyConstructor, ClassLoc);
10944 
10945  // Note that we have declared this constructor.
10947 
10948  if (Scope *S = getScopeForContext(ClassDecl))
10949  PushOnScopeChains(CopyConstructor, S, false);
10950  ClassDecl->addDecl(CopyConstructor);
10951 
10952  return CopyConstructor;
10953 }
10954 
10956  CXXConstructorDecl *CopyConstructor) {
10957  assert((CopyConstructor->isDefaulted() &&
10958  CopyConstructor->isCopyConstructor() &&
10959  !CopyConstructor->doesThisDeclarationHaveABody() &&
10960  !CopyConstructor->isDeleted()) &&
10961  "DefineImplicitCopyConstructor - call it for implicit copy ctor");
10962 
10963  CXXRecordDecl *ClassDecl = CopyConstructor->getParent();
10964  assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
10965 
10966  // C++11 [class.copy]p7:
10967  // The [definition of an implicitly declared copy constructor] is
10968  // deprecated if the class has a user-declared copy assignment operator
10969  // or a user-declared destructor.
10970  if (getLangOpts().CPlusPlus11 && CopyConstructor->isImplicit())
10971  diagnoseDeprecatedCopyOperation(*this, CopyConstructor, CurrentLocation);
10972 
10973  SynthesizedFunctionScope Scope(*this, CopyConstructor);
10974  DiagnosticErrorTrap Trap(Diags);
10975 
10976  if (SetCtorInitializers(CopyConstructor, /*AnyErrors=*/false) ||
10977  Trap.hasErrorOccurred()) {
10978  Diag(CurrentLocation, diag::note_member_synthesized_at)
10979  << CXXCopyConstructor << Context.getTagDeclType(ClassDecl);
10980  CopyConstructor->setInvalidDecl();
10981  } else {
10982  SourceLocation Loc = CopyConstructor->getLocEnd().isValid()
10983  ? CopyConstructor->getLocEnd()
10984  : CopyConstructor->getLocation();
10985  Sema::CompoundScopeRAII CompoundScope(*this);
10986  CopyConstructor->setBody(
10987  ActOnCompoundStmt(Loc, Loc, None, /*isStmtExpr=*/false).getAs<Stmt>());
10988  }
10989 
10990  // The exception specification is needed because we are defining the
10991  // function.
10992  ResolveExceptionSpec(CurrentLocation,
10993  CopyConstructor->getType()->castAs<FunctionProtoType>());
10994 
10995  CopyConstructor->markUsed(Context);
10996  MarkVTableUsed(CurrentLocation, ClassDecl);
10997 
10999  L->CompletedImplicitDefinition(CopyConstructor);
11000  }
11001 }
11002 
11005  CXXRecordDecl *ClassDecl = MD->getParent();
11006 
11007  // C++ [except.spec]p14:
11008  // An implicitly declared special member function (Clause 12) shall have an
11009  // exception-specification. [...]
11010  ImplicitExceptionSpecification ExceptSpec(*this);
11011  if (ClassDecl->isInvalidDecl())
11012  return ExceptSpec;
11013 
11014  // Direct base-class constructors.
11015  for (const auto &B : ClassDecl->bases()) {
11016  if (B.isVirtual()) // Handled below.
11017  continue;
11018 
11019  if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
11020  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
11021  CXXConstructorDecl *Constructor =
11022  LookupMovingConstructor(BaseClassDecl, 0);
11023  // If this is a deleted function, add it anyway. This might be conformant
11024  // with the standard. This might not. I'm not sure. It might not matter.
11025  if (Constructor)
11026  ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
11027  }
11028  }
11029 
11030  // Virtual base-class constructors.
11031  for (const auto &B : ClassDecl->vbases()) {
11032  if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
11033  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
11034  CXXConstructorDecl *Constructor =
11035  LookupMovingConstructor(BaseClassDecl, 0);
11036  // If this is a deleted function, add it anyway. This might be conformant
11037  // with the standard. This might not. I'm not sure. It might not matter.
11038  if (Constructor)
11039  ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
11040  }
11041  }
11042 
11043  // Field constructors.
11044  for (const auto *F : ClassDecl->fields()) {
11045  QualType FieldType = Context.getBaseElementType(F->getType());
11046  if (CXXRecordDecl *FieldRecDecl = FieldType->getAsCXXRecordDecl()) {
11047  CXXConstructorDecl *Constructor =
11048  LookupMovingConstructor(FieldRecDecl, FieldType.getCVRQualifiers());
11049  // If this is a deleted function, add it anyway. This might be conformant
11050  // with the standard. This might not. I'm not sure. It might not matter.
11051  // In particular, the problem is that this function never gets called. It
11052  // might just be ill-formed because this function attempts to refer to
11053  // a deleted function here.
11054  if (Constructor)
11055  ExceptSpec.CalledDecl(F->getLocation(), Constructor);
11056  }
11057  }
11058 
11059  return ExceptSpec;
11060 }
11061 
11063  CXXRecordDecl *ClassDecl) {
11064  assert(ClassDecl->needsImplicitMoveConstructor());
11065 
11066  DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveConstructor);
11067  if (DSM.isAlreadyBeingDeclared())
11068  return nullptr;
11069 
11070  QualType ClassType = Context.getTypeDeclType(ClassDecl);
11071  QualType ArgType = Context.getRValueReferenceType(ClassType);
11072 
11073  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
11075  false);
11076 
11077  DeclarationName Name
11079  Context.getCanonicalType(ClassType));
11080  SourceLocation ClassLoc = ClassDecl->getLocation();
11081  DeclarationNameInfo NameInfo(Name, ClassLoc);
11082 
11083  // C++11 [class.copy]p11:
11084  // An implicitly-declared copy/move constructor is an inline public
11085  // member of its class.
11087  Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
11088  /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
11089  Constexpr);
11090  MoveConstructor->setAccess(AS_public);
11091  MoveConstructor->setDefaulted();
11092 
11093  if (getLangOpts().CUDA) {
11095  MoveConstructor,
11096  /* ConstRHS */ false,
11097  /* Diagnose */ false);
11098  }
11099 
11100  // Build an exception specification pointing back at this member.
11102  getImplicitMethodEPI(*this, MoveConstructor);
11103  MoveConstructor->setType(
11104  Context.getFunctionType(Context.VoidTy, ArgType, EPI));
11105 
11106  // Add the parameter to the constructor.
11107  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveConstructor,
11108  ClassLoc, ClassLoc,
11109  /*IdentifierInfo=*/nullptr,
11110  ArgType, /*TInfo=*/nullptr,
11111  SC_None, nullptr);
11112  MoveConstructor->setParams(FromParam);
11113 
11114  MoveConstructor->setTrivial(
11116  ? SpecialMemberIsTrivial(MoveConstructor, CXXMoveConstructor)
11117  : ClassDecl->hasTrivialMoveConstructor());
11118 
11119  if (ShouldDeleteSpecialMember(MoveConstructor, CXXMoveConstructor)) {
11121  SetDeclDeleted(MoveConstructor, ClassLoc);
11122  }
11123 
11124  // Note that we have declared this constructor.
11126 
11127  if (Scope *S = getScopeForContext(ClassDecl))
11128  PushOnScopeChains(MoveConstructor, S, false);
11129  ClassDecl->addDecl(MoveConstructor);
11130 
11131  return MoveConstructor;
11132 }
11133 
11135  CXXConstructorDecl *MoveConstructor) {
11136  assert((MoveConstructor->isDefaulted() &&
11137  MoveConstructor->isMoveConstructor() &&
11138  !MoveConstructor->doesThisDeclarationHaveABody() &&
11139  !MoveConstructor->isDeleted()) &&
11140  "DefineImplicitMoveConstructor - call it for implicit move ctor");
11141 
11142  CXXRecordDecl *ClassDecl = MoveConstructor->getParent();
11143  assert(ClassDecl && "DefineImplicitMoveConstructor - invalid constructor");
11144 
11145  SynthesizedFunctionScope Scope(*this, MoveConstructor);
11146  DiagnosticErrorTrap Trap(Diags);
11147 
11148  if (SetCtorInitializers(MoveConstructor, /*AnyErrors=*/false) ||
11149  Trap.hasErrorOccurred()) {
11150  Diag(CurrentLocation, diag::note_member_synthesized_at)
11151  << CXXMoveConstructor << Context.getTagDeclType(ClassDecl);
11152  MoveConstructor->setInvalidDecl();
11153  } else {
11154  SourceLocation Loc = MoveConstructor->getLocEnd().isValid()
11155  ? MoveConstructor->getLocEnd()
11156  : MoveConstructor->getLocation();
11157  Sema::CompoundScopeRAII CompoundScope(*this);
11158  MoveConstructor->setBody(ActOnCompoundStmt(
11159  Loc, Loc, None, /*isStmtExpr=*/ false).getAs<Stmt>());
11160  }
11161 
11162  // The exception specification is needed because we are defining the
11163  // function.
11164  ResolveExceptionSpec(CurrentLocation,
11165  MoveConstructor->getType()->castAs<FunctionProtoType>());
11166 
11167  MoveConstructor->markUsed(Context);
11168  MarkVTableUsed(CurrentLocation, ClassDecl);
11169 
11171  L->CompletedImplicitDefinition(MoveConstructor);
11172  }
11173 }
11174 
11176  return FD->isDeleted() && FD->isDefaulted() && isa<CXXMethodDecl>(FD);
11177 }
11178 
11180  SourceLocation CurrentLocation,
11181  CXXConversionDecl *Conv) {
11182  CXXRecordDecl *Lambda = Conv->getParent();
11183  CXXMethodDecl *CallOp = Lambda->getLambdaCallOperator();
11184  // If we are defining a specialization of a conversion to function-ptr
11185  // cache the deduced template arguments for this specialization
11186  // so that we can use them to retrieve the corresponding call-operator
11187  // and static-invoker.
11188  const TemplateArgumentList *DeducedTemplateArgs = nullptr;
11189 
11190  // Retrieve the corresponding call-operator specialization.
11191  if (Lambda->isGenericLambda()) {
11192  assert(Conv->isFunctionTemplateSpecialization());
11193  FunctionTemplateDecl *CallOpTemplate =
11194  CallOp->getDescribedFunctionTemplate();
11195  DeducedTemplateArgs = Conv->getTemplateSpecializationArgs();
11196  void *InsertPos = nullptr;
11197  FunctionDecl *CallOpSpec = CallOpTemplate->findSpecialization(
11198  DeducedTemplateArgs->asArray(),
11199  InsertPos);
11200  assert(CallOpSpec &&
11201  "Conversion operator must have a corresponding call operator");
11202  CallOp = cast<CXXMethodDecl>(CallOpSpec);
11203  }
11204  // Mark the call operator referenced (and add to pending instantiations
11205  // if necessary).
11206  // For both the conversion and static-invoker template specializations
11207  // we construct their body's in this function, so no need to add them
11208  // to the PendingInstantiations.
11209  MarkFunctionReferenced(CurrentLocation, CallOp);
11210 
11211  SynthesizedFunctionScope Scope(*this, Conv);
11212  DiagnosticErrorTrap Trap(Diags);
11213 
11214  // Retrieve the static invoker...
11215  CXXMethodDecl *Invoker = Lambda->getLambdaStaticInvoker();
11216  // ... and get the corresponding specialization for a generic lambda.
11217  if (Lambda->isGenericLambda()) {
11218  assert(DeducedTemplateArgs &&
11219  "Must have deduced template arguments from Conversion Operator");
11220  FunctionTemplateDecl *InvokeTemplate =
11221  Invoker->getDescribedFunctionTemplate();
11222  void *InsertPos = nullptr;
11223  FunctionDecl *InvokeSpec = InvokeTemplate->findSpecialization(
11224  DeducedTemplateArgs->asArray(),
11225  InsertPos);
11226  assert(InvokeSpec &&
11227  "Must have a corresponding static invoker specialization");
11228  Invoker = cast<CXXMethodDecl>(InvokeSpec);
11229  }
11230  // Construct the body of the conversion function { return __invoke; }.
11231  Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(),
11232  VK_LValue, Conv->getLocation()).get();
11233  assert(FunctionRef && "Can't refer to __invoke function?");
11234  Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
11235  Conv->setBody(new (Context) CompoundStmt(Context, Return,
11236  Conv->getLocation(),
11237  Conv->getLocation()));
11238 
11239  Conv->markUsed(Context);
11240  Conv->setReferenced();
11241 
11242  // Fill in the __invoke function with a dummy implementation. IR generation
11243  // will fill in the actual details.
11244  Invoker->markUsed(Context);
11245  Invoker->setReferenced();
11246  Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));
11247 
11249  L->CompletedImplicitDefinition(Conv);
11250  L->CompletedImplicitDefinition(Invoker);
11251  }
11252 }
11253 
11254 
11255 
11257  SourceLocation CurrentLocation,
11258  CXXConversionDecl *Conv)
11259 {
11260  assert(!Conv->getParent()->isGenericLambda());
11261 
11262  Conv->markUsed(Context);
11263 
11264  SynthesizedFunctionScope Scope(*this, Conv);
11265  DiagnosticErrorTrap Trap(Diags);
11266 
11267  // Copy-initialize the lambda object as needed to capture it.
11268  Expr *This = ActOnCXXThis(CurrentLocation).get();
11269  Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).get();
11270 
11271  ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation,
11272  Conv->getLocation(),
11273  Conv, DerefThis);
11274 
11275  // If we're not under ARC, make sure we still get the _Block_copy/autorelease
11276  // behavior. Note that only the general conversion function does this
11277  // (since it's unusable otherwise); in the case where we inline the
11278  // block literal, it has block literal lifetime semantics.
11279  if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
11280  BuildBlock = ImplicitCastExpr::Create(Context, BuildBlock.get()->getType(),
11282  BuildBlock.get(), nullptr, VK_RValue);
11283 
11284  if (BuildBlock.isInvalid()) {
11285  Diag(CurrentLocation, diag::note_lambda_to_block_conv);
11286  Conv->setInvalidDecl();
11287  return;
11288  }
11289 
11290  // Create the return statement that returns the block from the conversion
11291  // function.
11292  StmtResult Return = BuildReturnStmt(Conv->getLocation(), BuildBlock.get());
11293  if (Return.isInvalid()) {
11294  Diag(CurrentLocation, diag::note_lambda_to_block_conv);
11295  Conv->setInvalidDecl();
11296  return;
11297  }
11298 
11299  // Set the body of the conversion function.
11300  Stmt *ReturnS = Return.get();
11301  Conv->setBody(new (Context) CompoundStmt(Context, ReturnS,
11302  Conv->getLocation(),
11303  Conv->getLocation()));
11304 
11305  // We're done; notify the mutation listener, if any.
11307  L->CompletedImplicitDefinition(Conv);
11308  }
11309 }
11310 
11311 /// \brief Determine whether the given list arguments contains exactly one
11312 /// "real" (non-default) argument.
11314  switch (Args.size()) {
11315  case 0:
11316  return false;
11317 
11318  default:
11319  if (!Args[1]->isDefaultArgument())
11320  return false;
11321 
11322  // fall through
11323  case 1:
11324  return !Args[0]->isDefaultArgument();
11325  }
11326 
11327  return false;
11328 }
11329 
11330 ExprResult
11332  CXXConstructorDecl *Constructor,
11333  MultiExprArg ExprArgs,
11334  bool HadMultipleCandidates,
11335  bool IsListInitialization,
11336  bool IsStdInitListInitialization,
11337  bool RequiresZeroInit,
11338  unsigned ConstructKind,
11339  SourceRange ParenRange) {
11340  bool Elidable = false;
11341 
11342  // C++0x [class.copy]p34:
11343  // When certain criteria are met, an implementation is allowed to
11344  // omit the copy/move construction of a class object, even if the
11345  // copy/move constructor and/or destructor for the object have
11346  // side effects. [...]
11347  // - when a temporary class object that has not been bound to a
11348  // reference (12.2) would be copied/moved to a class object
11349  // with the same cv-unqualified type, the copy/move operation
11350  // can be omitted by constructing the temporary object
11351  // directly into the target of the omitted copy/move
11352  if (ConstructKind == CXXConstructExpr::CK_Complete &&
11353  Constructor->isCopyOrMoveConstructor() && hasOneRealArgument(ExprArgs)) {
11354  Expr *SubExpr = ExprArgs[0];
11355  Elidable = SubExpr->isTemporaryObject(Context, Constructor->getParent());
11356  }
11357 
11358  return BuildCXXConstructExpr(ConstructLoc, DeclInitType, Constructor,
11359  Elidable, ExprArgs, HadMultipleCandidates,
11360  IsListInitialization,
11361  IsStdInitListInitialization, RequiresZeroInit,
11362  ConstructKind, ParenRange);
11363 }
11364 
11365 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
11366 /// including handling of its default argument expressions.
11367 ExprResult
11369  CXXConstructorDecl *Constructor, bool Elidable,
11370  MultiExprArg ExprArgs,
11371  bool HadMultipleCandidates,
11372  bool IsListInitialization,
11373  bool IsStdInitListInitialization,
11374  bool RequiresZeroInit,
11375  unsigned ConstructKind,
11376  SourceRange ParenRange) {
11377  MarkFunctionReferenced(ConstructLoc, Constructor);
11378  return CXXConstructExpr::Create(
11379  Context, DeclInitType, ConstructLoc, Constructor, Elidable, ExprArgs,
11380  HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
11381  RequiresZeroInit,
11382  static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
11383  ParenRange);
11384 }
11385 
11387  assert(Field->hasInClassInitializer());
11388 
11389  // If we already have the in-class initializer nothing needs to be done.
11390  if (Field->getInClassInitializer())
11391  return CXXDefaultInitExpr::Create(Context, Loc, Field);
11392 
11393  // Maybe we haven't instantiated the in-class initializer. Go check the
11394  // pattern FieldDecl to see if it has one.
11395  CXXRecordDecl *ParentRD = cast<CXXRecordDecl>(Field->getParent());
11396 
11398  CXXRecordDecl *ClassPattern = ParentRD->getTemplateInstantiationPattern();
11400  ClassPattern->lookup(Field->getDeclName());
11401  assert(Lookup.size() == 1);
11402  FieldDecl *Pattern = cast<FieldDecl>(Lookup[0]);
11403  if (InstantiateInClassInitializer(Loc, Field, Pattern,
11405  return ExprError();
11406  return CXXDefaultInitExpr::Create(Context, Loc, Field);
11407  }
11408 
11409  // DR1351:
11410  // If the brace-or-equal-initializer of a non-static data member
11411  // invokes a defaulted default constructor of its class or of an
11412  // enclosing class in a potentially evaluated subexpression, the
11413  // program is ill-formed.
11414  //
11415  // This resolution is unworkable: the exception specification of the
11416  // default constructor can be needed in an unevaluated context, in
11417  // particular, in the operand of a noexcept-expression, and we can be
11418  // unable to compute an exception specification for an enclosed class.
11419  //
11420  // Any attempt to resolve the exception specification of a defaulted default
11421  // constructor before the initializer is lexically complete will ultimately
11422  // come here at which point we can diagnose it.
11423  RecordDecl *OutermostClass = ParentRD->getOuterLexicalRecordContext();
11424  if (OutermostClass == ParentRD) {
11425  Diag(Field->getLocEnd(), diag::err_in_class_initializer_not_yet_parsed)
11426  << ParentRD << Field;
11427  } else {
11428  Diag(Field->getLocEnd(),
11429  diag::err_in_class_initializer_not_yet_parsed_outer_class)
11430  << ParentRD << OutermostClass << Field;
11431  }
11432 
11433  return ExprError();
11434 }
11435 
11437  if (VD->isInvalidDecl()) return;
11438 
11439  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());
11440  if (ClassDecl->isInvalidDecl()) return;
11441  if (ClassDecl->hasIrrelevantDestructor()) return;
11442  if (ClassDecl->isDependentContext()) return;
11443 
11444  CXXDestructorDecl *Destructor = LookupDestructor(ClassDecl);
11445  MarkFunctionReferenced(VD->getLocation(), Destructor);
11446  CheckDestructorAccess(VD->getLocation(), Destructor,
11447  PDiag(diag::err_access_dtor_var)
11448  << VD->getDeclName()
11449  << VD->getType());
11450  DiagnoseUseOfDecl(Destructor, VD->getLocation());
11451 
11452  if (Destructor->isTrivial()) return;
11453  if (!VD->hasGlobalStorage()) return;
11454 
11455  // Emit warning for non-trivial dtor in global scope (a real global,
11456  // class-static, function-static).
11457  Diag(VD->getLocation(), diag::warn_exit_time_destructor);
11458 
11459  // TODO: this should be re-enabled for static locals by !CXAAtExit
11460  if (!VD->isStaticLocal())
11461  Diag(VD->getLocation(), diag::warn_global_destructor);
11462 }
11463 
11464 /// \brief Given a constructor and the set of arguments provided for the
11465 /// constructor, convert the arguments and add any required default arguments
11466 /// to form a proper call to this constructor.
11467 ///
11468 /// \returns true if an error occurred, false otherwise.
11469 bool
11471  MultiExprArg ArgsPtr,
11472  SourceLocation Loc,
11473  SmallVectorImpl<Expr*> &ConvertedArgs,
11474  bool AllowExplicit,
11475  bool IsListInitialization) {
11476  // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
11477  unsigned NumArgs = ArgsPtr.size();
11478  Expr **Args = ArgsPtr.data();
11479 
11480  const FunctionProtoType *Proto
11481  = Constructor->getType()->getAs<FunctionProtoType>();
11482  assert(Proto && "Constructor without a prototype?");
11483  unsigned NumParams = Proto->getNumParams();
11484 
11485  // If too few arguments are available, we'll fill in the rest with defaults.
11486  if (NumArgs < NumParams)
11487  ConvertedArgs.reserve(NumParams);
11488  else
11489  ConvertedArgs.reserve(NumArgs);
11490 
11491  VariadicCallType CallType =
11493  SmallVector<Expr *, 8> AllArgs;
11494  bool Invalid = GatherArgumentsForCall(Loc, Constructor,
11495  Proto, 0,
11496  llvm::makeArrayRef(Args, NumArgs),
11497  AllArgs,
11498  CallType, AllowExplicit,
11499  IsListInitialization);
11500  ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
11501 
11502  DiagnoseSentinelCalls(Constructor, Loc, AllArgs);
11503 
11504  CheckConstructorCall(Constructor,
11505  llvm::makeArrayRef(AllArgs.data(), AllArgs.size()),
11506  Proto, Loc);
11507 
11508  return Invalid;
11509 }
11510 
11511 static inline bool
11513  const FunctionDecl *FnDecl) {
11514  const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
11515  if (isa<NamespaceDecl>(DC)) {
11516  return SemaRef.Diag(FnDecl->getLocation(),
11517  diag::err_operator_new_delete_declared_in_namespace)
11518  << FnDecl->getDeclName();
11519  }
11520 
11521  if (isa<TranslationUnitDecl>(DC) &&
11522  FnDecl->getStorageClass() == SC_Static) {
11523  return SemaRef.Diag(FnDecl->getLocation(),
11524  diag::err_operator_new_delete_declared_static)
11525  << FnDecl->getDeclName();
11526  }
11527 
11528  return false;
11529 }
11530 
11531 static inline bool
11533  CanQualType ExpectedResultType,
11534  CanQualType ExpectedFirstParamType,
11535  unsigned DependentParamTypeDiag,
11536  unsigned InvalidParamTypeDiag) {
11537  QualType ResultType =
11538  FnDecl->getType()->getAs<FunctionType>()->getReturnType();
11539 
11540  // Check that the result type is not dependent.
11541  if (ResultType->isDependentType())
11542  return SemaRef.Diag(FnDecl->getLocation(),
11543  diag::err_operator_new_delete_dependent_result_type)
11544  << FnDecl->getDeclName() << ExpectedResultType;
11545 
11546  // Check that the result type is what we expect.
11547  if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType)
11548  return SemaRef.Diag(FnDecl->getLocation(),
11549  diag::err_operator_new_delete_invalid_result_type)
11550  << FnDecl->getDeclName() << ExpectedResultType;
11551 
11552  // A function template must have at least 2 parameters.
11553  if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
11554  return SemaRef.Diag(FnDecl->getLocation(),
11555  diag::err_operator_new_delete_template_too_few_parameters)
11556  << FnDecl->getDeclName();
11557 
11558  // The function decl must have at least 1 parameter.
11559  if (FnDecl->getNumParams() == 0)
11560  return SemaRef.Diag(FnDecl->getLocation(),
11561  diag::err_operator_new_delete_too_few_parameters)
11562  << FnDecl->getDeclName();
11563 
11564  // Check the first parameter type is not dependent.
11565  QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
11566  if (FirstParamType->isDependentType())
11567  return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag)
11568  << FnDecl->getDeclName() << ExpectedFirstParamType;
11569 
11570  // Check that the first parameter type is what we expect.
11571  if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
11572  ExpectedFirstParamType)
11573  return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
11574  << FnDecl->getDeclName() << ExpectedFirstParamType;
11575 
11576  return false;
11577 }
11578 
11579 static bool
11581  // C++ [basic.stc.dynamic.allocation]p1:
11582  // A program is ill-formed if an allocation function is declared in a
11583  // namespace scope other than global scope or declared static in global
11584  // scope.
11585  if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
11586  return true;
11587 
11588  CanQualType SizeTy =
11589  SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType());
11590 
11591  // C++ [basic.stc.dynamic.allocation]p1:
11592  // The return type shall be void*. The first parameter shall have type
11593  // std::size_t.
11594  if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy,
11595  SizeTy,
11596  diag::err_operator_new_dependent_param_type,
11597  diag::err_operator_new_param_type))
11598  return true;
11599 
11600  // C++ [basic.stc.dynamic.allocation]p1:
11601  // The first parameter shall not have an associated default argument.
11602  if (FnDecl->getParamDecl(0)->hasDefaultArg())
11603  return SemaRef.Diag(FnDecl->getLocation(),
11604  diag::err_operator_new_default_arg)
11605  << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();
11606 
11607  return false;
11608 }
11609 
11610 static bool
11612  // C++ [basic.stc.dynamic.deallocation]p1:
11613  // A program is ill-formed if deallocation functions are declared in a
11614  // namespace scope other than global scope or declared static in global
11615  // scope.
11616  if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
11617  return true;
11618 
11619  // C++ [basic.stc.dynamic.deallocation]p2:
11620  // Each deallocation function shall return void and its first parameter
11621  // shall be void*.
11622  if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidTy,
11623  SemaRef.Context.VoidPtrTy,
11624  diag::err_operator_delete_dependent_param_type,
11625  diag::err_operator_delete_param_type))
11626  return true;
11627 
11628  return false;
11629 }
11630 
11631 /// CheckOverloadedOperatorDeclaration - Check whether the declaration
11632 /// of this overloaded operator is well-formed. If so, returns false;
11633 /// otherwise, emits appropriate diagnostics and returns true.
11635  assert(FnDecl && FnDecl->isOverloadedOperator() &&
11636  "Expected an overloaded operator declaration");
11637 
11639 
11640  // C++ [over.oper]p5:
11641  // The allocation and deallocation functions, operator new,
11642  // operator new[], operator delete and operator delete[], are
11643  // described completely in 3.7.3. The attributes and restrictions
11644  // found in the rest of this subclause do not apply to them unless
11645  // explicitly stated in 3.7.3.
11646  if (Op == OO_Delete || Op == OO_Array_Delete)
11647  return CheckOperatorDeleteDeclaration(*this, FnDecl);
11648 
11649  if (Op == OO_New || Op == OO_Array_New)
11650  return CheckOperatorNewDeclaration(*this, FnDecl);
11651 
11652  // C++ [over.oper]p6:
11653  // An operator function shall either be a non-static member
11654  // function or be a non-member function and have at least one
11655  // parameter whose type is a class, a reference to a class, an
11656  // enumeration, or a reference to an enumeration.
11657  if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
11658  if (MethodDecl->isStatic())
11659  return Diag(FnDecl->getLocation(),
11660  diag::err_operator_overload_static) << FnDecl->getDeclName();
11661  } else {
11662  bool ClassOrEnumParam = false;
11663  for (auto Param : FnDecl->params()) {
11664  QualType ParamType = Param->getType().getNonReferenceType();
11665  if (ParamType->isDependentType() || ParamType->isRecordType() ||
11666  ParamType->isEnumeralType()) {
11667  ClassOrEnumParam = true;
11668  break;
11669  }
11670  }
11671 
11672  if (!ClassOrEnumParam)
11673  return Diag(FnDecl->getLocation(),
11674  diag::err_operator_overload_needs_class_or_enum)
11675  << FnDecl->getDeclName();
11676  }
11677 
11678  // C++ [over.oper]p8:
11679  // An operator function cannot have default arguments (8.3.6),
11680  // except where explicitly stated below.
11681  //
11682  // Only the function-call operator allows default arguments
11683  // (C++ [over.call]p1).
11684  if (Op != OO_Call) {
11685  for (auto Param : FnDecl->params()) {
11686  if (Param->hasDefaultArg())
11687  return Diag(Param->getLocation(),
11688  diag::err_operator_overload_default_arg)
11689  << FnDecl->getDeclName() << Param->getDefaultArgRange();
11690  }
11691  }
11692 
11693  static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
11694  { false, false, false }
11695 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
11696  , { Unary, Binary, MemberOnly }
11697 #include "clang/Basic/OperatorKinds.def"
11698  };
11699 
11700  bool CanBeUnaryOperator = OperatorUses[Op][0];
11701  bool CanBeBinaryOperator = OperatorUses[Op][1];
11702  bool MustBeMemberOperator = OperatorUses[Op][2];
11703 
11704  // C++ [over.oper]p8:
11705  // [...] Operator functions cannot have more or fewer parameters
11706  // than the number required for the corresponding operator, as
11707  // described in the rest of this subclause.
11708  unsigned NumParams = FnDecl->getNumParams()
11709  + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
11710  if (Op != OO_Call &&
11711  ((NumParams == 1 && !CanBeUnaryOperator) ||
11712  (NumParams == 2 && !CanBeBinaryOperator) ||
11713  (NumParams < 1) || (NumParams > 2))) {
11714  // We have the wrong number of parameters.
11715  unsigned ErrorKind;
11716  if (CanBeUnaryOperator && CanBeBinaryOperator) {
11717  ErrorKind = 2; // 2 -> unary or binary.
11718  } else if (CanBeUnaryOperator) {
11719  ErrorKind = 0; // 0 -> unary
11720  } else {
11721  assert(CanBeBinaryOperator &&
11722  "All non-call overloaded operators are unary or binary!");
11723  ErrorKind = 1; // 1 -> binary
11724  }
11725 
11726  return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
11727  << FnDecl->getDeclName() << NumParams << ErrorKind;
11728  }
11729 
11730  // Overloaded operators other than operator() cannot be variadic.
11731  if (Op != OO_Call &&
11732  FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) {
11733  return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
11734  << FnDecl->getDeclName();
11735  }
11736 
11737  // Some operators must be non-static member functions.
11738  if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
11739  return Diag(FnDecl->getLocation(),
11740  diag::err_operator_overload_must_be_member)
11741  << FnDecl->getDeclName();
11742  }
11743 
11744  // C++ [over.inc]p1:
11745  // The user-defined function called operator++ implements the
11746  // prefix and postfix ++ operator. If this function is a member
11747  // function with no parameters, or a non-member function with one
11748  // parameter of class or enumeration type, it defines the prefix
11749  // increment operator ++ for objects of that type. If the function
11750  // is a member function with one parameter (which shall be of type
11751  // int) or a non-member function with two parameters (the second
11752  // of which shall be of type int), it defines the postfix
11753  // increment operator ++ for objects of that type.
11754  if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
11755  ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
11756  QualType ParamType = LastParam->getType();
11757 
11758  if (!ParamType->isSpecificBuiltinType(BuiltinType::Int) &&
11759  !ParamType->isDependentType())
11760  return Diag(LastParam->getLocation(),
11761  diag::err_operator_overload_post_incdec_must_be_int)
11762  << LastParam->getType() << (Op == OO_MinusMinus);
11763  }
11764 
11765  return false;
11766 }
11767 
11768 /// CheckLiteralOperatorDeclaration - Check whether the declaration
11769 /// of this literal operator function is well-formed. If so, returns
11770 /// false; otherwise, emits appropriate diagnostics and returns true.
11772  if (isa<CXXMethodDecl>(FnDecl)) {
11773  Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
11774  << FnDecl->getDeclName();
11775  return true;
11776  }
11777 
11778  if (FnDecl->isExternC()) {
11779  Diag(FnDecl->getLocation(), diag::err_literal_operator_extern_c);
11780  return true;
11781  }
11782 
11783  bool Valid = false;
11784 
11785  // This might be the definition of a literal operator template.
11787  // This might be a specialization of a literal operator template.
11788  if (!TpDecl)
11789  TpDecl = FnDecl->getPrimaryTemplate();
11790 
11791  // template <char...> type operator "" name() and
11792  // template <class T, T...> type operator "" name() are the only valid
11793  // template signatures, and the only valid signatures with no parameters.
11794  if (TpDecl) {
11795  if (FnDecl->param_size() == 0) {
11796  // Must have one or two template parameters
11797  TemplateParameterList *Params = TpDecl->getTemplateParameters();
11798  if (Params->size() == 1) {
11799  NonTypeTemplateParmDecl *PmDecl =
11800  dyn_cast<NonTypeTemplateParmDecl>(Params->getParam(0));
11801 
11802  // The template parameter must be a char parameter pack.
11803  if (PmDecl && PmDecl->isTemplateParameterPack() &&
11804  Context.hasSameType(PmDecl->getType(), Context.CharTy))
11805  Valid = true;
11806  } else if (Params->size() == 2) {
11807  TemplateTypeParmDecl *PmType =
11808  dyn_cast<TemplateTypeParmDecl>(Params->getParam(0));
11809  NonTypeTemplateParmDecl *PmArgs =
11810  dyn_cast<NonTypeTemplateParmDecl>(Params->getParam(1));
11811 
11812  // The second template parameter must be a parameter pack with the
11813  // first template parameter as its type.
11814  if (PmType && PmArgs &&
11815  !PmType->isTemplateParameterPack() &&
11816  PmArgs->isTemplateParameterPack()) {
11817  const TemplateTypeParmType *TArgs =
11818  PmArgs->getType()->getAs<TemplateTypeParmType>();
11819  if (TArgs && TArgs->getDepth() == PmType->getDepth() &&
11820  TArgs->getIndex() == PmType->getIndex()) {
11821  Valid = true;
11822  if (ActiveTemplateInstantiations.empty())
11823  Diag(FnDecl->getLocation(),
11824  diag::ext_string_literal_operator_template);
11825  }
11826  }
11827  }
11828  }
11829  } else if (FnDecl->param_size()) {
11830  // Check the first parameter
11831  FunctionDecl::param_iterator Param = FnDecl->param_begin();
11832 
11833  QualType T = (*Param)->getType().getUnqualifiedType();
11834 
11835  // unsigned long long int, long double, and any character type are allowed
11836  // as the only parameters.
11837  if (Context.hasSameType(T, Context.UnsignedLongLongTy) ||
11838  Context.hasSameType(T, Context.LongDoubleTy) ||
11839  Context.hasSameType(T, Context.CharTy) ||
11840  Context.hasSameType(T, Context.WideCharTy) ||
11841  Context.hasSameType(T, Context.Char16Ty) ||
11842  Context.hasSameType(T, Context.Char32Ty)) {
11843  if (++Param == FnDecl->param_end())
11844  Valid = true;
11845  goto FinishedParams;
11846  }
11847 
11848  // Otherwise it must be a pointer to const; let's strip those qualifiers.
11849  const PointerType *PT = T->getAs<PointerType>();
11850  if (!PT)
11851  goto FinishedParams;
11852  T = PT->getPointeeType();
11853  if (!T.isConstQualified() || T.isVolatileQualified())
11854  goto FinishedParams;
11855  T = T.getUnqualifiedType();
11856 
11857  // Move on to the second parameter;
11858  ++Param;
11859 
11860  // If there is no second parameter, the first must be a const char *
11861  if (Param == FnDecl->param_end()) {
11862  if (Context.hasSameType(T, Context.CharTy))
11863  Valid = true;
11864  goto FinishedParams;
11865  }
11866 
11867  // const char *, const wchar_t*, const char16_t*, and const char32_t*
11868  // are allowed as the first parameter to a two-parameter function
11869  if (!(Context.hasSameType(T, Context.CharTy) ||
11870  Context.hasSameType(T, Context.WideCharTy) ||
11871  Context.hasSameType(T, Context.Char16Ty) ||
11872  Context.hasSameType(T, Context.Char32Ty)))
11873  goto FinishedParams;
11874 
11875  // The second and final parameter must be an std::size_t
11876  T = (*Param)->getType().getUnqualifiedType();
11877  if (Context.hasSameType(T, Context.getSizeType()) &&
11878  ++Param == FnDecl->param_end())
11879  Valid = true;
11880  }
11881 
11882  // FIXME: This diagnostic is absolutely terrible.
11883 FinishedParams:
11884  if (!Valid) {
11885  Diag(FnDecl->getLocation(), diag::err_literal_operator_params)
11886  << FnDecl->getDeclName();
11887  return true;
11888  }
11889 
11890  // A parameter-declaration-clause containing a default argument is not
11891  // equivalent to any of the permitted forms.
11892  for (auto Param : FnDecl->params()) {
11893  if (Param->hasDefaultArg()) {
11894  Diag(Param->getDefaultArgRange().getBegin(),
11895  diag::err_literal_operator_default_argument)
11896  << Param->getDefaultArgRange();
11897  break;
11898  }
11899  }
11900 
11901  StringRef LiteralName
11902  = FnDecl->getDeclName().getCXXLiteralIdentifier()->getName();
11903  if (LiteralName[0] != '_') {
11904  // C++11 [usrlit.suffix]p1:
11905  // Literal suffix identifiers that do not start with an underscore
11906  // are reserved for future standardization.
11907  Diag(FnDecl->getLocation(), diag::warn_user_literal_reserved)
11909  }
11910 
11911  return false;
11912 }
11913 
11914 /// ActOnStartLinkageSpecification - Parsed the beginning of a C++
11915 /// linkage specification, including the language and (if present)
11916 /// the '{'. ExternLoc is the location of the 'extern', Lang is the
11917 /// language string literal. LBraceLoc, if valid, provides the location of
11918 /// the '{' brace. Otherwise, this linkage specification does not
11919 /// have any braces.
11921  Expr *LangStr,
11922  SourceLocation LBraceLoc) {
11923  StringLiteral *Lit = cast<StringLiteral>(LangStr);
11924  if (!Lit->isAscii()) {
11925  Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_not_ascii)
11926  << LangStr->getSourceRange();
11927  return nullptr;
11928  }
11929 
11930  StringRef Lang = Lit->getString();
11932  if (Lang == "C")
11933  Language = LinkageSpecDecl::lang_c;
11934  else if (Lang == "C++")
11935  Language = LinkageSpecDecl::lang_cxx;
11936  else {
11937  Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_unknown)
11938  << LangStr->getSourceRange();
11939  return nullptr;
11940  }
11941 
11942  // FIXME: Add all the various semantics of linkage specifications
11943 
11944  LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext, ExternLoc,
11945  LangStr->getExprLoc(), Language,
11946  LBraceLoc.isValid());
11947  CurContext->addDecl(D);
11948  PushDeclContext(S, D);
11949  return D;
11950 }
11951 
11952 /// ActOnFinishLinkageSpecification - Complete the definition of
11953 /// the C++ linkage specification LinkageSpec. If RBraceLoc is
11954 /// valid, it's the position of the closing '}' brace in a linkage
11955 /// specification that uses braces.
11957  Decl *LinkageSpec,
11958  SourceLocation RBraceLoc) {
11959  if (RBraceLoc.isValid()) {
11960  LinkageSpecDecl* LSDecl = cast<LinkageSpecDecl>(LinkageSpec);
11961  LSDecl->setRBraceLoc(RBraceLoc);
11962  }
11963  PopDeclContext();
11964  return LinkageSpec;
11965 }
11966 
11968  AttributeList *AttrList,
11969  SourceLocation SemiLoc) {
11970  Decl *ED = EmptyDecl::Create(Context, CurContext, SemiLoc);
11971  // Attribute declarations appertain to empty declaration so we handle
11972  // them here.
11973  if (AttrList)
11974  ProcessDeclAttributeList(S, ED, AttrList);
11975 
11976  CurContext->addDecl(ED);
11977  return ED;
11978 }
11979 
11980 /// \brief Perform semantic analysis for the variable declaration that
11981 /// occurs within a C++ catch clause, returning the newly-created
11982 /// variable.
11984  TypeSourceInfo *TInfo,
11985  SourceLocation StartLoc,
11986  SourceLocation Loc,
11987  IdentifierInfo *Name) {
11988  bool Invalid = false;
11989  QualType ExDeclType = TInfo->getType();
11990 
11991  // Arrays and functions decay.
11992  if (ExDeclType->isArrayType())
11993  ExDeclType = Context.getArrayDecayedType(ExDeclType);
11994  else if (ExDeclType->isFunctionType())
11995  ExDeclType = Context.getPointerType(ExDeclType);
11996 
11997  // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
11998  // The exception-declaration shall not denote a pointer or reference to an
11999  // incomplete type, other than [cv] void*.
12000  // N2844 forbids rvalue references.
12001  if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
12002  Diag(Loc, diag::err_catch_rvalue_ref);
12003  Invalid = true;
12004  }
12005 
12006  QualType BaseType = ExDeclType;
12007  int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
12008  unsigned DK = diag::err_catch_incomplete;
12009  if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
12010  BaseType = Ptr->getPointeeType();
12011  Mode = 1;
12012  DK = diag::err_catch_incomplete_ptr;
12013  } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
12014  // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
12015  BaseType = Ref->getPointeeType();
12016  Mode = 2;
12017  DK = diag::err_catch_incomplete_ref;
12018  }
12019  if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
12020  !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
12021  Invalid = true;
12022 
12023  if (!Invalid && !ExDeclType->isDependentType() &&
12024  RequireNonAbstractType(Loc, ExDeclType,
12025  diag::err_abstract_type_in_decl,
12027  Invalid = true;
12028 
12029  // Only the non-fragile NeXT runtime currently supports C++ catches
12030  // of ObjC types, and no runtime supports catching ObjC types by value.
12031  if (!Invalid && getLangOpts().ObjC1) {
12032  QualType T = ExDeclType;
12033  if (const ReferenceType *RT = T->getAs<ReferenceType>())
12034  T = RT->getPointeeType();
12035 
12036  if (T->isObjCObjectType()) {
12037  Diag(Loc, diag::err_objc_object_catch);
12038  Invalid = true;
12039  } else if (T->isObjCObjectPointerType()) {
12040  // FIXME: should this be a test for macosx-fragile specifically?
12042  Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
12043  }
12044  }
12045 
12046  VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
12047  ExDeclType, TInfo, SC_None);
12048  ExDecl->setExceptionVariable(true);
12049 
12050  // In ARC, infer 'retaining' for variables of retainable type.
12051  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(ExDecl))
12052  Invalid = true;
12053 
12054  if (!Invalid && !ExDeclType->isDependentType()) {
12055  if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) {
12056  // Insulate this from anything else we might currently be parsing.
12058 
12059  // C++ [except.handle]p16:
12060  // The object declared in an exception-declaration or, if the
12061  // exception-declaration does not specify a name, a temporary (12.2) is
12062  // copy-initialized (8.5) from the exception object. [...]
12063  // The object is destroyed when the handler exits, after the destruction
12064  // of any automatic objects initialized within the handler.
12065  //
12066  // We just pretend to initialize the object with itself, then make sure
12067  // it can be destroyed later.
12068  QualType initType = Context.getExceptionObjectType(ExDeclType);
12069 
12070  InitializedEntity entity =
12072  InitializationKind initKind =
12074 
12075  Expr *opaqueValue =
12076  new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary);
12077  InitializationSequence sequence(*this, entity, initKind, opaqueValue);
12078  ExprResult result = sequence.Perform(*this, entity, initKind, opaqueValue);
12079  if (result.isInvalid())
12080  Invalid = true;
12081  else {
12082  // If the constructor used was non-trivial, set this as the
12083  // "initializer".
12085  if (!construct->getConstructor()->isTrivial()) {
12086  Expr *init = MaybeCreateExprWithCleanups(construct);
12087  ExDecl->setInit(init);
12088  }
12089 
12090  // And make sure it's destructable.
12091  FinalizeVarWithDestructor(ExDecl, recordType);
12092  }
12093  }
12094  }
12095 
12096  if (Invalid)
12097  ExDecl->setInvalidDecl();
12098 
12099  return ExDecl;
12100 }
12101 
12102 /// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
12103 /// handler.
12105  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
12106  bool Invalid = D.isInvalidType();
12107 
12108  // Check for unexpanded parameter packs.
12110  UPPC_ExceptionType)) {
12111  TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
12112  D.getIdentifierLoc());
12113  Invalid = true;
12114  }
12115 
12116  IdentifierInfo *II = D.getIdentifier();
12117  if (NamedDecl *PrevDecl = LookupSingleName(S, II, D.getIdentifierLoc(),
12119  ForRedeclaration)) {
12120  // The scope should be freshly made just for us. There is just no way
12121  // it contains any previous declaration, except for function parameters in
12122  // a function-try-block's catch statement.
12123  assert(!S->isDeclScope(PrevDecl));
12124  if (isDeclInScope(PrevDecl, CurContext, S)) {
12125  Diag(D.getIdentifierLoc(), diag::err_redefinition)
12126  << D.getIdentifier();
12127  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
12128  Invalid = true;
12129  } else if (PrevDecl->isTemplateParameter())
12130  // Maybe we will complain about the shadowed template parameter.
12132  }
12133 
12134  if (D.getCXXScopeSpec().isSet() && !Invalid) {
12135  Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
12136  << D.getCXXScopeSpec().getRange();
12137  Invalid = true;
12138  }
12139 
12140  VarDecl *ExDecl = BuildExceptionDeclaration(S, TInfo,
12141  D.getLocStart(),
12142  D.getIdentifierLoc(),
12143  D.getIdentifier());
12144  if (Invalid)
12145  ExDecl->setInvalidDecl();
12146 
12147  // Add the exception declaration into this scope.
12148  if (II)
12149  PushOnScopeChains(ExDecl, S);
12150  else
12151  CurContext->addDecl(ExDecl);
12152 
12153  ProcessDeclAttributes(S, ExDecl, D);
12154  return ExDecl;
12155 }
12156 
12158  Expr *AssertExpr,
12159  Expr *AssertMessageExpr,
12160  SourceLocation RParenLoc) {
12161  StringLiteral *AssertMessage =
12162  AssertMessageExpr ? cast<StringLiteral>(AssertMessageExpr) : nullptr;
12163 
12165  return nullptr;
12166 
12167  return BuildStaticAssertDeclaration(StaticAssertLoc, AssertExpr,
12168  AssertMessage, RParenLoc, false);
12169 }
12170 
12172  Expr *AssertExpr,
12173  StringLiteral *AssertMessage,
12174  SourceLocation RParenLoc,
12175  bool Failed) {
12176  assert(AssertExpr != nullptr && "Expected non-null condition");
12177  if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent() &&
12178  !Failed) {
12179  // In a static_assert-declaration, the constant-expression shall be a
12180  // constant expression that can be contextually converted to bool.
12181  ExprResult Converted = PerformContextuallyConvertToBool(AssertExpr);
12182  if (Converted.isInvalid())
12183  Failed = true;
12184 
12185  llvm::APSInt Cond;
12186  if (!Failed && VerifyIntegerConstantExpression(Converted.get(), &Cond,
12187  diag::err_static_assert_expression_is_not_constant,
12188  /*AllowFold=*/false).isInvalid())
12189  Failed = true;
12190 
12191  if (!Failed && !Cond) {
12192  SmallString<256> MsgBuffer;
12193  llvm::raw_svector_ostream Msg(MsgBuffer);
12194  if (AssertMessage)
12195  AssertMessage->printPretty(Msg, nullptr, getPrintingPolicy());
12196  Diag(StaticAssertLoc, diag::err_static_assert_failed)
12197  << !AssertMessage << Msg.str() << AssertExpr->getSourceRange();
12198  Failed = true;
12199  }
12200  }
12201 
12202  Decl *Decl = StaticAssertDecl::Create(Context, CurContext, StaticAssertLoc,
12203  AssertExpr, AssertMessage, RParenLoc,
12204  Failed);
12205 
12206  CurContext->addDecl(Decl);
12207  return Decl;
12208 }
12209 
12210 /// \brief Perform semantic analysis of the given friend type declaration.
12211 ///
12212 /// \returns A friend declaration that.
12214  SourceLocation FriendLoc,
12215  TypeSourceInfo *TSInfo) {
12216  assert(TSInfo && "NULL TypeSourceInfo for friend type declaration");
12217 
12218  QualType T = TSInfo->getType();
12219  SourceRange TypeRange = TSInfo->getTypeLoc().getLocalSourceRange();
12220 
12221  // C++03 [class.friend]p2:
12222  // An elaborated-type-specifier shall be used in a friend declaration
12223  // for a class.*
12224  //
12225  // * The class-key of the elaborated-type-specifier is required.
12226  if (!ActiveTemplateInstantiations.empty()) {
12227  // Do not complain about the form of friend template types during
12228  // template instantiation; we will already have complained when the
12229  // template was declared.
12230  } else {
12231  if (!T->isElaboratedTypeSpecifier()) {
12232  // If we evaluated the type to a record type, suggest putting
12233  // a tag in front.
12234  if (const RecordType *RT = T->getAs<RecordType>()) {
12235  RecordDecl *RD = RT->getDecl();
12236 
12237  SmallString<16> InsertionText(" ");
12238  InsertionText += RD->getKindName();
12239 
12240  Diag(TypeRange.getBegin(),
12241  getLangOpts().CPlusPlus11 ?
12242  diag::warn_cxx98_compat_unelaborated_friend_type :
12243  diag::ext_unelaborated_friend_type)
12244  << (unsigned) RD->getTagKind()
12245  << T
12247  InsertionText);
12248  } else {
12249  Diag(FriendLoc,
12251  diag::warn_cxx98_compat_nonclass_type_friend :
12252  diag::ext_nonclass_type_friend)
12253  << T
12254  << TypeRange;
12255  }
12256  } else if (T->getAs<EnumType>()) {
12257  Diag(FriendLoc,
12259  diag::warn_cxx98_compat_enum_friend :
12260  diag::ext_enum_friend)
12261  << T
12262  << TypeRange;
12263  }
12264 
12265  // C++11 [class.friend]p3:
12266  // A friend declaration that does not declare a function shall have one
12267  // of the following forms:
12268  // friend elaborated-type-specifier ;
12269  // friend simple-type-specifier ;
12270  // friend typename-specifier ;
12271  if (getLangOpts().CPlusPlus11 && LocStart != FriendLoc)
12272  Diag(FriendLoc, diag::err_friend_not_first_in_declaration) << T;
12273  }
12274 
12275  // If the type specifier in a friend declaration designates a (possibly
12276  // cv-qualified) class type, that class is declared as a friend; otherwise,
12277  // the friend declaration is ignored.
12278  return FriendDecl::Create(Context, CurContext,
12279  TSInfo->getTypeLoc().getLocStart(), TSInfo,
12280  FriendLoc);
12281 }
12282 
12283 /// Handle a friend tag declaration where the scope specifier was
12284 /// templated.
12286  unsigned TagSpec, SourceLocation TagLoc,
12287  CXXScopeSpec &SS,
12288  IdentifierInfo *Name,
12289  SourceLocation NameLoc,
12291  MultiTemplateParamsArg TempParamLists) {
12293 
12294  bool isExplicitSpecialization = false;
12295  bool Invalid = false;
12296 
12297  if (TemplateParameterList *TemplateParams =
12299  TagLoc, NameLoc, SS, nullptr, TempParamLists, /*friend*/ true,
12300  isExplicitSpecialization, Invalid)) {
12301  if (TemplateParams->size() > 0) {
12302  // This is a declaration of a class template.
12303  if (Invalid)
12304  return nullptr;
12305 
12306  return CheckClassTemplate(S, TagSpec, TUK_Friend, TagLoc, SS, Name,
12307  NameLoc, Attr, TemplateParams, AS_public,
12308  /*ModulePrivateLoc=*/SourceLocation(),
12309  FriendLoc, TempParamLists.size() - 1,
12310  TempParamLists.data()).get();
12311  } else {
12312  // The "template<>" header is extraneous.
12313  Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
12315  isExplicitSpecialization = true;
12316  }
12317  }
12318 
12319  if (Invalid) return nullptr;
12320 
12321  bool isAllExplicitSpecializations = true;
12322  for (unsigned I = TempParamLists.size(); I-- > 0; ) {
12323  if (TempParamLists[I]->size()) {
12324  isAllExplicitSpecializations = false;
12325  break;
12326  }
12327  }
12328 
12329  // FIXME: don't ignore attributes.
12330 
12331  // If it's explicit specializations all the way down, just forget
12332  // about the template header and build an appropriate non-templated
12333  // friend. TODO: for source fidelity, remember the headers.
12334  if (isAllExplicitSpecializations) {
12335  if (SS.isEmpty()) {
12336  bool Owned = false;
12337  bool IsDependent = false;
12338  return ActOnTag(S, TagSpec, TUK_Friend, TagLoc, SS, Name, NameLoc,
12339  Attr, AS_public,
12340  /*ModulePrivateLoc=*/SourceLocation(),
12341  MultiTemplateParamsArg(), Owned, IsDependent,
12342  /*ScopedEnumKWLoc=*/SourceLocation(),
12343  /*ScopedEnumUsesClassTag=*/false,
12344  /*UnderlyingType=*/TypeResult(),
12345  /*IsTypeSpecifier=*/false);
12346  }
12347 
12348  NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
12349  ElaboratedTypeKeyword Keyword
12351  QualType T = CheckTypenameType(Keyword, TagLoc, QualifierLoc,
12352  *Name, NameLoc);
12353  if (T.isNull())
12354  return nullptr;
12355 
12356  TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
12357  if (isa<DependentNameType>(T)) {
12360  TL.setElaboratedKeywordLoc(TagLoc);
12361  TL.setQualifierLoc(QualifierLoc);
12362  TL.setNameLoc(NameLoc);
12363  } else {
12365  TL.setElaboratedKeywordLoc(TagLoc);
12366  TL.setQualifierLoc(QualifierLoc);
12367  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(NameLoc);
12368  }
12369 
12370  FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
12371  TSI, FriendLoc, TempParamLists);
12372  Friend->setAccess(AS_public);
12373  CurContext->addDecl(Friend);
12374  return Friend;
12375  }
12376 
12377  assert(SS.isNotEmpty() && "valid templated tag with no SS and no direct?");
12378 
12379 
12380 
12381  // Handle the case of a templated-scope friend class. e.g.
12382  // template <class T> class A<T>::B;
12383  // FIXME: we don't support these right now.
12384  Diag(NameLoc, diag::warn_template_qualified_friend_unsupported)
12385  << SS.getScopeRep() << SS.getRange() << cast<CXXRecordDecl>(CurContext);
12387  QualType T = Context.getDependentNameType(ETK, SS.getScopeRep(), Name);
12388  TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
12390  TL.setElaboratedKeywordLoc(TagLoc);
12391  TL.setQualifierLoc(SS.getWithLocInContext(Context));
12392  TL.setNameLoc(NameLoc);
12393 
12394  FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
12395  TSI, FriendLoc, TempParamLists);
12396  Friend->setAccess(AS_public);
12397  Friend->setUnsupportedFriend(true);
12398  CurContext->addDecl(Friend);
12399  return Friend;
12400 }
12401 
12402 
12403 /// Handle a friend type declaration. This works in tandem with
12404 /// ActOnTag.
12405 ///
12406 /// Notes on friend class templates:
12407 ///
12408 /// We generally treat friend class declarations as if they were
12409 /// declaring a class. So, for example, the elaborated type specifier
12410 /// in a friend declaration is required to obey the restrictions of a
12411 /// class-head (i.e. no typedefs in the scope chain), template
12412 /// parameters are required to match up with simple template-ids, &c.
12413 /// However, unlike when declaring a template specialization, it's
12414 /// okay to refer to a template specialization without an empty
12415 /// template parameter declaration, e.g.
12416 /// friend class A<T>::B<unsigned>;
12417 /// We permit this as a special case; if there are any template
12418 /// parameters present at all, require proper matching, i.e.
12419 /// template <> template <class T> friend class A<int>::B;
12421  MultiTemplateParamsArg TempParams) {
12422  SourceLocation Loc = DS.getLocStart();
12423 
12424  assert(DS.isFriendSpecified());
12426 
12427  // Try to convert the decl specifier to a type. This works for
12428  // friend templates because ActOnTag never produces a ClassTemplateDecl
12429  // for a TUK_Friend.
12430  Declarator TheDeclarator(DS, Declarator::MemberContext);
12431  TypeSourceInfo *TSI = GetTypeForDeclarator(TheDeclarator, S);
12432  QualType T = TSI->getType();
12433  if (TheDeclarator.isInvalidType())
12434  return nullptr;
12435 
12437  return nullptr;
12438 
12439  // This is definitely an error in C++98. It's probably meant to
12440  // be forbidden in C++0x, too, but the specification is just
12441  // poorly written.
12442  //
12443  // The problem is with declarations like the following:
12444  // template <T> friend A<T>::foo;
12445  // where deciding whether a class C is a friend or not now hinges
12446  // on whether there exists an instantiation of A that causes
12447  // 'foo' to equal C. There are restrictions on class-heads
12448  // (which we declare (by fiat) elaborated friend declarations to
12449  // be) that makes this tractable.
12450  //
12451  // FIXME: handle "template <> friend class A<T>;", which
12452  // is possibly well-formed? Who even knows?
12453  if (TempParams.size() && !T->isElaboratedTypeSpecifier()) {
12454  Diag(Loc, diag::err_tagless_friend_type_template)
12455  << DS.getSourceRange();
12456  return nullptr;
12457  }
12458 
12459  // C++98 [class.friend]p1: A friend of a class is a function
12460  // or class that is not a member of the class . . .
12461  // This is fixed in DR77, which just barely didn't make the C++03
12462  // deadline. It's also a very silly restriction that seriously
12463  // affects inner classes and which nobody else seems to implement;
12464  // thus we never diagnose it, not even in -pedantic.
12465  //
12466  // But note that we could warn about it: it's always useless to
12467  // friend one of your own members (it's not, however, worthless to
12468  // friend a member of an arbitrary specialization of your template).
12469 
12470  Decl *D;
12471  if (unsigned NumTempParamLists = TempParams.size())
12472  D = FriendTemplateDecl::Create(Context, CurContext, Loc,
12473  NumTempParamLists,
12474  TempParams.data(),
12475  TSI,
12476  DS.getFriendSpecLoc());
12477  else
12478  D = CheckFriendTypeDecl(Loc, DS.getFriendSpecLoc(), TSI);
12479 
12480  if (!D)
12481  return nullptr;
12482 
12483  D->setAccess(AS_public);
12484  CurContext->addDecl(D);
12485 
12486  return D;
12487 }
12488 
12490  MultiTemplateParamsArg TemplateParams) {
12491  const DeclSpec &DS = D.getDeclSpec();
12492 
12493  assert(DS.isFriendSpecified());
12495 
12496  SourceLocation Loc = D.getIdentifierLoc();
12497  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
12498 
12499  // C++ [class.friend]p1
12500  // A friend of a class is a function or class....
12501  // Note that this sees through typedefs, which is intended.
12502  // It *doesn't* see through dependent types, which is correct
12503  // according to [temp.arg.type]p3:
12504  // If a declaration acquires a function type through a
12505  // type dependent on a template-parameter and this causes
12506  // a declaration that does not use the syntactic form of a
12507  // function declarator to have a function type, the program
12508  // is ill-formed.
12509  if (!TInfo->getType()->isFunctionType()) {
12510  Diag(Loc, diag::err_unexpected_friend);
12511 
12512  // It might be worthwhile to try to recover by creating an
12513  // appropriate declaration.
12514  return nullptr;
12515  }
12516 
12517  // C++ [namespace.memdef]p3
12518  // - If a friend declaration in a non-local class first declares a
12519  // class or function, the friend class or function is a member
12520  // of the innermost enclosing namespace.
12521  // - The name of the friend is not found by simple name lookup
12522  // until a matching declaration is provided in that namespace
12523  // scope (either before or after the class declaration granting
12524  // friendship).
12525  // - If a friend function is called, its name may be found by the
12526  // name lookup that considers functions from namespaces and
12527  // classes associated with the types of the function arguments.
12528  // - When looking for a prior declaration of a class or a function
12529  // declared as a friend, scopes outside the innermost enclosing
12530  // namespace scope are not considered.
12531 
12532  CXXScopeSpec &SS = D.getCXXScopeSpec();
12534  DeclarationName Name = NameInfo.getName();
12535  assert(Name);
12536 
12537  // Check for unexpanded parameter packs.
12541  return nullptr;
12542 
12543  // The context we found the declaration in, or in which we should
12544  // create the declaration.
12545  DeclContext *DC;
12546  Scope *DCScope = S;
12547  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
12549 
12550  // There are five cases here.
12551  // - There's no scope specifier and we're in a local class. Only look
12552  // for functions declared in the immediately-enclosing block scope.
12553  // We recover from invalid scope qualifiers as if they just weren't there.
12554  FunctionDecl *FunctionContainingLocalClass = nullptr;
12555  if ((SS.isInvalid() || !SS.isSet()) &&
12556  (FunctionContainingLocalClass =
12557  cast<CXXRecordDecl>(CurContext)->isLocalClass())) {
12558  // C++11 [class.friend]p11:
12559  // If a friend declaration appears in a local class and the name
12560  // specified is an unqualified name, a prior declaration is
12561  // looked up without considering scopes that are outside the
12562  // innermost enclosing non-class scope. For a friend function
12563  // declaration, if there is no prior declaration, the program is
12564  // ill-formed.
12565 
12566  // Find the innermost enclosing non-class scope. This is the block
12567  // scope containing the local class definition (or for a nested class,
12568  // the outer local class).
12569  DCScope = S->getFnParent();
12570 
12571  // Look up the function name in the scope.
12572  Previous.clear(LookupLocalFriendName);
12573  LookupName(Previous, S, /*AllowBuiltinCreation*/false);
12574 
12575  if (!Previous.empty()) {
12576  // All possible previous declarations must have the same context:
12577  // either they were declared at block scope or they are members of
12578  // one of the enclosing local classes.
12579  DC = Previous.getRepresentativeDecl()->getDeclContext();
12580  } else {
12581  // This is ill-formed, but provide the context that we would have
12582  // declared the function in, if we were permitted to, for error recovery.
12583  DC = FunctionContainingLocalClass;
12584  }
12586 
12587  // C++ [class.friend]p6:
12588  // A function can be defined in a friend declaration of a class if and
12589  // only if the class is a non-local class (9.8), the function name is
12590  // unqualified, and the function has namespace scope.
12591  if (D.isFunctionDefinition()) {
12592  Diag(NameInfo.getBeginLoc(), diag::err_friend_def_in_local_class);
12593  }
12594 
12595  // - There's no scope specifier, in which case we just go to the
12596  // appropriate scope and look for a function or function template
12597  // there as appropriate.
12598  } else if (SS.isInvalid() || !SS.isSet()) {
12599  // C++11 [namespace.memdef]p3:
12600  // If the name in a friend declaration is neither qualified nor
12601  // a template-id and the declaration is a function or an
12602  // elaborated-type-specifier, the lookup to determine whether
12603  // the entity has been previously declared shall not consider
12604  // any scopes outside the innermost enclosing namespace.
12605  bool isTemplateId = D.getName().getKind() == UnqualifiedId::IK_TemplateId;
12606 
12607  // Find the appropriate context according to the above.
12608  DC = CurContext;
12609 
12610  // Skip class contexts. If someone can cite chapter and verse
12611  // for this behavior, that would be nice --- it's what GCC and
12612  // EDG do, and it seems like a reasonable intent, but the spec
12613  // really only says that checks for unqualified existing
12614  // declarations should stop at the nearest enclosing namespace,
12615  // not that they should only consider the nearest enclosing
12616  // namespace.
12617  while (DC->isRecord())
12618  DC = DC->getParent();
12619 
12620  DeclContext *LookupDC = DC;
12621  while (LookupDC->isTransparentContext())
12622  LookupDC = LookupDC->getParent();
12623 
12624  while (true) {
12625  LookupQualifiedName(Previous, LookupDC);
12626 
12627  if (!Previous.empty()) {
12628  DC = LookupDC;
12629  break;
12630  }
12631 
12632  if (isTemplateId) {
12633  if (isa<TranslationUnitDecl>(LookupDC)) break;
12634  } else {
12635  if (LookupDC->isFileContext()) break;
12636  }
12637  LookupDC = LookupDC->getParent();
12638  }
12639 
12640  DCScope = getScopeForDeclContext(S, DC);
12641 
12642  // - There's a non-dependent scope specifier, in which case we
12643  // compute it and do a previous lookup there for a function
12644  // or function template.
12645  } else if (!SS.getScopeRep()->isDependent()) {
12646  DC = computeDeclContext(SS);
12647  if (!DC) return nullptr;
12648 
12649  if (RequireCompleteDeclContext(SS, DC)) return nullptr;
12650 
12651  LookupQualifiedName(Previous, DC);
12652 
12653  // Ignore things found implicitly in the wrong scope.
12654  // TODO: better diagnostics for this case. Suggesting the right
12655  // qualified scope would be nice...
12656  LookupResult::Filter F = Previous.makeFilter();
12657  while (F.hasNext()) {
12658  NamedDecl *D = F.next();
12659  if (!DC->InEnclosingNamespaceSetOf(
12661  F.erase();
12662  }
12663  F.done();
12664 
12665  if (Previous.empty()) {
12666  D.setInvalidType();
12667  Diag(Loc, diag::err_qualified_friend_not_found)
12668  << Name << TInfo->getType();
12669  return nullptr;
12670  }
12671 
12672  // C++ [class.friend]p1: A friend of a class is a function or
12673  // class that is not a member of the class . . .
12674  if (DC->Equals(CurContext))
12675  Diag(DS.getFriendSpecLoc(),
12676  getLangOpts().CPlusPlus11 ?
12677  diag::warn_cxx98_compat_friend_is_member :
12678  diag::err_friend_is_member);
12679 
12680  if (D.isFunctionDefinition()) {
12681  // C++ [class.friend]p6:
12682  // A function can be defined in a friend declaration of a class if and
12683  // only if the class is a non-local class (9.8), the function name is
12684  // unqualified, and the function has namespace scope.
12686  = Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def);
12687 
12688  DB << SS.getScopeRep();
12689  if (DC->isFileContext())
12690  DB << FixItHint::CreateRemoval(SS.getRange());
12691  SS.clear();
12692  }
12693 
12694  // - There's a scope specifier that does not match any template
12695  // parameter lists, in which case we use some arbitrary context,
12696  // create a method or method template, and wait for instantiation.
12697  // - There's a scope specifier that does match some template
12698  // parameter lists, which we don't handle right now.
12699  } else {
12700  if (D.isFunctionDefinition()) {
12701  // C++ [class.friend]p6:
12702  // A function can be defined in a friend declaration of a class if and
12703  // only if the class is a non-local class (9.8), the function name is
12704  // unqualified, and the function has namespace scope.
12705  Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def)
12706  << SS.getScopeRep();
12707  }
12708 
12709  DC = CurContext;
12710  assert(isa<CXXRecordDecl>(DC) && "friend declaration not in class?");
12711  }
12712 
12713  if (!DC->isRecord()) {
12714  int DiagArg = -1;
12715  switch (D.getName().getKind()) {
12718  DiagArg = 0;
12719  break;
12721  DiagArg = 1;
12722  break;
12724  DiagArg = 2;
12725  break;
12731  break;
12732  }
12733  // This implies that it has to be an operator or function.
12734  if (DiagArg >= 0) {
12735  Diag(Loc, diag::err_introducing_special_friend) << DiagArg;
12736  return nullptr;
12737  }
12738  }
12739 
12740  // FIXME: This is an egregious hack to cope with cases where the scope stack
12741  // does not contain the declaration context, i.e., in an out-of-line
12742  // definition of a class.
12743  Scope FakeDCScope(S, Scope::DeclScope, Diags);
12744  if (!DCScope) {
12745  FakeDCScope.setEntity(DC);
12746  DCScope = &FakeDCScope;
12747  }
12748 
12749  bool AddToScope = true;
12750  NamedDecl *ND = ActOnFunctionDeclarator(DCScope, D, DC, TInfo, Previous,
12751  TemplateParams, AddToScope);
12752  if (!ND) return nullptr;
12753 
12754  assert(ND->getLexicalDeclContext() == CurContext);
12755 
12756  // If we performed typo correction, we might have added a scope specifier
12757  // and changed the decl context.
12758  DC = ND->getDeclContext();
12759 
12760  // Add the function declaration to the appropriate lookup tables,
12761  // adjusting the redeclarations list as necessary. We don't
12762  // want to do this yet if the friending class is dependent.
12763  //
12764  // Also update the scope-based lookup if the target context's
12765  // lookup context is in lexical scope.
12766  if (!CurContext->isDependentContext()) {
12767  DC = DC->getRedeclContext();
12768  DC->makeDeclVisibleInContext(ND);
12769  if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
12770  PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
12771  }
12772 
12773  FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
12774  D.getIdentifierLoc(), ND,
12775  DS.getFriendSpecLoc());
12776  FrD->setAccess(AS_public);
12777  CurContext->addDecl(FrD);
12778 
12779  if (ND->isInvalidDecl()) {
12780  FrD->setInvalidDecl();
12781  } else {
12782  if (DC->isRecord()) CheckFriendAccess(ND);
12783 
12784  FunctionDecl *FD;
12785  if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
12786  FD = FTD->getTemplatedDecl();
12787  else
12788  FD = cast<FunctionDecl>(ND);
12789 
12790  // C++11 [dcl.fct.default]p4: If a friend declaration specifies a
12791  // default argument expression, that declaration shall be a definition
12792  // and shall be the only declaration of the function or function
12793  // template in the translation unit.
12795  if (FunctionDecl *OldFD = FD->getPreviousDecl()) {
12796  Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
12797  Diag(OldFD->getLocation(), diag::note_previous_declaration);
12798  } else if (!D.isFunctionDefinition())
12799  Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_must_be_def);
12800  }
12801 
12802  // Mark templated-scope function declarations as unsupported.
12803  if (FD->getNumTemplateParameterLists() && SS.isValid()) {
12804  Diag(FD->getLocation(), diag::warn_template_qualified_friend_unsupported)
12805  << SS.getScopeRep() << SS.getRange()
12806  << cast<CXXRecordDecl>(CurContext);
12807  FrD->setUnsupportedFriend(true);
12808  }
12809  }
12810 
12811  return ND;
12812 }
12813 
12814 void Sema::SetDeclDeleted(Decl *Dcl, SourceLocation DelLoc) {
12815  AdjustDeclIfTemplate(Dcl);
12816 
12817  FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Dcl);
12818  if (!Fn) {
12819  Diag(DelLoc, diag::err_deleted_non_function);
12820  return;
12821  }
12822 
12823  if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
12824  // Don't consider the implicit declaration we generate for explicit
12825  // specializations. FIXME: Do not generate these implicit declarations.
12826  if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization ||
12827  Prev->getPreviousDecl()) &&
12828  !Prev->isDefined()) {
12829  Diag(DelLoc, diag::err_deleted_decl_not_first);
12830  Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
12831  Prev->isImplicit() ? diag::note_previous_implicit_declaration
12832  : diag::note_previous_declaration);
12833  }
12834  // If the declaration wasn't the first, we delete the function anyway for
12835  // recovery.
12836  Fn = Fn->getCanonicalDecl();
12837  }
12838 
12839  // dllimport/dllexport cannot be deleted.
12840  if (const InheritableAttr *DLLAttr = getDLLAttr(Fn)) {
12841  Diag(Fn->getLocation(), diag::err_attribute_dll_deleted) << DLLAttr;
12842  Fn->setInvalidDecl();
12843  }
12844 
12845  if (Fn->isDeleted())
12846  return;
12847 
12848  // See if we're deleting a function which is already known to override a
12849  // non-deleted virtual function.
12850  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn)) {
12851  bool IssuedDiagnostic = false;
12853  E = MD->end_overridden_methods();
12854  I != E; ++I) {
12855  if (!(*MD->begin_overridden_methods())->isDeleted()) {
12856  if (!IssuedDiagnostic) {
12857  Diag(DelLoc, diag::err_deleted_override) << MD->getDeclName();
12858  IssuedDiagnostic = true;
12859  }
12860  Diag((*I)->getLocation(), diag::note_overridden_virtual_function);
12861  }
12862  }
12863  }
12864 
12865  // C++11 [basic.start.main]p3:
12866  // A program that defines main as deleted [...] is ill-formed.
12867  if (Fn->isMain())
12868  Diag(DelLoc, diag::err_deleted_main);
12869 
12870  Fn->setDeletedAsWritten();
12871 }
12872 
12873 void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) {
12874  CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Dcl);
12875 
12876  if (MD) {
12877  if (MD->getParent()->isDependentType()) {
12878  MD->setDefaulted();
12879  MD->setExplicitlyDefaulted();
12880  return;
12881  }
12882 
12883  CXXSpecialMember Member = getSpecialMember(MD);
12884  if (Member == CXXInvalid) {
12885  if (!MD->isInvalidDecl())
12886  Diag(DefaultLoc, diag::err_default_special_members);
12887  return;
12888  }
12889 
12890  MD->setDefaulted();
12891  MD->setExplicitlyDefaulted();
12892 
12893  // If this definition appears within the record, do the checking when
12894  // the record is complete.
12895  const FunctionDecl *Primary = MD;
12896  if (const FunctionDecl *Pattern = MD->getTemplateInstantiationPattern())
12897  // Find the uninstantiated declaration that actually had the '= default'
12898  // on it.
12899  Pattern->isDefined(Primary);
12900 
12901  // If the method was defaulted on its first declaration, we will have
12902  // already performed the checking in CheckCompletedCXXClass. Such a
12903  // declaration doesn't trigger an implicit definition.
12904  if (Primary == Primary->getCanonicalDecl())
12905  return;
12906 
12908 
12909  if (MD->isInvalidDecl())
12910  return;
12911 
12912  switch (Member) {
12913  case CXXDefaultConstructor:
12915  cast<CXXConstructorDecl>(MD));
12916  break;
12917  case CXXCopyConstructor:
12918  DefineImplicitCopyConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
12919  break;
12920  case CXXCopyAssignment:
12921  DefineImplicitCopyAssignment(DefaultLoc, MD);
12922  break;
12923  case CXXDestructor:
12924  DefineImplicitDestructor(DefaultLoc, cast<CXXDestructorDecl>(MD));
12925  break;
12926  case CXXMoveConstructor:
12927  DefineImplicitMoveConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
12928  break;
12929  case CXXMoveAssignment:
12930  DefineImplicitMoveAssignment(DefaultLoc, MD);
12931  break;
12932  case CXXInvalid:
12933  llvm_unreachable("Invalid special member.");
12934  }
12935  } else {
12936  Diag(DefaultLoc, diag::err_default_special_members);
12937  }
12938 }
12939 
12940 static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
12941  for (Stmt *SubStmt : S->children()) {
12942  if (!SubStmt)
12943  continue;
12944  if (isa<ReturnStmt>(SubStmt))
12945  Self.Diag(SubStmt->getLocStart(),
12946  diag::err_return_in_constructor_handler);
12947  if (!isa<Expr>(SubStmt))
12948  SearchForReturnInStmt(Self, SubStmt);
12949  }
12950 }
12951 
12953  for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
12954  CXXCatchStmt *Handler = TryBlock->getHandler(I);
12955  SearchForReturnInStmt(*this, Handler);
12956  }
12957 }
12958 
12960  const CXXMethodDecl *Old) {
12961  const FunctionType *NewFT = New->getType()->getAs<FunctionType>();
12962  const FunctionType *OldFT = Old->getType()->getAs<FunctionType>();
12963 
12964  CallingConv NewCC = NewFT->getCallConv(), OldCC = OldFT->getCallConv();
12965 
12966  // If the calling conventions match, everything is fine
12967  if (NewCC == OldCC)
12968  return false;
12969 
12970  // If the calling conventions mismatch because the new function is static,
12971  // suppress the calling convention mismatch error; the error about static
12972  // function override (err_static_overrides_virtual from
12973  // Sema::CheckFunctionDeclaration) is more clear.
12974  if (New->getStorageClass() == SC_Static)
12975  return false;
12976 
12977  Diag(New->getLocation(),
12978  diag::err_conflicting_overriding_cc_attributes)
12979  << New->getDeclName() << New->getType() << Old->getType();
12980  Diag(Old->getLocation(), diag::note_overridden_virtual_function);
12981  return true;
12982 }
12983 
12985  const CXXMethodDecl *Old) {
12986  QualType NewTy = New->getType()->getAs<FunctionType>()->getReturnType();
12987  QualType OldTy = Old->getType()->getAs<FunctionType>()->getReturnType();
12988 
12989  if (Context.hasSameType(NewTy, OldTy) ||
12990  NewTy->isDependentType() || OldTy->isDependentType())
12991  return false;
12992 
12993  // Check if the return types are covariant
12994  QualType NewClassTy, OldClassTy;
12995 
12996  /// Both types must be pointers or references to classes.
12997  if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
12998  if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
12999  NewClassTy = NewPT->getPointeeType();
13000  OldClassTy = OldPT->getPointeeType();
13001  }
13002  } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
13003  if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
13004  if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
13005  NewClassTy = NewRT->getPointeeType();
13006  OldClassTy = OldRT->getPointeeType();
13007  }
13008  }
13009  }
13010 
13011  // The return types aren't either both pointers or references to a class type.
13012  if (NewClassTy.isNull()) {
13013  Diag(New->getLocation(),
13014  diag::err_different_return_type_for_overriding_virtual_function)
13015  << New->getDeclName() << NewTy << OldTy
13016  << New->getReturnTypeSourceRange();
13017  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
13018  << Old->getReturnTypeSourceRange();
13019 
13020  return true;
13021  }
13022 
13023  // C++ [class.virtual]p6:
13024  // If the return type of D::f differs from the return type of B::f, the
13025  // class type in the return type of D::f shall be complete at the point of
13026  // declaration of D::f or shall be the class type D.
13027  if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
13028  if (!RT->isBeingDefined() &&
13029  RequireCompleteType(New->getLocation(), NewClassTy,
13030  diag::err_covariant_return_incomplete,
13031  New->getDeclName()))
13032  return true;
13033  }
13034 
13035  if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
13036  // Check if the new class derives from the old class.
13037  if (!IsDerivedFrom(New->getLocation(), NewClassTy, OldClassTy)) {
13038  Diag(New->getLocation(), diag::err_covariant_return_not_derived)
13039  << New->getDeclName() << NewTy << OldTy
13040  << New->getReturnTypeSourceRange();
13041  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
13042  << Old->getReturnTypeSourceRange();
13043  return true;
13044  }
13045 
13046  // Check if we the conversion from derived to base is valid.
13048  NewClassTy, OldClassTy,
13049  diag::err_covariant_return_inaccessible_base,
13050  diag::err_covariant_return_ambiguous_derived_to_base_conv,
13051  New->getLocation(), New->getReturnTypeSourceRange(),
13052  New->getDeclName(), nullptr)) {
13053  // FIXME: this note won't trigger for delayed access control
13054  // diagnostics, and it's impossible to get an undelayed error
13055  // here from access control during the original parse because
13056  // the ParsingDeclSpec/ParsingDeclarator are still in scope.
13057  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
13058  << Old->getReturnTypeSourceRange();
13059  return true;
13060  }
13061  }
13062 
13063  // The qualifiers of the return types must be the same.
13064  if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
13065  Diag(New->getLocation(),
13066  diag::err_covariant_return_type_different_qualifications)
13067  << New->getDeclName() << NewTy << OldTy
13068  << New->getReturnTypeSourceRange();
13069  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
13070  << Old->getReturnTypeSourceRange();
13071  return true;
13072  };
13073 
13074 
13075  // The new class type must have the same or less qualifiers as the old type.
13076  if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
13077  Diag(New->getLocation(),
13078  diag::err_covariant_return_type_class_type_more_qualified)
13079  << New->getDeclName() << NewTy << OldTy
13080  << New->getReturnTypeSourceRange();
13081  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
13082  << Old->getReturnTypeSourceRange();
13083  return true;
13084  };
13085 
13086  return false;
13087 }
13088 
13089 /// \brief Mark the given method pure.
13090 ///
13091 /// \param Method the method to be marked pure.
13092 ///
13093 /// \param InitRange the source range that covers the "0" initializer.
13095  SourceLocation EndLoc = InitRange.getEnd();
13096  if (EndLoc.isValid())
13097  Method->setRangeEnd(EndLoc);
13098 
13099  if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
13100  Method->setPure();
13101  return false;
13102  }
13103 
13104  if (!Method->isInvalidDecl())
13105  Diag(Method->getLocation(), diag::err_non_virtual_pure)
13106  << Method->getDeclName() << InitRange;
13107  return true;
13108 }
13109 
13111  if (D->getFriendObjectKind())
13112  Diag(D->getLocation(), diag::err_pure_friend);
13113  else if (auto *M = dyn_cast<CXXMethodDecl>(D))
13114  CheckPureMethod(M, ZeroLoc);
13115  else
13116  Diag(D->getLocation(), diag::err_illegal_initializer);
13117 }
13118 
13119 /// \brief Determine whether the given declaration is a static data member.
13120 static bool isStaticDataMember(const Decl *D) {
13121  if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(D))
13122  return Var->isStaticDataMember();
13123 
13124  return false;
13125 }
13126 
13127 /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse
13128 /// an initializer for the out-of-line declaration 'Dcl'. The scope
13129 /// is a fresh scope pushed for just this purpose.
13130 ///
13131 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
13132 /// static data member of class X, names should be looked up in the scope of
13133 /// class X.
13135  // If there is no declaration, there was an error parsing it.
13136  if (!D || D->isInvalidDecl())
13137  return;
13138 
13139  // We will always have a nested name specifier here, but this declaration
13140  // might not be out of line if the specifier names the current namespace:
13141  // extern int n;
13142  // int ::n = 0;
13143  if (D->isOutOfLine())
13145 
13146  // If we are parsing the initializer for a static data member, push a
13147  // new expression evaluation context that is associated with this static
13148  // data member.
13149  if (isStaticDataMember(D))
13151 }
13152 
13153 /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
13154 /// initializer for the out-of-line declaration 'D'.
13156  // If there is no declaration, there was an error parsing it.
13157  if (!D || D->isInvalidDecl())
13158  return;
13159 
13160  if (isStaticDataMember(D))
13162 
13163  if (D->isOutOfLine())
13165 }
13166 
13167 /// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
13168 /// C++ if/switch/while/for statement.
13169 /// e.g: "if (int x = f()) {...}"
13171  // C++ 6.4p2:
13172  // The declarator shall not specify a function or an array.
13173  // The type-specifier-seq shall not contain typedef and shall not declare a
13174  // new class or enumeration.
13176  "Parser allowed 'typedef' as storage class of condition decl.");
13177 
13178  Decl *Dcl = ActOnDeclarator(S, D);
13179  if (!Dcl)
13180  return true;
13181 
13182  if (isa<FunctionDecl>(Dcl)) { // The declarator shall not specify a function.
13183  Diag(Dcl->getLocation(), diag::err_invalid_use_of_function_type)
13184  << D.getSourceRange();
13185  return true;
13186  }
13187 
13188  return Dcl;
13189 }
13190 
13192  if (!ExternalSource)
13193  return;
13194 
13196  ExternalSource->ReadUsedVTables(VTables);
13197  SmallVector<VTableUse, 4> NewUses;
13198  for (unsigned I = 0, N = VTables.size(); I != N; ++I) {
13200  = VTablesUsed.find(VTables[I].Record);
13201  // Even if a definition wasn't required before, it may be required now.
13202  if (Pos != VTablesUsed.end()) {
13203  if (!Pos->second && VTables[I].DefinitionRequired)
13204  Pos->second = true;
13205  continue;
13206  }
13207 
13208  VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
13209  NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location));
13210  }
13211 
13212  VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end());
13213 }
13214 
13216  bool DefinitionRequired) {
13217  // Ignore any vtable uses in unevaluated operands or for classes that do
13218  // not have a vtable.
13219  if (!Class->isDynamicClass() || Class->isDependentContext() ||
13221  return;
13222 
13223  // Try to insert this class into the map.
13225  Class = cast<CXXRecordDecl>(Class->getCanonicalDecl());
13227  Pos = VTablesUsed.insert(std::make_pair(Class, DefinitionRequired));
13228  if (!Pos.second) {
13229  // If we already had an entry, check to see if we are promoting this vtable
13230  // to require a definition. If so, we need to reappend to the VTableUses
13231  // list, since we may have already processed the first entry.
13232  if (DefinitionRequired && !Pos.first->second) {
13233  Pos.first->second = true;
13234  } else {
13235  // Otherwise, we can early exit.
13236  return;
13237  }
13238  } else {
13239  // The Microsoft ABI requires that we perform the destructor body
13240  // checks (i.e. operator delete() lookup) when the vtable is marked used, as
13241  // the deleting destructor is emitted with the vtable, not with the
13242  // destructor definition as in the Itanium ABI.
13243  // If it has a definition, we do the check at that point instead.
13244  if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
13245  Class->hasUserDeclaredDestructor() &&
13246  !Class->getDestructor()->isDefined() &&
13247  !Class->getDestructor()->isDeleted()) {
13248  CXXDestructorDecl *DD = Class->getDestructor();
13249  ContextRAII SavedContext(*this, DD);
13250  CheckDestructor(DD);
13251  }
13252  }
13253 
13254  // Local classes need to have their virtual members marked
13255  // immediately. For all other classes, we mark their virtual members
13256  // at the end of the translation unit.
13257  if (Class->isLocalClass())
13258  MarkVirtualMembersReferenced(Loc, Class);
13259  else
13260  VTableUses.push_back(std::make_pair(Class, Loc));
13261 }
13262 
13265  if (VTableUses.empty())
13266  return false;
13267 
13268  // Note: The VTableUses vector could grow as a result of marking
13269  // the members of a class as "used", so we check the size each
13270  // time through the loop and prefer indices (which are stable) to
13271  // iterators (which are not).
13272  bool DefinedAnything = false;
13273  for (unsigned I = 0; I != VTableUses.size(); ++I) {
13274  CXXRecordDecl *Class = VTableUses[I].first->getDefinition();
13275  if (!Class)
13276  continue;
13277 
13278  SourceLocation Loc = VTableUses[I].second;
13279 
13280  bool DefineVTable = true;
13281 
13282  // If this class has a key function, but that key function is
13283  // defined in another translation unit, we don't need to emit the
13284  // vtable even though we're using it.
13285  const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(Class);
13286  if (KeyFunction && !KeyFunction->hasBody()) {
13287  // The key function is in another translation unit.
13288  DefineVTable = false;
13290  KeyFunction->getTemplateSpecializationKind();
13291  assert(TSK != TSK_ExplicitInstantiationDefinition &&
13292  TSK != TSK_ImplicitInstantiation &&
13293  "Instantiations don't have key functions");
13294  (void)TSK;
13295  } else if (!KeyFunction) {
13296  // If we have a class with no key function that is the subject
13297  // of an explicit instantiation declaration, suppress the
13298  // vtable; it will live with the explicit instantiation
13299  // definition.
13300  bool IsExplicitInstantiationDeclaration
13303  for (auto R : Class->redecls()) {
13305  = cast<CXXRecordDecl>(R)->getTemplateSpecializationKind();
13307  IsExplicitInstantiationDeclaration = true;
13308  else if (TSK == TSK_ExplicitInstantiationDefinition) {
13309  IsExplicitInstantiationDeclaration = false;
13310  break;
13311  }
13312  }
13313 
13314  if (IsExplicitInstantiationDeclaration)
13315  DefineVTable = false;
13316  }
13317 
13318  // The exception specifications for all virtual members may be needed even
13319  // if we are not providing an authoritative form of the vtable in this TU.
13320  // We may choose to emit it available_externally anyway.
13321  if (!DefineVTable) {
13323  continue;
13324  }
13325 
13326  // Mark all of the virtual members of this class as referenced, so
13327  // that we can build a vtable. Then, tell the AST consumer that a
13328  // vtable for this class is required.
13329  DefinedAnything = true;
13330  MarkVirtualMembersReferenced(Loc, Class);
13331  CXXRecordDecl *Canonical = cast<CXXRecordDecl>(Class->getCanonicalDecl());
13332  if (VTablesUsed[Canonical])
13333  Consumer.HandleVTable(Class);
13334 
13335  // Optionally warn if we're emitting a weak vtable.
13336  if (Class->isExternallyVisible() &&
13338  const FunctionDecl *KeyFunctionDef = nullptr;
13339  if (!KeyFunction ||
13340  (KeyFunction->hasBody(KeyFunctionDef) &&
13341  KeyFunctionDef->isInlined()))
13342  Diag(Class->getLocation(), Class->getTemplateSpecializationKind() ==
13344  ? diag::warn_weak_template_vtable : diag::warn_weak_vtable)
13345  << Class;
13346  }
13347  }
13348  VTableUses.clear();
13349 
13350  return DefinedAnything;
13351 }
13352 
13354  const CXXRecordDecl *RD) {
13355  for (const auto *I : RD->methods())
13356  if (I->isVirtual() && !I->isPure())
13357  ResolveExceptionSpec(Loc, I->getType()->castAs<FunctionProtoType>());
13358 }
13359 
13361  const CXXRecordDecl *RD) {
13362  // Mark all functions which will appear in RD's vtable as used.
13363  CXXFinalOverriderMap FinalOverriders;
13364  RD->getFinalOverriders(FinalOverriders);
13365  for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
13366  E = FinalOverriders.end();
13367  I != E; ++I) {
13368  for (OverridingMethods::const_iterator OI = I->second.begin(),
13369  OE = I->second.end();
13370  OI != OE; ++OI) {
13371  assert(OI->second.size() > 0 && "no final overrider");
13372  CXXMethodDecl *Overrider = OI->second.front().Method;
13373 
13374  // C++ [basic.def.odr]p2:
13375  // [...] A virtual member function is used if it is not pure. [...]
13376  if (!Overrider->isPure())
13377  MarkFunctionReferenced(Loc, Overrider);
13378  }
13379  }
13380 
13381  // Only classes that have virtual bases need a VTT.
13382  if (RD->getNumVBases() == 0)
13383  return;
13384 
13385  for (const auto &I : RD->bases()) {
13386  const CXXRecordDecl *Base =
13387  cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
13388  if (Base->getNumVBases() == 0)
13389  continue;
13390  MarkVirtualMembersReferenced(Loc, Base);
13391  }
13392 }
13393 
13394 /// SetIvarInitializers - This routine builds initialization ASTs for the
13395 /// Objective-C implementation whose ivars need be initialized.
13397  if (!getLangOpts().CPlusPlus)
13398  return;
13399  if (ObjCInterfaceDecl *OID = ObjCImplementation->getClassInterface()) {
13402  if (ivars.empty())
13403  return;
13405  for (unsigned i = 0; i < ivars.size(); i++) {
13406  FieldDecl *Field = ivars[i];
13407  if (Field->isInvalidDecl())
13408  continue;
13409 
13410  CXXCtorInitializer *Member;
13412  InitializationKind InitKind =
13413  InitializationKind::CreateDefault(ObjCImplementation->getLocation());
13414 
13415  InitializationSequence InitSeq(*this, InitEntity, InitKind, None);
13416  ExprResult MemberInit =
13417  InitSeq.Perform(*this, InitEntity, InitKind, None);
13418  MemberInit = MaybeCreateExprWithCleanups(MemberInit);
13419  // Note, MemberInit could actually come back empty if no initialization
13420  // is required (e.g., because it would call a trivial default constructor)
13421  if (!MemberInit.get() || MemberInit.isInvalid())
13422  continue;
13423 
13424  Member =
13425  new (Context) CXXCtorInitializer(Context, Field, SourceLocation(),
13426  SourceLocation(),
13427  MemberInit.getAs<Expr>(),
13428  SourceLocation());
13429  AllToInit.push_back(Member);
13430 
13431  // Be sure that the destructor is accessible and is marked as referenced.
13432  if (const RecordType *RecordTy =
13433  Context.getBaseElementType(Field->getType())
13434  ->getAs<RecordType>()) {
13435  CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
13436  if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
13437  MarkFunctionReferenced(Field->getLocation(), Destructor);
13438  CheckDestructorAccess(Field->getLocation(), Destructor,
13439  PDiag(diag::err_access_dtor_ivar)
13440  << Context.getBaseElementType(Field->getType()));
13441  }
13442  }
13443  }
13444  ObjCImplementation->setIvarInitializers(Context,
13445  AllToInit.data(), AllToInit.size());
13446  }
13447 }
13448 
13449 static
13451  llvm::SmallSet<CXXConstructorDecl*, 4> &Valid,
13452  llvm::SmallSet<CXXConstructorDecl*, 4> &Invalid,
13453  llvm::SmallSet<CXXConstructorDecl*, 4> &Current,
13454  Sema &S) {
13455  if (Ctor->isInvalidDecl())
13456  return;
13457 
13458  CXXConstructorDecl *Target = Ctor->getTargetConstructor();
13459 
13460  // Target may not be determinable yet, for instance if this is a dependent
13461  // call in an uninstantiated template.
13462  if (Target) {
13463  const FunctionDecl *FNTarget = nullptr;
13464  (void)Target->hasBody(FNTarget);
13465  Target = const_cast<CXXConstructorDecl*>(
13466  cast_or_null<CXXConstructorDecl>(FNTarget));
13467  }
13468 
13469  CXXConstructorDecl *Canonical = Ctor->getCanonicalDecl(),
13470  // Avoid dereferencing a null pointer here.
13471  *TCanonical = Target? Target->getCanonicalDecl() : nullptr;
13472 
13473  if (!Current.insert(Canonical).second)
13474  return;
13475 
13476  // We know that beyond here, we aren't chaining into a cycle.
13477  if (!Target || !Target->isDelegatingConstructor() ||
13478  Target->isInvalidDecl() || Valid.count(TCanonical)) {
13479  Valid.insert(Current.begin(), Current.end());
13480  Current.clear();
13481  // We've hit a cycle.
13482  } else if (TCanonical == Canonical || Invalid.count(TCanonical) ||
13483  Current.count(TCanonical)) {
13484  // If we haven't diagnosed this cycle yet, do so now.
13485  if (!Invalid.count(TCanonical)) {
13486  S.Diag((*Ctor->init_begin())->getSourceLocation(),
13487  diag::warn_delegating_ctor_cycle)
13488  << Ctor;
13489 
13490  // Don't add a note for a function delegating directly to itself.
13491  if (TCanonical != Canonical)
13492  S.Diag(Target->getLocation(), diag::note_it_delegates_to);
13493 
13494  CXXConstructorDecl *C = Target;
13495  while (C->getCanonicalDecl() != Canonical) {
13496  const FunctionDecl *FNTarget = nullptr;
13497  (void)C->getTargetConstructor()->hasBody(FNTarget);
13498  assert(FNTarget && "Ctor cycle through bodiless function");
13499 
13500  C = const_cast<CXXConstructorDecl*>(
13501  cast<CXXConstructorDecl>(FNTarget));
13502  S.Diag(C->getLocation(), diag::note_which_delegates_to);
13503  }
13504  }
13505 
13506  Invalid.insert(Current.begin(), Current.end());
13507  Current.clear();
13508  } else {
13509  DelegatingCycleHelper(Target, Valid, Invalid, Current, S);
13510  }
13511 }
13512 
13513 
13515  llvm::SmallSet<CXXConstructorDecl*, 4> Valid, Invalid, Current;
13516 
13518  I = DelegatingCtorDecls.begin(ExternalSource),
13519  E = DelegatingCtorDecls.end();
13520  I != E; ++I)
13521  DelegatingCycleHelper(*I, Valid, Invalid, Current, *this);
13522 
13523  for (llvm::SmallSet<CXXConstructorDecl *, 4>::iterator CI = Invalid.begin(),
13524  CE = Invalid.end();
13525  CI != CE; ++CI)
13526  (*CI)->setInvalidDecl();
13527 }
13528 
13529 namespace {
13530  /// \brief AST visitor that finds references to the 'this' expression.
13531  class FindCXXThisExpr : public RecursiveASTVisitor<FindCXXThisExpr> {
13532  Sema &S;
13533 
13534  public:
13535  explicit FindCXXThisExpr(Sema &S) : S(S) { }
13536 
13537  bool VisitCXXThisExpr(CXXThisExpr *E) {
13538  S.Diag(E->getLocation(), diag::err_this_static_member_func)
13539  << E->isImplicit();
13540  return false;
13541  }
13542  };
13543 }
13544 
13546  TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
13547  if (!TSInfo)
13548  return false;
13549 
13550  TypeLoc TL = TSInfo->getTypeLoc();
13552  if (!ProtoTL)
13553  return false;
13554 
13555  // C++11 [expr.prim.general]p3:
13556  // [The expression this] shall not appear before the optional
13557  // cv-qualifier-seq and it shall not appear within the declaration of a
13558  // static member function (although its type and value category are defined
13559  // within a static member function as they are within a non-static member
13560  // function). [ Note: this is because declaration matching does not occur
13561  // until the complete declarator is known. - end note ]
13562  const FunctionProtoType *Proto = ProtoTL.getTypePtr();
13563  FindCXXThisExpr Finder(*this);
13564 
13565  // If the return type came after the cv-qualifier-seq, check it now.
13566  if (Proto->hasTrailingReturn() &&
13567  !Finder.TraverseTypeLoc(ProtoTL.getReturnLoc()))
13568  return true;
13569 
13570  // Check the exception specification.
13572  return true;
13573 
13575 }
13576 
13578  TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
13579  if (!TSInfo)
13580  return false;
13581 
13582  TypeLoc TL = TSInfo->getTypeLoc();
13584  if (!ProtoTL)
13585  return false;
13586 
13587  const FunctionProtoType *Proto = ProtoTL.getTypePtr();
13588  FindCXXThisExpr Finder(*this);
13589 
13590  switch (Proto->getExceptionSpecType()) {
13591  case EST_Unparsed:
13592  case EST_Uninstantiated:
13593  case EST_Unevaluated:
13594  case EST_BasicNoexcept:
13595  case EST_DynamicNone:
13596  case EST_MSAny:
13597  case EST_None:
13598  break;
13599 
13600  case EST_ComputedNoexcept:
13601  if (!Finder.TraverseStmt(Proto->getNoexceptExpr()))
13602  return true;
13603 
13604  case EST_Dynamic:
13605  for (const auto &E : Proto->exceptions()) {
13606  if (!Finder.TraverseType(E))
13607  return true;
13608  }
13609  break;
13610  }
13611 
13612  return false;
13613 }
13614 
13616  FindCXXThisExpr Finder(*this);
13617 
13618  // Check attributes.
13619  for (const auto *A : Method->attrs()) {
13620  // FIXME: This should be emitted by tblgen.
13621  Expr *Arg = nullptr;
13622  ArrayRef<Expr *> Args;
13623  if (const auto *G = dyn_cast<GuardedByAttr>(A))
13624  Arg = G->getArg();
13625  else if (const auto *G = dyn_cast<PtGuardedByAttr>(A))
13626  Arg = G->getArg();
13627  else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
13628  Args = llvm::makeArrayRef(AA->args_begin(), AA->args_size());
13629  else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
13630  Args = llvm::makeArrayRef(AB->args_begin(), AB->args_size());
13631  else if (const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
13632  Arg = ETLF->getSuccessValue();
13633  Args = llvm::makeArrayRef(ETLF->args_begin(), ETLF->args_size());
13634  } else if (const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
13635  Arg = STLF->getSuccessValue();
13636  Args = llvm::makeArrayRef(STLF->args_begin(), STLF->args_size());
13637  } else if (const auto *LR = dyn_cast<LockReturnedAttr>(A))
13638  Arg = LR->getArg();
13639  else if (const auto *LE = dyn_cast<LocksExcludedAttr>(A))
13640  Args = llvm::makeArrayRef(LE->args_begin(), LE->args_size());
13641  else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
13642  Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());
13643  else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
13644  Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
13645  else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
13646  Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
13647  else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
13648  Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());
13649 
13650  if (Arg && !Finder.TraverseStmt(Arg))
13651  return true;
13652 
13653  for (unsigned I = 0, N = Args.size(); I != N; ++I) {
13654  if (!Finder.TraverseStmt(Args[I]))
13655  return true;
13656  }
13657  }
13658 
13659  return false;
13660 }
13661 
13663  bool IsTopLevel, ExceptionSpecificationType EST,
13664  ArrayRef<ParsedType> DynamicExceptions,
13665  ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr,
13666  SmallVectorImpl<QualType> &Exceptions,
13668  Exceptions.clear();
13669  ESI.Type = EST;
13670  if (EST == EST_Dynamic) {
13671  Exceptions.reserve(DynamicExceptions.size());
13672  for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
13673  // FIXME: Preserve type source info.
13674  QualType ET = GetTypeFromParser(DynamicExceptions[ei]);
13675 
13676  if (IsTopLevel) {
13678  collectUnexpandedParameterPacks(ET, Unexpanded);
13679  if (!Unexpanded.empty()) {
13681  DynamicExceptionRanges[ei].getBegin(), UPPC_ExceptionType,
13682  Unexpanded);
13683  continue;
13684  }
13685  }
13686 
13687  // Check that the type is valid for an exception spec, and
13688  // drop it if not.
13689  if (!CheckSpecifiedExceptionType(ET, DynamicExceptionRanges[ei]))
13690  Exceptions.push_back(ET);
13691  }
13692  ESI.Exceptions = Exceptions;
13693  return;
13694  }
13695 
13696  if (EST == EST_ComputedNoexcept) {
13697  // If an error occurred, there's no expression here.
13698  if (NoexceptExpr) {
13699  assert((NoexceptExpr->isTypeDependent() ||
13700  NoexceptExpr->getType()->getCanonicalTypeUnqualified() ==
13701  Context.BoolTy) &&
13702  "Parser should have made sure that the expression is boolean");
13703  if (IsTopLevel && NoexceptExpr &&
13704  DiagnoseUnexpandedParameterPack(NoexceptExpr)) {
13705  ESI.Type = EST_BasicNoexcept;
13706  return;
13707  }
13708 
13709  if (!NoexceptExpr->isValueDependent())
13710  NoexceptExpr = VerifyIntegerConstantExpression(NoexceptExpr, nullptr,
13711  diag::err_noexcept_needs_constant_expression,
13712  /*AllowFold*/ false).get();
13713  ESI.NoexceptExpr = NoexceptExpr;
13714  }
13715  return;
13716  }
13717 }
13718 
13721  SourceRange SpecificationRange,
13722  ArrayRef<ParsedType> DynamicExceptions,
13723  ArrayRef<SourceRange> DynamicExceptionRanges,
13724  Expr *NoexceptExpr) {
13725  if (!MethodD)
13726  return;
13727 
13728  // Dig out the method we're referring to.
13729  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(MethodD))
13730  MethodD = FunTmpl->getTemplatedDecl();
13731 
13732  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(MethodD);
13733  if (!Method)
13734  return;
13735 
13736  // Check the exception specification.
13737  llvm::SmallVector<QualType, 4> Exceptions;
13739  checkExceptionSpecification(/*IsTopLevel*/true, EST, DynamicExceptions,
13740  DynamicExceptionRanges, NoexceptExpr, Exceptions,
13741  ESI);
13742 
13743  // Update the exception specification on the function type.
13744  Context.adjustExceptionSpec(Method, ESI, /*AsWritten*/true);
13745 
13746  if (Method->isStatic())
13748 
13749  if (Method->isVirtual()) {
13750  // Check overrides, which we previously had to delay.
13752  OEnd = Method->end_overridden_methods();
13753  O != OEnd; ++O)
13755  }
13756 }
13757 
13758 /// HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
13759 ///
13761  SourceLocation DeclStart,
13762  Declarator &D, Expr *BitWidth,
13763  InClassInitStyle InitStyle,
13764  AccessSpecifier AS,
13765  AttributeList *MSPropertyAttr) {
13766  IdentifierInfo *II = D.getIdentifier();
13767  if (!II) {
13768  Diag(DeclStart, diag::err_anonymous_property);
13769  return nullptr;
13770  }
13771  SourceLocation Loc = D.getIdentifierLoc();
13772 
13773  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
13774  QualType T = TInfo->getType();
13775  if (getLangOpts().CPlusPlus) {
13777 
13780  D.setInvalidType();
13781  T = Context.IntTy;
13782  TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
13783  }
13784  }
13785 
13787 
13790  diag::err_invalid_thread)
13791  << DeclSpec::getSpecifierName(TSCS);
13792 
13793  // Check to see if this name was declared as a member previously
13794  NamedDecl *PrevDecl = nullptr;
13796  LookupName(Previous, S);
13797  switch (Previous.getResultKind()) {
13798  case LookupResult::Found:
13800  PrevDecl = Previous.getAsSingle<NamedDecl>();
13801  break;
13802 
13804  PrevDecl = Previous.getRepresentativeDecl();
13805  break;
13806 
13810  break;
13811  }
13812 
13813  if (PrevDecl && PrevDecl->isTemplateParameter()) {
13814  // Maybe we will complain about the shadowed template parameter.
13816  // Just pretend that we didn't see the previous declaration.
13817  PrevDecl = nullptr;
13818  }
13819 
13820  if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
13821  PrevDecl = nullptr;
13822 
13823  SourceLocation TSSL = D.getLocStart();
13824  const AttributeList::PropertyData &Data = MSPropertyAttr->getPropertyData();
13826  Context, Record, Loc, II, T, TInfo, TSSL, Data.GetterId, Data.SetterId);
13827  ProcessDeclAttributes(TUScope, NewPD, D);
13828  NewPD->setAccess(AS);
13829 
13830  if (NewPD->isInvalidDecl())
13831  Record->setInvalidDecl();
13832 
13834  NewPD->setModulePrivate();
13835 
13836  if (NewPD->isInvalidDecl() && PrevDecl) {
13837  // Don't introduce NewFD into scope; there's already something
13838  // with the same name in the same scope.
13839  } else if (II) {
13840  PushOnScopeChains(NewPD, S);
13841  } else
13842  Record->addDecl(NewPD);
13843 
13844  return NewPD;
13845 }
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:1320
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
Definition: Ownership.h:265
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:207
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:54
SourceLocation getThreadStorageClassSpecLoc() const
Definition: DeclSpec.h:451
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl)
Definition: DeclCXX.cpp:2018
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2393
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType) const
Defines the clang::ASTContext interface.
void ActOnFinishDelayedMemberInitializers(Decl *Record)
unsigned getNumInits() const
Definition: Expr.h:3754
VariadicCallType
Definition: Sema.h:8256
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1332
SourceLocation getEnd() const
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:64
CastKind getCastKind() const
Definition: Expr.h:2658
IdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:971
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void setImplicit(bool I=true)
Definition: DeclBase.h:515
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1483
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.
CK_LValueToRValue - A conversion which causes the extraction of an r-value from the operand gl-value...
static void CheckForDanglingReferenceOrPointer(Sema &S, ValueDecl *Member, Expr *Init, SourceLocation IdLoc)
Checks a member initializer expression for cases where reference (or pointer) members are bound to by...
bool isVariadic() const
Definition: Type.h:3255
bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, bool Diagnose=true)
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
Name lookup found a set of overloaded functions that met the criteria.
Definition: Sema/Lookup.h:47
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
Definition: DeclSpec.h:2076
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:916
bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier * > Bases)
Performs the actual work of attaching the given base class specifiers to a C++ class.
bool needsImplicitMoveConstructor() const
Determine whether this class should get an implicit move constructor or if any existing special membe...
Definition: DeclCXX.h:915
iterator begin() const
Definition: DeclBase.h:1090
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Definition: DeclBase.h:1807
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
Definition: DeclSpec.h:1206
unsigned getDepth() const
Definition: Type.h:3779
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:169
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
void CheckConstructor(CXXConstructorDecl *Constructor)
CheckConstructor - Checks a fully-formed constructor for well-formedness, issuing any diagnostics req...
static bool specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, Sema::CXXSpecialMember CSM, unsigned Quals, bool ConstRHS)
Is the special member function which would be selected to perform the specified operation on the spec...
no exception specification
bool needsOverloadResolutionForDestructor() const
Determine whether we need to eagerly declare a destructor for this class.
Definition: DeclCXX.h:1017
bool TemplateParameterListsAreEqual(TemplateParameterList *New, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2147
EvaluatedExprVisitor - This class visits 'Expr *'s.
SourceLocation getRestrictSpecLoc() const
Definition: DeclSpec.h:536
CanQualType VoidPtrTy
Definition: ASTContext.h:895
A (possibly-)qualified type.
Definition: Type.h:575
ASTConsumer & Consumer
Definition: Sema.h:296
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:206
Simple class containing the result of Sema::CorrectTypo.
base_class_range bases()
Definition: DeclCXX.h:713
bool isInvalid() const
Definition: Ownership.h:159
bool CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams, TemplateParamListContext TPC)
Checks the validity of a template parameter list, possibly considering the template parameter list fr...
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:5513
SourceLocation getConstSpecLoc() const
Definition: DeclSpec.h:535
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2199
bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A, const NamedDecl *B)
Determine if A and B are equivalent internal linkage declarations from different modules, and thus an ambiguity error can be downgraded to an extension warning.
NestedNameSpecifier * getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
SourceLocation getExplicitSpecLoc() const
Definition: DeclSpec.h:563
ExtInfo withCallingConv(CallingConv cc) const
Definition: Type.h:2954
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2432
static bool checkTrivialClassMembers(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM, bool ConstArg, bool Diagnose)
Check whether the members of a class type allow a special member to be trivial.
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1077
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2277
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1263
void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace)
ActOnFinishNamespaceDef - This callback is called after a namespace is exited.
void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D)
Definition: SemaDecl.cpp:5218
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:252
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition: DeclSpec.h:948
void InstantiateExceptionSpec(SourceLocation PointOfInstantiation, FunctionDecl *Function)
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
static unsigned NumImplicitMoveAssignmentOperatorsDeclared
The number of implicitly-declared move assignment operators for which declarations were built...
Definition: ASTContext.h:2458
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
std::unique_ptr< RecordDeclSetTy > PureVirtualClassDiagSet
PureVirtualClassDiagSet - a set of class declarations which we have emitted a list of pure virtual fu...
Definition: Sema.h:471
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2636
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:164
DeclarationName getCXXConstructorName(CanQualType Ty)
getCXXConstructorName - Returns the name of a C++ constructor for the given Type. ...
method_range methods() const
Definition: DeclCXX.h:755
CanQualType Char32Ty
Definition: ASTContext.h:888
The subobject is a base class.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1673
const LangOptions & getLangOpts() const
Definition: Sema.h:1041
static CXXConstructExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, CXXConstructorDecl *D, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, ConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Definition: ExprCXX.cpp:824
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Sema/Lookup.h:209
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false)
Perform unqualified name lookup starting from a given scope.
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
Definition: Scope.h:220
An initializer.
Definition: Sema.h:5985
static unsigned NumImplicitDefaultConstructors
The number of implicitly-declared default constructors.
Definition: ASTContext.h:2426
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
DeclClass * getAsSingle() const
Definition: Sema/Lookup.h:448
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration...
Definition: DeclCXX.h:1786
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID. ...
bool hasDefaultArg() const
hasDefaultArg - Determines whether this parameter has a default argument, either parsed or not...
Definition: Decl.cpp:2420
Expr *const * semantics_iterator
Definition: Expr.h:4758
static ClassTemplateDecl * LookupStdInitializerList(Sema &S, SourceLocation Loc)
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
Definition: DeclSpec.h:921
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Sema/Lookup.h:465
Filter makeFilter()
Create a filter for this result set.
Definition: Sema/Lookup.h:622
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1439
We are matching the template parameter lists of two templates that might be redeclarations.
Definition: Sema.h:5844
CXXMethodDecl * LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals, bool RValueThis, unsigned ThisQuals)
Look up the moving assignment operator for the given class.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:3748
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2847
CXXCatchStmt * getHandler(unsigned i)
Definition: StmtCXX.h:104
FullExprArg MakeFullExpr(Expr *Arg)
Definition: Sema.h:3249
TypeLoc getNamedTypeLoc() const
Definition: TypeLoc.h:1759
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program...
Definition: Decl.cpp:2526
IfStmt - This represents an if/then/else.
Definition: Stmt.h:869
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
IdentifierInfo * getCXXLiteralIdentifier() const
getCXXLiteralIdentifier - If this name is the name of a literal operator, retrieve the identifier ass...
CachedTokens * DefaultArgTokens
DefaultArgTokens - When the parameter's default argument cannot be parsed immediately (because it occ...
Definition: DeclSpec.h:1175
StmtResult ActOnExprStmt(ExprResult Arg)
Definition: SemaStmt.cpp:43
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:215
void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnStartDelayedCXXMethodDeclaration - We have completed parsing a top-level (non-nested) C++ class...
static CharSourceRange getTokenRange(SourceRange R)
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
Definition: SemaDecl.cpp:10351
void addConst()
Add the const type qualifier to this QualType.
Definition: Type.h:738
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed...
Definition: SemaExpr.cpp:4404
The current expression is potentially evaluated at run time, which means that code may be generated t...
Definition: Sema.h:781
static unsigned NumImplicitMoveAssignmentOperators
The number of implicitly-declared move assignment operators.
Definition: ASTContext.h:2454
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:171
bool needsOverloadResolutionForCopyConstructor() const
Determine whether we need to eagerly declare a defaulted copy constructor for this class...
Definition: DeclCXX.h:864
void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class)
Force the declaration of any implicitly-declared members of this class.
Definition: SemaLookup.cpp:718
A conversion function name, e.g., operator int.
Definition: DeclSpec.h:887
ctor_range ctors() const
Definition: DeclCXX.h:774
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: Sema/Lookup.h:594
static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D)
Determine what kind of template specialization the given declaration is.
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
bool isRecordType() const
Definition: Type.h:5362
QualType getUnderlyingType() const
Definition: Decl.h:2566
void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc, const CXXRecordDecl *RD)
Mark the exception specifications of all virtual member functions in the given class as needed...
StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R, ArrayRef< Stmt * > Elts, bool isStmtExpr)
Definition: SemaStmt.cpp:331
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1118
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:77
void setRangeEnd(SourceLocation E)
Definition: Decl.h:1675
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr * > Args, SmallVectorImpl< Expr * > &AllArgs, VariadicCallType CallType=VariadicDoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
GatherArgumentsForCall - Collector argument expressions for various form of call prototypes.
Definition: SemaExpr.cpp:4699
chain_range chain() const
Definition: Decl.h:2457
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToMemberFunction - Build a call to a member function.
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 addDefaultArgExprForConstructor(const CXXConstructorDecl *CD, unsigned ParmIdx, Expr *DAE)
void DiagnoseFunctionSpecifiers(const DeclSpec &DS)
Diagnose function specifiers on a declaration of an identifier that does not identify a function...
Definition: SemaDecl.cpp:5155
void setModulePrivate(bool MP=true)
Specify whether this declaration was marked as being private to the module in which it was defined...
Definition: DeclBase.h:570
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:680
void setPure(bool P=true)
Definition: Decl.cpp:2513
ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation, SourceLocation ConvLocation, CXXConversionDecl *Conv, Expr *Src)
bool hasFlexibleArrayMember() const
Definition: Decl.h:3218
void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD)
MarkVirtualMembersReferenced - Will mark all members of the given CXXRecordDecl referenced.
bool isEnumeralType() const
Definition: Type.h:5365
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:834
SCS getStorageClassSpec() const
Definition: DeclSpec.h:441
void FindHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl< CXXMethodDecl * > &OverloadedMethods)
Check if a method overloads virtual methods in a base class without overriding any.
void AddDecl(Decl *D)
Definition: Scope.h:272
void ActOnBaseSpecifiers(Decl *ClassDecl, MutableArrayRef< CXXBaseSpecifier * > Bases)
ActOnBaseSpecifiers - Attach the given base specifiers to the class, after checking whether there are...
void EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD)
Evaluate the implicit exception specification for a defaulted special member function.
PtrTy get() const
Definition: Ownership.h:163
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Definition: SemaExpr.cpp:4262
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
TemplateSpecializationType(TemplateName T, const TemplateArgument *Args, unsigned NumArgs, QualType Canon, QualType Aliased)
Definition: Type.cpp:3118
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
Definition: Type.cpp:2398
IdentifierInfo * getAsIdentifierInfo() const
getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in this declaration name, or NULL if this declaration name isn't a simple identifier.
The base class of the type hierarchy.
Definition: Type.h:1249
bool isInStdNamespace() const
Definition: DeclBase.cpp:292
bool isElaboratedTypeSpecifier() const
Determine wither this type is a C++ elaborated-type-specifier.
Definition: Type.cpp:2488
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:884
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
Definition: DeclCXX.h:1395
iterator begin() const
Definition: Sema/Lookup.h:276
void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnFinishDelayedCXXMethodDeclaration - We have finished processing the delayed method declaration f...
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:5122
unsigned getLength() const
Efficiently return the length of this identifier info.
MapType::iterator iterator
QualType getRecordType(const RecordDecl *Decl) const
One instance of this struct is used for each type in a declarator that is parsed. ...
Definition: DeclSpec.h:1091
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:1791
Declaration of a variable template.
const Expr * getInit() const
Definition: Decl.h:1070
void MarkDeclRefReferenced(DeclRefExpr *E)
Perform reference-marking and odr-use handling for a DeclRefExpr.
Definition: SemaExpr.cpp:13645
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:402
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:46
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1149
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:91
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:444
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:100
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:90
A container of type source information.
Definition: Decl.h:61
bool defaultedDefaultConstructorIsConstexpr() const
Determine whether a defaulted default constructor for this class would be constexpr.
Definition: DeclCXX.h:1193
unsigned getIndex() const
Definition: Type.h:3780
const Stmt * getElse() const
Definition: Stmt.h:905
bool inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, CXXSpecialMember CSM, CXXMethodDecl *MemberDecl, bool ConstRHS, bool Diagnose)
Given a implicit special member, infer its CUDA target from the calls it needs to make to underlying ...
Definition: SemaCUDA.cpp:296
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclBase.h:380
void PopDeclContext()
Definition: SemaDecl.cpp:1076
bool needsImplicitDestructor() const
Determine whether this class needs an implicit destructor to be lazily declared.
Definition: DeclCXX.h:1011
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, ArrayRef< TemplateParameterList * > FriendTypeTPLists=None)
Definition: DeclFriend.cpp:27
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
bool hasUserDeclaredCopyAssignment() const
Determine whether this class has a user-declared copy assignment operator.
Definition: DeclCXX.h:933
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2134
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:2940
CanQualType WideCharTy
Definition: ASTContext.h:885
bool hasErrorOccurred() const
Determine whether any errors have occurred since this object instance was created.
Definition: Diagnostic.h:833
Expr * getInClassInitializer() const
getInClassInitializer - Get the C++11 in-class initializer for this member, or null if one has not be...
Definition: Decl.h:2332
capture_iterator capture_begin() const
Retrieve an iterator pointing to the first lambda capture.
Definition: ExprCXX.cpp:1012
InClassInitStyle getInClassInitStyle() const
getInClassInitStyle - Get the kind of (C++11) in-class initializer which this field has...
Definition: Decl.h:2316
bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S)
MergeCXXFunctionDecl - Merge two declarations of the same C++ function, once we already know that the...
const llvm::APInt & getSize() const
Definition: Type.h:2495
void CheckCXXDefaultArguments(FunctionDecl *FD)
CheckCXXDefaultArguments - Verify that the default arguments for a function declaration are well-form...
RAII object to handle the state changes required to synthesize a function body.
Definition: Sema.h:635
Look up a namespace name within a C++ using directive or namespace alias definition, ignoring non-namespace names (C++ [basic.lookup.udir]p1).
Definition: Sema.h:2656
CXXMethodDecl * DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl)
Declare the implicit move assignment operator for the given class.
void ActOnFinishCXXNonNestedClass(Decl *D)
static void DiagnoseBaseOrMemInitializerOrder(Sema &SemaRef, const CXXConstructorDecl *Constructor, ArrayRef< CXXCtorInitializer * > Inits)
This file provides some common utility functions for processing Lambda related AST Constructs...
CXXConstructorDecl * LookupMovingConstructor(CXXRecordDecl *Class, unsigned Quals)
Look up the moving constructor for the given class.
bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info)
DiagnoseClassNameShadow - Implement C++ [class.mem]p13: If T is the name of a class, then each of the following shall have a name different from T:
Definition: SemaDecl.cpp:4671
bool isImplicit() const
Definition: ExprCXX.h:882
void ActOnDefaultCtorInitializers(Decl *CDtorDecl)
DeclContext::lookup_result Decls
The set of declarations found inside this base class subobject.
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:40
RAII object that enters a new expression evaluation context.
Definition: Sema.h:9238
void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record)
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:699
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
CXXMethodDecl * LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals, bool RValueThis, unsigned ThisQuals)
Look up the copying assignment operator for the given class.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
std::pair< CXXRecordDecl *, CXXSpecialMember > SpecialMemberDecl
Definition: Sema.h:979
Expr * getInit() const
Get the initializer.
Definition: DeclCXX.h:2119
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1608
DiagnosticsEngine & Diags
Definition: Sema.h:297
Wrapper for source info for member pointers.
Definition: TypeLoc.h:1163
const Expr * getCallee() const
Definition: Expr.h:2170
void finishedDefaultedOrDeletedMember(CXXMethodDecl *MD)
Indicates that the declaration of a defaulted or deleted special member function is now complete...
Definition: DeclCXX.cpp:933
OverloadKind CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &OldDecls, NamedDecl *&OldDecl, bool IsForUsingDecl)
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
Extra information about a function prototype.
Definition: Type.h:3067
AccessSpecifier getAccess() const
Definition: DeclBase.h:428
void clear()
Clear the base-paths results.
CallingConv getCallConv() const
Definition: Type.h:2985
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
field_iterator field_begin() const
Definition: Decl.cpp:3746
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
Definition: DeclCXX.cpp:2223
MapType::const_iterator const_iterator
The "__interface" keyword.
Definition: Type.h:4178
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1793
RAII class that determines when any errors have occurred between the time the instance was created an...
Definition: Diagnostic.h:822
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:319
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
Definition: Sema.h:9234
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:926
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Definition: DeclCXX.cpp:1802
Like System, but searched after the system directories.
bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD)
AddOverriddenMethods - See if a method overrides any in the base classes, and if so, check that it's a valid override and remember it.
Definition: SemaDecl.cpp:6780
SpecialMemberOverloadResult * LookupSpecialMember(CXXRecordDecl *D, CXXSpecialMember SM, bool ConstArg, bool VolatileArg, bool RValueThis, bool ConstThis, bool VolatileThis)
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:48
void setBegin(SourceLocation b)
static StringRef getTagTypeKindName(TagTypeKind Kind)
Definition: Type.h:4246
static InitializationKind CreateDirectList(SourceLocation InitLoc)
decl_iterator decls_end() const
Definition: DeclBase.h:1441
NamedDecl * ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope)
Definition: SemaDecl.cpp:7377
bool hasNonTrivialMoveAssignment() const
Determine whether this class has a non-trivial move assignment operator (C++11 [class.copy]p25)
Definition: DeclCXX.h:1255
void DefineImplicitLambdaToFunctionPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a function pointer.
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1521
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams)
Handle a friend type declaration.
bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM, bool Diagnose=false)
Determine whether a defaulted or deleted special member function is trivial, as specified in C++11 [c...
static AccessSpecDecl * Create(ASTContext &C, AccessSpecifier AS, DeclContext *DC, SourceLocation ASLoc, SourceLocation ColonLoc)
Definition: DeclCXX.h:128
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1299
bool isObjCRetainableType() const
Definition: Type.cpp:3704
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:1553
type_object_range type_objects() const
Returns the range of type objects, from the identifier outwards.
Definition: DeclSpec.h:2000
Defines the clang::Expr interface and subclasses for C++ expressions.
Parse and apply any fixits to the source.
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
Definition: DeclCXX.cpp:1270
bool isUnionType() const
Definition: Type.cpp:391
void removeDecl(Decl *D)
Removes a declaration from this context.
Definition: DeclBase.cpp:1185
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
iterator begin(Source *source, bool LocalOnly=false)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1739
bool isVoidType() const
Definition: Type.h:5546
bool isBaseInitializer() const
Determine whether this initializer is initializing a base class.
Definition: DeclCXX.h:1965
void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, TypedefNameDecl *NewTD)
Definition: SemaDecl.cpp:3643
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:485
The collection of all-type qualifiers we support.
Definition: Type.h:116
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:5002
void DefineImplicitMoveConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitMoveConstructor - Checks for feasibility of defining this constructor as the move const...
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
FieldDecl * HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS)
HandleField - Analyze a field of a C struct or a C++ data member.
Definition: SemaDecl.cpp:12936
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class...
Definition: DeclCXX.h:1207
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()
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool OdrUse)
Perform marking for a reference to an arbitrary declaration.
Definition: SemaExpr.cpp:13679
unsigned getNumParams() const
Definition: Type.h:3160
AccessResult CheckFriendAccess(NamedDecl *D)
Checks access to the target of a friend declaration.
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3166
Decl * ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS, MultiTemplateParamsArg TemplateParams, SourceLocation UsingLoc, UnqualifiedId &Name, AttributeList *AttrList, TypeResult Type, Decl *DeclFromDeclSpec)
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body (definition).
Definition: Decl.cpp:2460
void LoadExternalVTableUses()
Load any externally-stored vtable uses.
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Definition: Decl.h:2073
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1414
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:2629
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:942
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
DeclarationName getName() const
getName - Returns the embedded declaration name.
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3082
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.
iterator end() const
Definition: Sema/Lookup.h:277
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition: Sema/Lookup.h:57
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1144
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)
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
Definition: SemaDecl.cpp:4432
void setRecordingPaths(bool RP)
Specify whether we should be recording paths or not.
method_iterator end_overridden_methods() const
Definition: DeclCXX.cpp:1588
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
Definition: Decl.h:2382
void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl)
DiagnoseTemplateParameterShadow - Produce a diagnostic complaining that the template parameter 'PrevD...
Decl * ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS, bool HasUsingKeyword, SourceLocation UsingLoc, CXXScopeSpec &SS, UnqualifiedId &Name, AttributeList *AttrList, bool HasTypenameKeyword, SourceLocation TypenameLoc)
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4381
bool hasAttr() const
Definition: DeclBase.h:498
UnionParsedType ConversionFunctionId
When Kind == IK_ConversionFunctionId, the type that the conversion function names.
Definition: DeclSpec.h:929
AttributeList * getList() const
void setUninstantiatedDefaultArg(Expr *arg)
Definition: Decl.cpp:2409
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3184
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:91
static unsigned NumImplicitMoveConstructorsDeclared
The number of implicitly-declared move constructors for which declarations were built.
Definition: ASTContext.h:2444
A C++ nested-name-specifier augmented with source location information.
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1054
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3165
bool isDelegatingConstructor() const
Determine whether this constructor is a delegating constructor.
Definition: DeclCXX.h:2242
bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, ArrayRef< CXXCtorInitializer * > Initializers=None)
ImplicitInitializerKind
ImplicitInitializerKind - How an implicit base or member initializer should initialize its base or me...
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:1727
bool isIdentifier() const
Predicate functions for querying what type of name this is.
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.
static void AddMostOverridenMethods(const CXXMethodDecl *MD, llvm::SmallPtrSetImpl< const CXXMethodDecl * > &Methods)
Add the most overriden methods from MD to Methods.
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclCXX.h:202
bool isRecordingPaths() const
Whether we are recording paths.
bool isReferenceType() const
Definition: Type.h:5314
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 getReturnType() const
Definition: Decl.h:1956
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...
VarDecl * BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id)
Perform semantic analysis for the variable declaration that occurs within a C++ catch clause...
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2209
CXXConstructorDecl * getTargetConstructor() const
When this constructor delegates to another, retrieve the target.
Definition: DeclCXX.cpp:1773
bool needsOverloadResolutionForMoveConstructor() const
Determine whether we need to eagerly declare a defaulted move constructor for this class...
Definition: DeclCXX.h:925
NoexceptResult
Result type of getNoexceptSpec().
Definition: Type.h:3211
bool isAbstractType(SourceLocation Loc, QualType T)
static bool isIncrementDecrementOp(Opcode Op)
Definition: Expr.h:1715
unsigned TypeQuals
The type qualifiers: const/volatile/restrict.
Definition: DeclSpec.h:1210
StmtResult ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, FullExprArg Second, Decl *SecondVar, FullExprArg Third, SourceLocation RParenLoc, Stmt *Body)
Definition: SemaStmt.cpp:1607
void Deallocate(void *Ptr) const
Definition: ASTContext.h:566
ParmVarDecl * getParam(unsigned i) const
Definition: TypeLoc.h:1306
unsigned getIdentifierNamespace() const
Definition: DeclBase.h:682
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:1769
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.h:2499
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that that type refers to...
Definition: Type.cpp:1507
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
This is not an overload because the signature exactly matches an existing declaration.
Definition: Sema.h:2181
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:675
static CXXCtorInitializer * Create(ASTContext &Context, FieldDecl *Member, SourceLocation MemberLoc, SourceLocation L, Expr *Init, SourceLocation R, VarDecl **Indices, unsigned NumIndices)
Creates a new member initializer that optionally contains array indices used to describe an elementwi...
Definition: DeclCXX.cpp:1694
bool isTranslationUnit() const
Definition: DeclBase.h:1269
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1788
TagKind getTagKind() const
Definition: Decl.h:2847
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:28
SourceRange getLocalSourceRange() const
Get the local source range.
Definition: TypeLoc.h:134
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1962
static void extendLeft(SourceRange &R, SourceRange Before)
DeclarationName getCXXDestructorName(CanQualType Ty)
getCXXDestructorName - Returns the name of a C++ destructor for the given Type.
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr)
Definition: Expr.cpp:368
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:1796
bool hasInClassInitializer() const
Whether this class has any in-class initializers for non-static data members (including those in anon...
Definition: DeclCXX.h:1107
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:503
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1744
unsigned size() const
Definition: DeclTemplate.h:91
static bool CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S, SmallVectorImpl< SourceLocation > &ReturnStmts, SourceLocation &Cxx1yLoc)
Check the provided statement is allowed in a constexpr function definition.
bool DefineUsedVTables()
Define all of the vtables that have been used in this translation unit and reference any virtual memb...
Expr * getSubExpr()
Definition: Expr.h:2662
Represents an access specifier followed by colon ':'.
Definition: DeclCXX.h:101
void ClearStorageClassSpecs()
Definition: DeclSpec.h:455
bool needsImplicitCopyAssignment() const
Determine whether this class needs an implicit copy assignment operator to be lazily declared...
Definition: DeclCXX.h:939
void addShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:2109
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param IfCond Not a nullptr if if clause was nullptr *otherwise *param PrivateVars List of references to private variables for the task *directive *param PrivateCopies List of private copies for each private variable in *p PrivateVars *param FirstprivateVars List of references to private variables for the *task directive *param FirstprivateCopies List of private copies for each private variable *in p FirstprivateVars *param FirstprivateInits List of references to auto generated variables *used for initialization of a single array element Used if firstprivate *variable is of array type *param Dependences List of dependences for the task construct
TypeSourceInfo * getTypeSourceInfo() const
Definition: TemplateBase.h:472
Decl * ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, AttributeList *Attr, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, SkipBodyInfo *SkipBody=nullptr)
This is invoked when we see 'struct foo' or 'struct {'.
Definition: SemaDecl.cpp:11850
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:1191
void PopExpressionEvaluationContext()
Definition: SemaExpr.cpp:12479
static FriendTemplateDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc, unsigned NParams, TemplateParameterList **Params, FriendUnion Friend, SourceLocation FriendLoc)
void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:1987
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: Sema/Lookup.h:39
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Adjust the DeclContext for a function or variable that might be a function-local external declaration...
Definition: SemaDecl.cpp:5664
IdentifierTable & Idents
Definition: ASTContext.h:451
SpecialMemberOverloadResult - The overloading result for a special member function.
Definition: Sema.h:879
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
Definition: SemaExpr.cpp:201
The type of an exception.
Definition: Sema.h:5994
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:102
Expr * getLHS() const
Definition: Expr.h:2921
T * getAttr() const
Definition: DeclBase.h:495
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted per C++0x.
Definition: Decl.h:1769
A location where the result (returned value) of evaluating a statement should be stored.
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:170
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:937
Describes an C or C++ initializer list.
Definition: Expr.h:3724
Represents a C++ using-declaration.
Definition: DeclCXX.h:2858
bool implicitCopyConstructorHasConstParam() const
Determine whether an implicit copy constructor for this type would have a parameter with a const-qual...
Definition: DeclCXX.h:870
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:874
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2351
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1416
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
Definition: SemaLookup.cpp:459
NamespaceDecl * getOrCreateStdNamespace()
Retrieve the special "std" namespace, which may require us to implicitly define the namespace...
Represents the results of name lookup.
Definition: Sema/Lookup.h:30
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:580
bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc, UnexpandedParameterPackContext UPPC, ArrayRef< UnexpandedParameterPack > Unexpanded)
Diagnose unexpanded parameter packs.
bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:324
void CalledExpr(Expr *E)
Integrate an invoked expression into the collected data.
const LangOptions & getLangOpts() const
Definition: ASTContext.h:596
bool isLastDiagnosticIgnored() const
Determine whether the previous diagnostic was ignored.
Definition: Diagnostic.h:507
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:1983
static InitializedEntity InitializeDelegation(QualType Type)
Create the initialization entity for a delegated constructor.
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:514
bool isInline() const
Returns true if this is an inline namespace declaration.
Definition: Decl.h:457
ImplicitExceptionSpecification ComputeInheritingCtorExceptionSpec(CXXConstructorDecl *CD)
Determine what sort of exception specification an inheriting constructor of a class will have...
IndirectFieldDecl * getIndirectMember() const
Definition: DeclCXX.h:2045
Microsoft throw(...) extension.
A convenient class for passing around template argument information.
Definition: TemplateBase.h:517
bool isFunctionDeclarationContext() const
Return true if this declaration appears in a context where a function declarator would be a function ...
Definition: DeclSpec.h:2099
static bool isStaticDataMember(const Decl *D)
Determine whether the given declaration is a static data member.
virtual void HandleVTable(CXXRecordDecl *RD)
Callback involved at the end of a translation unit to notify the consumer that a vtable for the given...
Definition: ASTConsumer.h:132
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...
The base type of a class type.
Definition: Sema.h:5955
bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method)
Check whether 'this' shows up in the type of a static member function after the (naturally empty) cv-...
QualType getReturnType() const
Definition: Type.h:2977
Look up all declarations in a scope with the given name, including resolved using declarations...
Definition: Sema.h:2660
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...
unsigned getMinRequiredArguments() const
getMinRequiredArguments - Returns the minimum number of arguments needed to call this function...
Definition: Decl.cpp:2786
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...
bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionExceptionSpec - Checks whether the exception spec is a subset of base spec...
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:1801
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:1764
bool CheckConstexprFunctionDecl(const FunctionDecl *FD)
void DefineInheritingConstructor(SourceLocation UseLoc, CXXConstructorDecl *Constructor)
Define the specified inheriting constructor.
An x-value expression is a reference to an object with independent storage but which can be "moved"...
Definition: Specifiers.h:111
field_range fields() const
Definition: Decl.h:3295
A friend of a previously-undeclared entity.
Definition: DeclBase.h:971
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
static bool BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, FieldDecl *Field, IndirectFieldDecl *Indirect, CXXCtorInitializer *&CXXMemberInit)
StmtResult StmtError()
Definition: Ownership.h:268
bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, DeclarationName Name, SourceLocation Loc)
Diagnose a declaration whose declarator-id has the given nested-name-specifier.
Definition: SemaDecl.cpp:4699
static void NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set, const QualType &Type)
Recursively add the bases of Type. Don't add Type itself.
NamedDecl * BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, AttributeList *AttrList, bool IsInstantiation, bool HasTypenameKeyword, SourceLocation TypenameLoc)
Builds a using declaration.
static bool isValidUDSuffix(const LangOptions &LangOpts, StringRef Suffix)
Determine whether a suffix is a valid ud-suffix.
capture_iterator capture_end() const
Retrieve an iterator pointing past the end of the sequence of lambda captures.
Definition: ExprCXX.cpp:1016
semantics_iterator semantics_end()
Definition: Expr.h:4766
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1080
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2486
Expr * getNoexceptExpr() const
Definition: Type.h:3225
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2875
An implicit 'self' parameter.
Definition: DeclSpec.h:899
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:146
RecordDecl * getDecl() const
Definition: Type.h:3553
FunctionDecl * getTemplateInstantiationPattern() const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition: Decl.cpp:3123
void CheckDelegatingCtorCycles()
QualType CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckDestructorDeclarator - Called by ActOnDeclarator to check the well-formednes of the destructor d...
ImplicitExceptionSpecification ComputeDefaultedDtorExceptionSpec(CXXMethodDecl *MD)
Determine what sort of exception specification a defaulted destructor of a class will have...
static void ReferenceDllExportedMethods(Sema &S, CXXRecordDecl *Class)
static void checkMoveAssignmentForRepeatedMove(Sema &S, CXXRecordDecl *Class, SourceLocation CurrentLocation)
Check if we're implicitly defining a move assignment operator for a class with virtual bases...
child_range children()
Definition: Expr.h:3886
void setExceptionVariable(bool EV)
Definition: Decl.h:1143
bool isOverloadedOperator() const
isOverloadedOperator - Whether this function declaration represents an C++ overloaded operator...
Definition: Decl.h:2009
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
Definition: Sema.h:687
CanQualType LongDoubleTy
Definition: ASTContext.h:892
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2454
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:38
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:6046
The type of a data member.
Definition: Sema.h:5961
bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:651
const Type * getBaseClass() const
If this is a base class initializer, returns the type of the base class.
Definition: DeclCXX.cpp:1714
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:1760
bool isDelegatingInitializer() const
Determine whether this initializer is creating a delegating constructor.
Definition: DeclCXX.h:1993
ExprResult ActOnCXXThis(SourceLocation loc)
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
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:2430
void setNumCtorInitializers(unsigned numCtorInitializers)
Definition: DeclCXX.h:2233
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:708
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
static UnresolvedUsingValueDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo)
Definition: DeclCXX.cpp:2162
std::string getAsString() const
getNameAsString - Retrieve the human-readable string for this name.
SourceLocation getLocation() const
Definition: Attr.h:93
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:879
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1422
bool isStaticLocal() const
isStaticLocal - Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:908
Preprocessor & PP
Definition: Sema.h:294
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1800
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
Definition: DeclCXX.cpp:2069
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Definition: Expr.cpp:720
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
static bool findCircularInheritance(const CXXRecordDecl *Class, const CXXRecordDecl *Current)
Determine whether the given class is a base class of the given class, including looking at dependent ...
static void DelegatingCycleHelper(CXXConstructorDecl *Ctor, llvm::SmallSet< CXXConstructorDecl *, 4 > &Valid, llvm::SmallSet< CXXConstructorDecl *, 4 > &Invalid, llvm::SmallSet< CXXConstructorDecl *, 4 > &Current, Sema &S)
An ordinary object is located at an address in memory.
Definition: Specifiers.h:118
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3063
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
A class that does preorder depth-first traversal on the entire Clang AST and visits each node...
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 '{'.
Represents an ObjC class declaration.
Definition: DeclObjC.h:853
DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, AttributeList *Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
Represents a linkage specification.
Definition: DeclCXX.h:2454
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)
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:497
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Sema/Lookup.h:367
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:2644
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1167
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:496
detail::InMemoryDirectory::const_iterator I
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:3060
unsigned getNumParams() const
Definition: TypeLoc.h:1301
QualType getCanonicalTypeInternal() const
Definition: Type.h:1973
init_iterator init_begin()
Retrieve an iterator to the first initializer.
Definition: DeclCXX.h:2193
Ordinary names.
Definition: DeclBase.h:138
QualType getType() const
Definition: Decl.h:530
bool isInvalid() const
const LangOptions & LangOpts
Definition: Sema.h:293
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:753
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:53
bool isUnnamedBitfield() const
Determines whether this is an unnamed bitfield.
Definition: Decl.h:2283
void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AL, bool IncludeCXX11Attributes=true)
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
Definition: Sema.h:2685
void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc)
PopPragmaVisibility - Pop the top element of the visibility stack; used for '#pragma GCC visibility' ...
Definition: SemaAttr.cpp:588
This object can be modified without requiring retains or releases.
Definition: Type.h:137
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5...
Definition: Sema.h:6811
SourceRange getRange() const
Definition: DeclSpec.h:68
bool isDefined(const FunctionDecl *&Definition) const
isDefined - Returns true if the function is defined at all, including a deleted definition.
Definition: Decl.cpp:2485
param_iterator param_begin()
Definition: Decl.h:1906
Represents the this expression in C++.
Definition: ExprCXX.h:860
UsingShadowDecl * BuildUsingShadowDecl(Scope *S, UsingDecl *UD, NamedDecl *Target, UsingShadowDecl *PrevDecl)
Builds a shadow declaration corresponding to a 'using' declaration.
bool isAbstract() const
Determine whether this class has a pure virtual function.
Definition: DeclCXX.h:1155
SourceLocation getUsingLoc() const
Return the source location of the 'using' keyword.
Definition: DeclCXX.h:2888
field_iterator field_end() const
Definition: Decl.h:3298
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl)
Class that aids in the construction of nested-name-specifiers along with source-location information ...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
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 '<' before the template argument list.
void removeInClassInitializer()
removeInClassInitializer - Remove the C++11 in-class initializer from this member.
Definition: Decl.h:2349
CXXMethodDecl * getMethod() const
Definition: Sema.h:895
AnnotatingParser & P
void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an initializer for the declaratio...
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack...
Definition: DeclBase.cpp:168
CXXSpecialMember
Kinds of C++ special members.
Definition: Sema.h:969
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.
bool isStatic() const
Definition: DeclCXX.cpp:1408
bool isUnion() const
Definition: Decl.h:2856
void setBases(CXXBaseSpecifier const *const *Bases, unsigned NumBases)
Sets the base classes of this struct or class.
Definition: DeclCXX.cpp:138
CXXConstructorDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2320
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3148
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1719
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:259
Decl * ActOnEmptyDeclaration(Scope *S, AttributeList *AttrList, SourceLocation SemiLoc)
Handle a C++11 empty-declaration and attribute-declaration.
TypeAliasDecl - Represents the declaration of a typedef-name via a C++0x alias-declaration.
Definition: Decl.h:2618
CanQualType getCanonicalTypeUnqualified() const
TST getTypeSpecType() const
Definition: DeclSpec.h:473
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:539
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Sema/Lookup.h:194
QualType getParamType(unsigned i) const
Definition: Type.h:3161
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3041
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition: DeclSpec.cpp:119
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
Definition: DeclCXX.h:1278
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3193
void ClearConstexprSpec()
Definition: DeclSpec.h:704
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:2510
CXXMethodDecl * getMethodDecl() const
Retrieves the declaration of the called method.
Definition: ExprCXX.cpp:544
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:10435
void ActOnFinishCXXMemberDecls()
Perform any semantic analysis which needs to be delayed until all pending class member declarations h...
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:980
void DefineImplicitCopyAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared copy assignment operator.
Causes a block literal to by copied to the heap and then autoreleased.
bool isParameterPack() const
Determine whether this parameter is actually a function parameter pack.
Definition: Decl.cpp:2428
static unsigned NumImplicitCopyConstructors
The number of implicitly-declared copy constructors.
Definition: ASTContext.h:2433
A RAII object to enter scope of a compound statement.
Definition: Sema.h:3274
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...
bool inferObjCARCLifetime(ValueDecl *decl)
Definition: SemaDecl.cpp:5352
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:577
bool needsImplicitMoveAssignment() const
Determine whether this class should get an implicit move assignment operator or if any existing speci...
Definition: DeclCXX.h:988
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a member subobject.
param_type_iterator param_type_begin() const
Definition: Type.h:3281
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1759
StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp)
Definition: SemaStmt.cpp:3116
ImplicitExceptionSpecification ComputeDefaultedCopyCtorExceptionSpec(CXXMethodDecl *MD)
Determine what sort of exception specification a defaulted default constructor of a class will have...
SourceLocation getFriendSpecLoc() const
Definition: DeclSpec.h:693
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:454
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1233
bool isGenericLambda() const
Determine whether this class describes a generic lambda function object (i.e.
Definition: DeclCXX.cpp:979
static bool defaultedSpecialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, Sema::CXXSpecialMember CSM, bool ConstArg)
Determine whether the specified special member function would be constexpr if it were implicitly defi...
static EmptyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
Definition: Decl.cpp:4133
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:226
static StaticAssertDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StaticAssertLoc, Expr *AssertExpr, StringLiteral *Message, SourceLocation RParenLoc, bool Failed)
Definition: DeclCXX.cpp:2207
ID
Defines the set of possible language-specific address spaces.
Definition: AddressSpaces.h:27
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1979
bool isMoreQualifiedThan(QualType Other) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
Definition: Type.h:5232
const CXXMethodDecl *const * method_iterator
Definition: DeclCXX.h:1793
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
void setInClassInitializer(Expr *Init)
setInClassInitializer - Set the C++11 in-class initializer for this member.
Definition: Decl.h:2340
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Definition: Decl.h:247
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)
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
bool InstantiateInClassInitializer(SourceLocation PointOfInstantiation, FieldDecl *Instantiation, FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the definition of a field from the given pattern.
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:534
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isInline, bool isImplicitlyDeclared)
Definition: DeclCXX.cpp:1908
int * Depth
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
Allows QualTypes to be sorted and hence used in maps and sets.
Decl * ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *AssertMessageExpr, SourceLocation RParenLoc)
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:1820
bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method)
Whether this' shows up in the exception specification of a static member function.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:155
const Type * getTypeForDecl() const
Definition: Decl.h:2507
unsigned param_size() const
Definition: Decl.h:1900
unsigned getTypeQualifiers() const
Definition: DeclCXX.h:1817
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(NamedDecl *D, const TemplateArgumentList *Innermost=nullptr, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:521
Expr - This represents one expression.
Definition: Expr.h:104
StringRef getName() const
Return the actual identifier string.
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:99
SourceLocation getAtomicSpecLoc() const
Definition: DeclSpec.h:538
bool isDeclarationOfFunction() const
Determine whether the declaration that will be produced from this declaration will be a function...
Definition: DeclSpec.cpp:261
bool isInstance() const
Definition: DeclCXX.h:1728
ImplicitExceptionSpecification ComputeDefaultedMoveCtorExceptionSpec(CXXMethodDecl *MD)
Determine what sort of exception specification a defaulted move constructor of a class will have...
bool isDeclScope(Decl *D)
isDeclScope - Return true if this is the scope that the specified decl is declared in...
Definition: Scope.h:306
Helper class that collects exception specifications for implicitly-declared special member functions...
Definition: Sema.h:4227
MatchFinder::MatchCallback * Callback
void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath)
StateNode * Previous
Declaration of a template type parameter.
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
bool isFunctionDefinition() const
Definition: DeclSpec.h:2219
void setHideTags(bool Hide)
Sets whether tag declarations should be hidden by non-tag declarations during resolution.
Definition: Sema/Lookup.h:238
static void getDefaultArgExprsForConstructors(Sema &S, CXXRecordDecl *Class)
This file defines the classes used to store parsed information about declaration-specifiers and decla...
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:943
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:4189
bool isVirtual() const
Definition: DeclCXX.h:1745
void setRBraceLoc(SourceLocation L)
Definition: Decl.h:502
Inits[]
Definition: OpenMPClause.h:310
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2345
LazyDeclPtr StdNamespace
The C++ "std" namespace, where the standard library resides.
Definition: Sema.h:683
void freeParams()
Reset the parameter list to having zero parameters.
Definition: DeclSpec.h:1296
void setInit(Expr *I)
Definition: Decl.cpp:2087
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:111
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:875
static unsigned NumImplicitMoveConstructors
The number of implicitly-declared move constructors.
Definition: ASTContext.h:2440
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Sema/Lookup.h:458
llvm::SmallSet< SpecialMemberDecl, 4 > SpecialMembersBeingDeclared
The C++ special members which we are currently in the process of declaring.
Definition: Sema.h:984
bool isLiteral() const
Determine whether this class is a literal type.
Definition: DeclCXX.h:1316
void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir)
void setRBraceLoc(SourceLocation L)
Definition: DeclCXX.h:2509
Defines the clang::Preprocessor interface.
bool CheckInheritingConstructorUsingDecl(UsingDecl *UD)
Additional checks for a using declaration referring to a constructor name.
bool isInherited() const
Definition: Attr.h:97
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:12273
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:216
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:1927
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3169
bool isInitListConstructor(const CXXConstructorDecl *Ctor)
Determine whether Ctor is an initializer-list constructor, as defined in [dcl.init.list]p2.
SourceLocation getVolatileSpecLoc() const
Definition: DeclSpec.h:537
bool isLocalExternDecl()
Determine whether this is a block-scope declaration with linkage.
Definition: DeclBase.h:928
bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc, SourceLocation ColonLoc, AttributeList *Attrs=nullptr)
ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
DeclContext * getDeclContext()
Definition: DeclBase.h:393
void PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, const BlockExpr *blkExpr=nullptr)
Definition: Sema.cpp:1159
FunctionProtoType::ExceptionSpecInfo getExceptionSpec() const
Overwrite an EPI's exception specification with this computed exception specification.
Definition: Sema.h:4273
ExprResult BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, TypeSourceInfo *Ty, Expr *E, SourceRange AngleBrackets, SourceRange Parens)
Definition: SemaCast.cpp:236
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition: Type.cpp:2385
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.
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:65
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param)
ActOnDelayedCXXMethodParameter - We've already started a delayed C++ method declaration.
Represents a C++ template name within the type system.
Definition: TemplateName.h:175
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
bool hasUserDeclaredMoveConstructor() const
Determine whether this class has had a move constructor declared by the user.
Definition: DeclCXX.h:894
NamedDecl * ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *D, LookupResult &Previous, bool &Redeclaration)
ActOnTypedefNameDecl - Perform semantic checking for a declaration which declares a typedef-name...
Definition: SemaDecl.cpp:5259
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:6518
Defines the clang::TypeLoc interface and its subclasses.
There is no noexcept specifier.
Definition: Type.h:3212
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprCXX.h:1666
SourceLocation getLastLocation() const
Definition: DeclSpec.h:2282
SourceRange getDefaultArgRange() const
Retrieve the source range that covers the entire default argument.
Definition: Decl.cpp:2389
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
Definition: Sema.h:1388
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:1999
void DiscardCleanupsInEvaluationContext()
Definition: SemaExpr.cpp:12537
bool isConstexprSpecified() const
Definition: DeclSpec.h:698
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...
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:318
bool isExplicit() const
Determine whether this constructor was marked "explicit" or not.
Definition: DeclCXX.h:2174
void setInheritConstructors(bool Inherit=true)
Set that this base class's constructors should be inherited.
Definition: DeclCXX.h:219
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:107
SourceLocation getLocEnd() const LLVM_READONLY
SmallVector< VTableUse, 16 > VTableUses
The list of vtables that are required but have not yet been materialized.
Definition: Sema.h:5252
static bool isPotentialConstantExpr(const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExpr - Return true if this function's definition might be usable in a constant exp...
StorageClass
Storage classes.
Definition: Specifiers.h:198
Expr * getSubExpr() const
Definition: Expr.h:1681
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
Definition: DeclSpec.h:582
TemplateDecl * AdjustDeclIfTemplate(Decl *&Decl)
AdjustDeclIfTemplate - If the given decl happens to be a template, reset the parameter D to reference...
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...
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1751
void AdjustDestructorExceptionSpec(CXXRecordDecl *ClassDecl, CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don't have one.
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
bool hasTrailingReturn() const
Definition: Type.h:3265
bool isFunctionOrMethod() const
Definition: DeclBase.h:1249
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:85
InClassInitStyle
In-class initialization styles for non-static data members.
Definition: Specifiers.h:221
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:1200
const TemplateArgument * data() const
Retrieve a pointer to the template argument list.
Definition: DeclTemplate.h:235
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc)
bool isExternallyVisible() const
Definition: Decl.h:280
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1654
void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method)
Integrate another called method into the collected data.
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
Definition: Decl.h:1935
DeclContextLookupResult slice(size_t N) const
Definition: DeclBase.h:1101
SmallVector< ActiveTemplateInstantiation, 16 > ActiveTemplateInstantiations
List of active template instantiations.
Definition: Sema.h:6601
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
Definition: SemaType.cpp:6818
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
Definition: DeclCXX.cpp:984
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2334
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:190
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1045
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
CXXRecordDecl * getStdBadAlloc() const
class LLVM_ALIGNAS(8) TemplateSpecializationType unsigned NumArgs
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:3988
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:707
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
Definition: SemaDecl.cpp:1203
void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an initializer for the declaration ...
ValueDecl * getDecl()
Definition: Expr.h:1007
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2392
QualType getCVRQualifiedType(QualType T, unsigned CVR) const
Return a type with additional const, volatile, or restrict qualifiers.
Definition: ASTContext.h:1668
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:144
llvm::FoldingSet< SpecialMemberOverloadResult > SpecialMemberCache
A cache of special member function overload resolution results for C++ records.
Definition: Sema.h:904
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
SourceLocation getLocEnd() const LLVM_READONLY
Definition: TypeLoc.h:131
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1797
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:450
RecordDecl * getDefinition() const
getDefinition - Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3285
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
Definition: Type.h:704
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:162
bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New, const CXXMethodDecl *Old)
void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitDefaultConstructor - Checks for feasibility of defining this constructor as the default...
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:602
bool isVirtualSpecified() const
Definition: DeclSpec.h:559
bool needsOverloadResolutionForCopyAssignment() const
Determine whether we need to eagerly declare a defaulted copy assignment operator for this class...
Definition: DeclCXX.h:945
CXXConstructorDecl * LookupCopyingConstructor(CXXRecordDecl *Class, unsigned Quals)
Look up the copying constructor for the given class.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:228
static bool RefersToRValueRef(Expr *MemRef)
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:545
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:1794
This is a legitimate overload: the existing declarations are functions or function templates with dif...
Definition: Sema.h:2177
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc, Decl *TagDecl, SourceLocation LBrac, SourceLocation RBrac, AttributeList *AttrList)
void NoteHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl< CXXMethodDecl * > &OverloadedMethods)
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
ExprResult ActOnFinishFullExpr(Expr *Expr)
Definition: Sema.h:4784
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:473
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)
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:2902
DelegatingCtorDeclsType DelegatingCtorDecls
All the delegating constructors seen so far in the file, used for cycle detection at the end of the T...
Definition: Sema.h:501
bool isAmbiguous() const
Definition: Sema/Lookup.h:242
void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow)
Hides a using shadow declaration.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
void addAttr(Attr *A)
Definition: DeclBase.h:449
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
static void SearchForReturnInStmt(Sema &Self, Stmt *S)
Wrapper for source info for arrays.
Definition: TypeLoc.h:1358
bool doesThisDeclarationHaveABody() const
doesThisDeclarationHaveABody - Returns whether this specific declaration of the function has a body -...
Definition: Decl.h:1732
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
TemplateArgumentLoc getArgLoc(unsigned i) const
Definition: TypeLoc.h:1479
There is no lifetime qualification on this type.
Definition: Type.h:133
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
DeclContext * getEntity() const
Definition: Scope.h:310
static bool CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef, const FunctionDecl *FnDecl)
void setSourceOrder(int pos)
Set the source order of this initializer.
Definition: DeclCXX.h:2078
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type. ...
Definition: Decl.cpp:2912
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:215
ASTMatchFinder *const Finder
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:840
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:236
static unsigned NumImplicitDestructorsDeclared
The number of implicitly-declared destructors for which declarations were built.
Definition: ASTContext.h:2465
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1540
#define false
Definition: stdbool.h:33
CanQualType BuiltinFnTy
Definition: ASTContext.h:897
The "struct" keyword.
Definition: Type.h:4176
Kind
static CXXConstructorDecl * findUserDeclaredCtor(CXXRecordDecl *RD)
bool CheckUsingDeclQualifier(SourceLocation UsingLoc, 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...
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3053
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:4692
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2357
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:144
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:187
enum clang::DeclaratorChunk::@183 Kind
SourceRange getSourceRange() const LLVM_READONLY
Determine the source range covering the entire initializer.
Definition: DeclCXX.cpp:1734
bool isInterface() const
Definition: Decl.h:2854
llvm::SmallPtrSet< QualType, 4 > IndirectBaseSet
Use small set to collect indirect bases.
This is not an overload because the lookup results contain a non-function.
Definition: Sema.h:2185
Encodes a location in the source.
void setOperatorDelete(FunctionDecl *OD)
Definition: DeclCXX.cpp:1920
void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record)
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Determines whether this field is a representative for an anonymous struct ...
Definition: Decl.cpp:3453
body_range body()
Definition: Stmt.h:569
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:932
unsigned getNumParams() const
getNumParams - Return the number of parameters this function must have based on its FunctionType...
Definition: Decl.cpp:2743
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3570
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5089
bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange)
Mark the given method pure.
Decl * ActOnFinishLinkageSpecification(Scope *S, Decl *LinkageSpec, SourceLocation RBraceLoc)
ActOnFinishLinkageSpecification - Complete the definition of the C++ linkage specification LinkageSpe...
const TemplateArgument * iterator
Definition: Type.h:4070
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const
Test if this context is part of the enclosing namespace set of the context NS, as defined in C++0x [n...
Definition: DeclBase.cpp:1522
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3463
method_iterator begin_overridden_methods() const
Definition: DeclCXX.cpp:1583
Decl * BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, StringLiteral *AssertMessageExpr, SourceLocation RParenLoc, bool Failed)
FieldDecl * getAnyMember() const
Definition: DeclCXX.h:2037
An overloaded operator name, e.g., operator+.
Definition: DeclSpec.h:885
Expr * getRepAsExpr() const
Definition: DeclSpec.h:489
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
Definition: DeclSpec.h:1731
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.
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isExplicit, bool isInline, bool isImplicitlyDeclared, bool isConstexpr)
Definition: DeclCXX.cpp:1755
bool isValid() const
Return true if this is a valid SourceLocation object.
static unsigned NumImplicitCopyAssignmentOperatorsDeclared
The number of implicitly-declared copy assignment operators for which declarations were built...
Definition: ASTContext.h:2451
bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method)
Check whether 'this' shows up in the attributes of the given static member function.
reference front() const
Definition: DeclBase.h:1096
void ExitDeclaratorContext(Scope *S)
Definition: SemaDecl.cpp:1133
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2644
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:143
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc)
Build the type that describes a C++ typename specifier, e.g., "typename T::type". ...
attr_range attrs() const
Definition: DeclBase.h:459
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:124
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:311
bool isValid() const
unsigned size_overridden_methods() const
Definition: DeclCXX.cpp:1593
FunctionTypeInfo Fun
Definition: DeclSpec.h:1433
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.
ASTContext & getASTContext() const
Definition: Sema.h:1048
static bool CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl, CanQualType ExpectedResultType, CanQualType ExpectedFirstParamType, unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag)
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
Definition: SemaInternal.h:92
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:431
void setReferenced(bool R=true)
Definition: DeclBase.h:543
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:690
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:493
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:3004
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3527
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
static InitializedEntity InitializeElement(ASTContext &Context, unsigned Index, const InitializedEntity &Parent)
Create the initialization entity for an array element.
QualType withConst() const
Definition: Type.h:741
void removeShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:2119
void setCtorInitializers(CXXCtorInitializer **Initializers)
Definition: DeclCXX.h:2237
ClassTemplateDecl * StdInitializerList
The C++ "std::initializer_list" template, which is defined in <initializer_list>. ...
Definition: Sema.h:691
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1701
unsigned getDepth() const
Retrieve the depth of the template parameter.
void setDefaulted(bool D=true)
Definition: Decl.h:1765
bool needsOverloadResolutionForMoveAssignment() const
Determine whether we need to eagerly declare a move assignment operator for this class.
Definition: DeclCXX.h:998
paths_iterator begin()
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:178
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
SourceLocation getSourceLocation() const
Determine the source location of the initializer.
Definition: DeclCXX.cpp:1721
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:618
No ref-qualifier was provided.
Definition: Type.h:1206
void setEntity(DeclContext *E)
Definition: Scope.h:311
bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckForFunctionMarkedFinal - Checks whether a virtual member function overrides a virtual member fun...
bool hasUserProvidedDefaultConstructor() const
Whether this class has a user-provided default constructor per C++11.
Definition: DeclCXX.h:845
llvm::SmallPtrSet< const CXXRecordDecl *, 8 > RecordDeclSetTy
Definition: Sema.h:466
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
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 implicitly move constructor, but overload resolution failed so we...
Definition: DeclCXX.h:906
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3522
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2094
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition: Sema/Lookup.h:52
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2085
SourceLocation getConstexprSpecLoc() const
Definition: DeclSpec.h:699
bool isTemplateParamScope() const
isTemplateParamScope - Return true if this scope is a C++ template parameter scope.
Definition: Scope.h:362
void push_back(const T &LocalValue)
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:881
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).
Decl * ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc, unsigned TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, AttributeList *Attr, MultiTemplateParamsArg TempParamLists)
Handle a friend tag declaration where the scope specifier was templated.
Describes the kind of initialization being performed, along with location information for tokens rela...
static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident)
A friend declaration.
Definition: Sema.h:5979
AbstractDiagSelID
Definition: Sema.h:5497
arg_range arguments()
Definition: Expr.h:2224
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:5640
A class for iterating through a result set and possibly filtering out results.
Definition: Sema/Lookup.h:557
Direct list-initialization.
Definition: Specifiers.h:224
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2254
SourceLocation getVirtualSpecLoc() const
Definition: DeclSpec.h:560
static CXXDefaultInitExpr * Create(const ASTContext &C, SourceLocation Loc, FieldDecl *Field)
Field is the non-static data member whose default initializer is used by this expression.
Definition: ExprCXX.h:1039
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2712
TypeLocClass getTypeLocClass() const
Definition: TypeLoc.h:90
bool isFinalSpelledSealed() const
Definition: DeclSpec.h:2274
void CheckExplicitlyDefaultedMemberExceptionSpec(CXXMethodDecl *MD, const FunctionProtoType *T)
Check whether the exception specification provided for an explicitly-defaulted special member matches...
void setIsParsingBaseSpecifiers()
Definition: DeclCXX.h:697
SourceLocation getBegin() const
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:164
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:5706
T * get(ExternalASTSource *Source) const
Retrieve the pointer to the AST node that this lazy pointer.
TypeLoc getReturnLoc() const
Definition: TypeLoc.h:1309
A default argument.
Definition: Sema.h:5988
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:72
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1368
static bool BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, CXXBaseSpecifier *BaseSpec, bool IsInheritedVirtualBase, CXXCtorInitializer *&CXXBaseInit)
No entity found met the criteria.
Definition: Sema/Lookup.h:34
NoexceptResult getNoexceptSpec(const ASTContext &Ctx) const
Get the meaning of the noexcept spec on this function, if any.
Definition: Type.cpp:2760
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.
bool isAscii() const
Definition: Expr.h:1543
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:156
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:141
bool isFileContext() const
Definition: DeclBase.h:1265
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
Definition: Sema.h:446
bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Previous)
Checks that the given using declaration is not an invalid redeclaration.
bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const LangOptions &Lang)
Definition: DeclSpec.cpp:771
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
Definition: SemaType.cpp:1889
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition: Decl.h:2818
void ActOnMemInitializers(Decl *ConstructorDecl, SourceLocation ColonLoc, ArrayRef< CXXCtorInitializer * > MemInits, bool AnyErrors)
ActOnMemInitializers - Handle the member initializers for a constructor.
Attr * clone(ASTContext &C) const
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5159
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, AttributeList *AttrList)
Definition: SemaDecl.cpp:13442
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:427
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:645
void setExplicitlyDefaulted(bool ED=true)
Definition: Decl.h:1770
void setHasInheritedDefaultArg(bool I=true)
Definition: Decl.h:1431
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:261
static Sema::ImplicitExceptionSpecification computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, CXXMethodDecl *MD)
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:69
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:557
bool isDynamicClass() const
Definition: DeclCXX.h:693
Opcode getOpcode() const
Definition: Expr.h:1678
CXXMethodDecl * getLambdaStaticInvoker() const
Retrieve the lambda static invoker, the address of which is returned by the conversion operator...
Definition: DeclCXX.cpp:1001
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:193
bool isFunctionProtoType() const
Definition: Type.h:1630
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1235
QualType getPointeeType() const
Definition: Type.h:2161
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:1235
Decl * ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc, SourceLocation NamespcLoc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *NamespcName, AttributeList *AttrList)
A constructor named via a template-id.
Definition: DeclSpec.h:893
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
getSpecialMember - get the special member enum for a method.
Definition: SemaDecl.cpp:2525
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
CXXDestructorDecl * DeclareImplicitDestructor(CXXRecordDecl *ClassDecl)
Declare the implicit destructor for the given class.
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:4088
The expression in a static assertion.
Definition: Sema.h:5967
MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, CXXRecordDecl *ClassDecl)
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1743
static AttributeList * getMSPropertyAttr(AttributeList *list)
param_range params()
Definition: Decl.h:1910
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
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)
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2526
attr::Kind getKind() const
Definition: Attr.h:86
ast_type_traits::DynTypedNode Node
QualType getType() const
Definition: Expr.h:125
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Whether this is an anonymous struct or union.
Definition: Decl.h:3233
CanQualType CharTy
Definition: ASTContext.h:883
TLS with a dynamic initializer.
Definition: Decl.h:718
Represents a template argument.
Definition: TemplateBase.h:40
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:1243
void setBody(Stmt *B)
Definition: Decl.cpp:2507
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:238
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument. ...
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
TagTypeKind
The kind of a tag type.
Definition: Type.h:4174
TypeSourceInfo * getTypeSourceInfo() const
Returns the declarator information for a base class or delegating initializer.
Definition: DeclCXX.h:2026
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3164
TSCS getThreadStorageClassSpec() const
Definition: DeclSpec.h:442
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2334
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LanguageIDs Lang, bool HasBraces)
Definition: DeclCXX.cpp:1961
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.h:461
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Definition: Decl.h:2636
CXXConstructorDecl * DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit copy constructor for the given class.
bool hasTypename() const
Return true if the using declaration has 'typename'.
Definition: DeclCXX.h:2910
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:3025
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:1121
AccessSpecifier getAccessSpecifier() const
Returns the access specifier for this base specifier.
Definition: DeclCXX.h:233
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:331
void EnterDeclaratorContext(Scope *S, DeclContext *DC)
EnterDeclaratorContext - Used when we must lookup names in the context of a declarator's nested name ...
Definition: SemaDecl.cpp:1104
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Sema/Lookup.h:214
bool hasUnparsedDefaultArg() const
hasUnparsedDefaultArg - Determines whether this parameter has a default argument that has not yet bee...
Definition: Decl.h:1410
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
bool isFriendSpecified() const
Definition: DeclSpec.h:692
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return 0.
Definition: Expr.cpp:1210
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1308
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 'Type', insert an implicit cast.
Definition: Sema.cpp:369
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:2658
SourceLocation getLocStart() const LLVM_READONLY
Definition: TypeLoc.h:130
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with ',...)', this is true.
Definition: DeclSpec.h:1199
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
static bool InitializationHasSideEffects(const FieldDecl &FD)
static __inline__ uint32_t volatile uint32_t * p
Definition: arm_acle.h:75
bool hasVariantMembers() const
Determine whether this class has any variant members.
Definition: DeclCXX.h:1166
bool isInvalidDecl() const
Definition: DeclBase.h:509
ImplicitExceptionSpecification ComputeDefaultedCopyAssignmentExceptionSpec(CXXMethodDecl *MD)
Determine what sort of exception specification a defautled copy assignment operator of a class will h...
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
Definition: Decl.h:2437
void ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc, Expr *defarg)
ActOnParamDefaultArgument - Check whether the default argument provided for a function parameter is w...
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
HandleFunctionTypeMismatch - Gives diagnostic information for differeing function types...
SourceLocation getFinalLoc() const
Definition: DeclSpec.h:2275
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1056
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:891
bool isFinalSpecified() const
Definition: DeclSpec.h:2273
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:104
static void PopulateKeysForFields(FieldDecl *Field, SmallVectorImpl< const void * > &IdealInits)
std::pair< SourceLocation, SourceLocation > getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
Definition: DeclBase.cpp:1511
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:152
static NamespaceDecl * getNamespaceDecl(NamedDecl *D)
getNamespaceDecl - Returns the namespace a decl represents.
QualType getExceptionObjectType(QualType T) const
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3087
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Definition: DeclCXX.cpp:1978
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
Definition: DeclCXX.h:1170
DeclarationName - The name of a declaration.
Expr * getDefaultArg()
Definition: Decl.cpp:2372
ImplicitExceptionSpecification ComputeDefaultedDefaultCtorExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD)
Determine what sort of exception specification a defaulted copy constructor of a class will have...
unsigned getNumHandlers() const
Definition: StmtCXX.h:103
void handleTagNumbering(const TagDecl *Tag, Scope *TagScope)
Definition: SemaDecl.cpp:3616
bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths) const
Look for entities within the base classes of this C++ class, transitively searching all base class su...
static UnresolvedUsingTypenameDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation TypenameLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TargetNameLoc, DeclarationName TargetName)
Definition: DeclCXX.cpp:2187
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
Definition: SemaDecl.cpp:1069
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:5248
param_type_iterator param_type_end() const
Definition: Type.h:3284
A mapping from each virtual member function to its set of final overriders.
StringRef getString() const
Definition: Expr.h:1500
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:624
bool hasTrivialMoveConstructor() const
Determine whether this class has a trivial move constructor (C++11 [class.copy]p12) ...
Definition: DeclCXX.h:1220
detail::InMemoryDirectory::const_iterator E
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:2369
bool hasUserDeclaredMoveAssignment() const
Determine whether this class has had a move assignment declared by the user.
Definition: DeclCXX.h:966
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:138
IdentifierResolver IdResolver
Definition: Sema.h:675
semantics_iterator semantics_begin()
Definition: Expr.h:4760
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2187
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Sema/Lookup.h:249
SourceLocation getLocation() const
Definition: ExprCXX.h:876
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1946
bool isMsStruct(const ASTContext &C) const
isMsStrust - Get whether or not this is an ms_struct which can be turned on with an attribute...
Definition: Decl.cpp:3763
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
Definition: DeclCXX.h:2032
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation...
Definition: DeclCXX.cpp:388
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
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...
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization. ...
MemInitResult BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo, Expr *Init, CXXRecordDecl *ClassDecl, SourceLocation EllipsisLoc)
bool field_empty() const
Definition: Decl.h:3304
bool hasUserDeclaredCopyConstructor() const
Determine whether this class has a user-declared copy constructor.
Definition: DeclCXX.h:852
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1022
DeclClass * getCorrectionDeclAs() const
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:1459
unsigned Map[Count]
The type of a lookup table which maps from language-specific address spaces to target-specific ones...
Definition: AddressSpaces.h:45
static unsigned NumImplicitCopyAssignmentOperators
The number of implicitly-declared copy assignment operators.
Definition: ASTContext.h:2447
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2551
param_iterator param_end()
Definition: Decl.h:1907
void PushUsingDirective(UsingDirectiveDecl *UDir)
Definition: Scope.h:439
CXXConstructorDecl * DeclareImplicitDefaultConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit default constructor for the given class.
bool isRValueReferenceType() const
Definition: Type.h:5320
const Stmt * getThen() const
Definition: Stmt.h:903
static InitializedEntity InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, bool IsInheritedVirtualBase)
Create the initialization entity for a base class subobject.
Definition: SemaInit.cpp:2788
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:5255
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1807
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:127
static FunctionProtoType::ExtProtoInfo getImplicitMethodEPI(Sema &S, CXXMethodDecl *MD)
bool hasInheritedDefaultArg() const
Definition: Decl.h:1427
void RemoveDecl(Decl *D)
Definition: Scope.h:276
Name lookup found a single declaration that met the criteria.
Definition: Sema/Lookup.h:43
bool empty() const
Return true if no decls were found.
Definition: Sema/Lookup.h:280
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...
bool isObjCObjectType() const
Definition: Type.h:5380
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2220
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
static AccessSpecifier MergeAccess(AccessSpecifier PathAccess, AccessSpecifier DeclAccess)
Calculates the access of a decl that is reached along a path.
Definition: DeclCXX.h:1582
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Definition: Type.h:808
Decl * ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc, SourceLocation NamespaceLoc, SourceLocation IdentLoc, IdentifierInfo *Ident, SourceLocation LBrace, AttributeList *AttrList, UsingDirectiveDecl *&UsingDecl)
ActOnStartNamespaceDef - This is called at the start of a namespace definition.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:191
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class.copy]p25)
Definition: DeclCXX.h:1248
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3544
bool isTriviallyCopyableType(ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2092
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:421
static bool CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl)
void setUnparsedDefaultArg()
setUnparsedDefaultArg - Specify that this parameter has an unparsed default argument.
Definition: Decl.h:1423
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:2414
static void diagnoseDeprecatedCopyOperation(Sema &S, CXXMethodDecl *CopyOp, SourceLocation UseLoc)
Diagnose an implicit copy operation for a class which is odr-used, but which is deprecated because th...
SourceManager & getSourceManager() const
Definition: Sema.h:1046
bool TypeAlias
Whether this template specialization type is a substituted type alias.
Definition: Type.h:4005
bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl)
CheckLiteralOperatorDeclaration - Check whether the declaration of this literal operator function is ...
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5675
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy.
Definition: Sema.h:1853
static void extendRight(SourceRange &R, SourceRange After)
unsigned getTypeQuals() const
Definition: Type.h:3267
QualType getCanonicalType() const
Definition: Type.h:5128
Decl::Kind getDeclKind() const
Definition: DeclBase.h:1194
bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl, const AttributeList *AttrList)
UsingDecl * getUsingDecl() const
Gets the using declaration to which this declaration is tied.
Definition: DeclCXX.cpp:2099
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, bool IsDecltype=false)
Definition: SemaExpr.cpp:12460
Represents a C++ base or member initializer.
Definition: DeclCXX.h:1885
LanguageIDs
Represents the language in a linkage specification.
Definition: DeclCXX.h:2463
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:148
SourceRange getSourceRange() const LLVM_READONLY
getSourceRange - The range of the declaration name.
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3268
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false)
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S'...
Definition: SemaDecl.cpp:1268
CXXRecordDecl * getOrigin() const
Retrieve the type from which this base-paths search began.
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope...
Definition: SemaDecl.cpp:1273
TrivialSubobjectKind
The kind of subobject we are checking for triviality.
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.
bool isFunctionType() const
Definition: Type.h:5302
static const void * GetKeyForBase(ASTContext &Context, QualType BaseType)
UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations
A mapping from parameters with unparsed default arguments to the set of instantiations of each parame...
Definition: Sema.h:934
TemplateParameterList * MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, ArrayRef< TemplateParameterList * > ParamLists, bool IsFriend, bool &IsExplicitSpecialization, bool &Invalid)
Match the given template parameter lists to the given scope specifier, returning the template paramet...
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
CXXBasePath & front()
QualType BuildDecltypeType(Expr *E, SourceLocation Loc, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
Definition: SemaType.cpp:7000
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1275
bool isImplicitlyDeleted(FunctionDecl *FD)
Determine whether the given function is an implicitly-deleted special member function.
The noexcept specifier evaluates to false.
Definition: Type.h:3215
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2287
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1495
CXXConstructorDecl * getConstructor() const
Definition: ExprCXX.h:1211
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:253
decl_range decls()
Definition: Stmt.h:479
static UsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, UsingDecl *Using, NamedDecl *Target)
Definition: DeclCXX.h:2801
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:2895
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1522
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:1759
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:978
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr)
Definition: SemaExpr.cpp:10954
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:1473
The template argument is a type.
Definition: TemplateBase.h:48
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
ActionResult< ParsedType > TypeResult
Definition: Ownership.h:254
static bool isInvalid(SourceLocation Loc, bool *Invalid)
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:78
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1257
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
bool isInvalid() const
The "class" keyword.
Definition: Type.h:4182
A template-id, e.g., f<int>.
Definition: DeclSpec.h:897
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, 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...
Represents a base class of a C++ class.
Definition: DeclCXX.h:157
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2354
bool isAnyMemberInitializer() const
Definition: DeclCXX.h:1973
CK_UncheckedDerivedToBase - A conversion from a C++ class pointer/reference to a base class that can ...
void setNamedTypeInfo(TypeSourceInfo *TInfo)
setNamedTypeInfo - Sets the source type info associated to the name.
const CXXConstructorDecl * getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Definition: DeclCXX.cpp:1881
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:343
bool isUsable() const
Definition: Ownership.h:160
void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, ArrayRef< Expr * > Args)
DiagnoseSentinelCalls - This routine checks whether a call or message-send is to a declaration with t...
Definition: SemaExpr.cpp:396
QualType getPointeeType() const
Definition: Type.h:2308
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3055
This is a scope that can contain a declaration.
Definition: Scope.h:57
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
Definition: LangOptions.h:141
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:1951
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:1782
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
Definition: SemaDecl.cpp:4781
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
Definition: Sema.cpp:1108
static const void * GetKeyForMember(ASTContext &Context, CXXCtorInitializer *Member)
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1024
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name.
Definition: DeclCXX.h:2898
Expr * getBase() const
Definition: Expr.h:2387
A template argument list.
Definition: DeclTemplate.h:172
bool hasNonTrivialObjCLifetime() const
Definition: Type.h:984
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
void setInvalidType(bool Val=true)
Definition: DeclSpec.h:2199
Expr * NoexceptExpr
Noexcept expression, if this is EST_ComputedNoexcept.
Definition: Type.h:3057
void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr, SourceLocation Loc)
PushNamespaceVisibilityAttr - Note that we've entered a namespace with a visibility attribute...
Definition: SemaAttr.cpp:579
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.
bool isPODType(ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:1961
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:1665
void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc, CXXRecordDecl *Record)
MarkBaseAndMemberDestructorsReferenced - Given a record decl, mark all the non-trivial destructors of...
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2297
static bool functionDeclHasDefaultArgument(const FunctionDecl *FD)
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
void CheckOverrideControl(NamedDecl *D)
CheckOverrideControl - Check C++11 override control semantics.
ThreadStorageClassSpecifier
Thread storage-class-specifier.
Definition: Specifiers.h:185
void setImplicitMoveAssignmentIsDeleted()
Set that we attempted to declare an implicit move assignment operator, but overload resolution failed...
Definition: DeclCXX.h:978
Describes the sequence of initializations required to initialize a given object or reference with a s...
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
FormatToken * Current
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:1102
bool isExplicitSpecified() const
Definition: DeclSpec.h:562
static bool CheckConstexprParameterTypes(Sema &SemaRef, const FunctionDecl *FD)
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5169
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:1957
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in it, apply them to D...
void setDefaultArg(Expr *defarg)
Definition: Decl.cpp:2384
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 NULL if there isn't one...
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
BoundNodesTreeBuilder *const Builder
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
static bool isCompoundAssignmentOp(Opcode Opc)
Definition: Expr.h:3005
bool hasUserDeclaredDestructor() const
Determine whether this class has a user-declared destructor.
Definition: DeclCXX.h:1005
void setIvarInitializers(ASTContext &C, CXXCtorInitializer **initializers, unsigned numInitializers)
Definition: DeclObjC.cpp:2055
void diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals, SourceLocation FallbackLoc, SourceLocation ConstQualLoc=SourceLocation(), SourceLocation VolatileQualLoc=SourceLocation(), SourceLocation RestrictQualLoc=SourceLocation(), SourceLocation AtomicQualLoc=SourceLocation())
Definition: SemaType.cpp:2475
A user-defined literal name, e.g., operator "" _i.
Definition: DeclSpec.h:889
void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc)
bool isObjCObjectPointerType() const
Definition: Type.h:5377
bool implicitCopyAssignmentHasConstParam() const
Determine whether an implicit copy assignment operator for this type would have a parameter with a co...
Definition: DeclCXX.h:951
Opcode getOpcode() const
Definition: Expr.h:2918
Look up a friend of a local class.
Definition: Sema.h:2668
bool needsImplicitDefaultConstructor() const
Determine if we need to declare a default constructor for this class.
Definition: DeclCXX.h:827
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:3218
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:29
void CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD)
void setConstexpr(bool IC)
Definition: Decl.h:1795
void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock)
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Definition: Decl.cpp:43
FunctionDecl * FindUsualDeallocationFunction(SourceLocation StartLoc, bool CanProvideSize, DeclarationName Name)
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
Definition: DeclBase.cpp:1231
void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc, SourceLocation ArgLoc)
ActOnParamUnparsedDefaultArgument - We've seen a default argument for a function parameter, but we can't parse it yet because we're inside a class definition.
The parameter type of a method or function.
void setParam(unsigned i, ParmVarDecl *VD)
Definition: TypeLoc.h:1307
bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range)
CheckSpecifiedExceptionType - Check if the given type is valid in an exception specification.
CallingConv getDefaultCallingConvention(bool isVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current target.
CanQualType Char16Ty
Definition: ASTContext.h:887
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult{return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
TypeLoc getElementLoc() const
Definition: TypeLoc.h:1388
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.
static unsigned NumImplicitCopyConstructorsDeclared
The number of implicitly-declared copy constructors for which declarations were built.
Definition: ASTContext.h:2437
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:307
SourceLocation getOverrideLoc() const
Definition: DeclSpec.h:2271
void setUnsupportedFriend(bool Unsupported)
Definition: DeclFriend.h:159
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
Definition: DeclCXX.cpp:2140
Declaration of a class template.
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:115
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:355
const PropertyData & getPropertyData() const
bool isOverrideSpecified() const
Definition: DeclSpec.h:2270
LookupResultKind getResultKind() const
Definition: Sema/Lookup.h:262
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
Definition: CanonicalType.h:70
bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionReturnType - Checks whether the return types are covariant, according to C++ [class.virtual]p5.
static bool checkTrivialSubobjectCall(Sema &S, SourceLocation SubobjLoc, QualType SubType, bool ConstRHS, Sema::CXXSpecialMember CSM, TrivialSubobjectKind Kind, bool Diagnose)
Check whether the special member selected for a given type would be trivial.
unsigned getIndex() const
Retrieve the index of the template parameter.
bool isArrayType() const
Definition: Type.h:5344
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1452
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2134
bool needsImplicitCopyConstructor() const
Determine whether this class needs an implicit copy constructor to be lazily declared.
Definition: DeclCXX.h:858
Expr * getRHS() const
Definition: Expr.h:2923
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1316
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3341
const FunctionDecl * getOperatorDelete() const
Definition: DeclCXX.h:2370
void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI, SmallVectorImpl< ObjCIvarDecl * > &Ivars)
CollectIvarsToConstructOrDestruct - Collect those ivars which require initialization.
ExprResult ExprError()
Definition: Ownership.h:267
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated, or computed.
FriendDecl * CheckFriendTypeDecl(SourceLocation LocStart, SourceLocation FriendLoc, TypeSourceInfo *TSInfo)
Perform semantic analysis of the given friend type declaration.
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.
static void CheckAbstractClassUsage(AbstractUsageInfo &Info, CXXMethodDecl *MD)
Check for invalid uses of an abstract type in a method declaration.
bool isIncompleteArrayType() const
Definition: Type.h:5350
CanQualType IntTy
Definition: ASTContext.h:889
A using declaration.
Definition: Sema.h:5976
bool isRecord() const
Definition: DeclBase.h:1273
bool isFragile() const
The inverse of isNonFragile(): does this runtime follow the set of implied behaviors for a "fragile" ...
Definition: ObjCRuntime.h:95
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:166
TranslationUnitDecl - The top declaration context.
Definition: Decl.h:79
CK_NoOp - A conversion which does not affect the type other than (possibly) adding qualifiers...
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace nested inside this namespace, if any.
Definition: Decl.h:479
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:196
ImplicitExceptionSpecification ComputeDefaultedMoveAssignmentExceptionSpec(CXXMethodDecl *MD)
Determine what sort of exception specification a defaulted move assignment operator of a class will h...
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:922
void CheckConversionDeclarator(Declarator &D, QualType &R, StorageClass &SC)
CheckConversionDeclarator - Called by ActOnDeclarator to check the well-formednes of the conversion f...
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
NamedDecl * getMostRecentDecl()
Definition: Decl.h:332
SourceLocation getRAngleLoc() const
Definition: DeclTemplate.h:132
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 isProvablyNotDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is provably not derived from the type Base.
CXXConstructorDecl * LookupDefaultConstructor(CXXRecordDecl *Class)
Look up the default constructor for the given class.
QualType getElementType() const
Definition: Type.h:2458
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
Expr * getDefaultArgExprForConstructor(const CXXConstructorDecl *CD, unsigned ParmIdx)
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool OdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3)
Definition: SemaExpr.cpp:12583
llvm::DenseMap< CXXRecordDecl *, bool > VTablesUsed
The set of classes whose vtables have been used within this translation unit, and a bit that will be ...
Definition: Sema.h:5258
SourceManager & SourceMgr
Definition: Sema.h:298
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
Definition: DeclSpec.h:1373
SourceLocation getRefQualifierLoc() const
Retrieve the location of the ref-qualifier, if any.
Definition: DeclSpec.h:1347
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:20
void setBaseObjectType(QualType T)
Sets the base object type for this lookup.
Definition: Sema/Lookup.h:361
static bool findTrivialSpecialMember(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM, unsigned Quals, bool ConstRHS, CXXMethodDecl **Selected)
Perform lookup for a special member of the specified kind, and determine whether it is trivial...
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3763
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:52
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3197
bool CheckDestructor(CXXDestructorDecl *Destructor)
CheckDestructor - Checks a fully-formed destructor definition for well-formedness, issuing any diagnostics required.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Sema/Lookup.h:523
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Definition: DeclSpec.h:1987
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:3213
AttributeList * getNext() const
#define true
Definition: stdbool.h:32
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:106
StringRef getKindName() const
Definition: Decl.h:2843
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:384
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 ...
bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM, bool Diagnose=false)
Determine if a special member function should have a deleted definition when it is defaulted...
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:728
ASTContext & Context
Definition: Sema.h:295
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:2682
paths_iterator end()
NamedDecl - This represents a decl with a name.
Definition: Decl.h:145
bool isInvalidType() const
Definition: DeclSpec.h:2200
void DeclareInheritingConstructors(CXXRecordDecl *ClassDecl)
Declare all inheriting constructors for the given class.
virtual void diagnose(Sema &S, SourceLocation Loc, QualType T)=0
void dropAttr()
Definition: DeclBase.h:471
bool isModulePrivateSpecified() const
Definition: DeclSpec.h:695
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:423
CanQualType BoolTy
Definition: ASTContext.h:882
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID...
Represents a C++ namespace alias.
Definition: DeclCXX.h:2649
No keyword precedes the qualified type name.
Definition: Type.h:4204
SourceRange getSourceRange() const LLVM_READONLY
Retrieves the source range that contains the entire base specifier.
Definition: DeclCXX.h:201
void getFinalOverriders(CXXFinalOverriderMap &FinaOverriders) const
Retrieve the final overriders for each virtual member function in the class hierarchy where this clas...
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5148
FullExprArg MakeFullDiscardedValueExpr(Expr *Arg)
Definition: Sema.h:3255
Represents C++ using-directive.
Definition: DeclCXX.h:2546
SmallVector< std::pair< const CXXMethodDecl *, const CXXMethodDecl * >, 2 > DelayedExceptionSpecChecks
All the overriding functions seen during a class definition that had their exception spec checks dela...
Definition: Sema.h:507
void DiagnoseAbstractType(const CXXRecordDecl *RD)
static Expr * CastForMoving(Sema &SemaRef, Expr *E, QualType T=QualType())
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:642
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
Definition: DeclCXX.h:1148
Describes an entity that is being initialized.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
virtual void ReadUsedVTables(SmallVectorImpl< ExternalVTableUse > &VTables)
Read the set of used vtables known to the external Sema source.
The global specifier '::'. There is no stored value.
The noexcept specifier is dependent.
Definition: Type.h:3214
The type of an arbitrary declaration.
Definition: Sema.h:5958
NamespaceDecl * getStdNamespace() const
bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
The object is actually the complete object.
void setType(QualType newType)
Definition: Decl.h:531
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:464
Wrapper for source info for pointers.
Definition: TypeLoc.h:1134
ParsedAttributes - A collection of parsed attributes.
SourceLocation ColonLoc
Location of ':'.
Definition: OpenMPClause.h:266
void WillReplaceSpecifier(bool ForceReplacement)
Wrapper for source info for block pointers.
Definition: TypeLoc.h:1147
void setDeletedAsWritten(bool D=true)
Definition: Decl.h:1822
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).
void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation)
SetIvarInitializers - This routine builds initialization ASTs for the Objective-C implementation whos...
No in-class initializer.
Definition: Specifiers.h:222
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
Definition: SemaDecl.cpp:4426
SmallVector< std::pair< CXXMethodDecl *, const FunctionProtoType * >, 2 > DelayedDefaultedMemberExceptionSpecs
All the members seen during a class definition which were both explicitly defaulted and had explicitl...
Definition: Sema.h:517
ArrayRef< QualType > exceptions() const
Definition: Type.h:3290
bool isBeingDefined() const
isBeingDefined - Return true if this decl is currently being defined.
Definition: Decl.h:2799
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2480
base_class_range vbases()
Definition: DeclCXX.h:730
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3087
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
enum clang::UnqualifiedId::IdKind Kind
Declaration of a template function.
Definition: DeclTemplate.h:830
void clear()
Clears out any current state.
Definition: Sema/Lookup.h:495
std::list< CXXBasePath >::iterator paths_iterator
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:4328
MSPropertyDecl * HandleMSProperty(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS, AttributeList *MSPropertyAttr)
HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
bool SetDelegatingInitializer(CXXConstructorDecl *Constructor, CXXCtorInitializer *Initializer)
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:1127
void DiagnoseAbsenceOfOverrideControl(NamedDecl *D)
DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was not used in the declaration of ...
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
Definition: DeclSpec.h:1272
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1730
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:451
Attr - This represents one attribute.
Definition: Attr.h:44
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:741
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:2766
TypeSourceInfo * GetTypeForDeclarator(Declarator &D, Scope *S)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
Definition: SemaType.cpp:4338
bool hasUserDeclaredConstructor() const
Determine whether this class has any user-declared constructors.
Definition: DeclCXX.h:839
const RecordDecl * getParent() const
getParent - Returns the parent of this field declaration, which is the struct in which this method is...
Definition: Decl.h:2371
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1071
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2433
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1712
Decl * ActOnDeclarator(Scope *S, Declarator &D)
Definition: SemaDecl.cpp:4653
AttributeList - Represents a syntactic attribute.
Definition: AttributeList.h:72
Decl * ActOnConversionDeclarator(CXXConversionDecl *Conversion)
ActOnConversionDeclarator - Called by ActOnDeclarator to complete the declaration of the given C++ co...
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5116
bool isMutable() const
isMutable - Determines whether this field is mutable (C++ only).
Definition: Decl.h:2274
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope...
Definition: SemaDecl.cpp:1290
llvm::DenseMap< ParmVarDecl *, SourceLocation > UnparsedDefaultArgLocs
Definition: Sema.h:938
bool hasInClassInitializer() const
hasInClassInitializer - Determine whether this member has a C++11 in-class initializer.
Definition: Decl.h:2324
bool isPointerType() const
Definition: Type.h:5305
static unsigned NumImplicitDestructors
The number of implicitly-declared destructors.
Definition: ASTContext.h:2461
static bool isVisible(Sema &SemaRef, NamedDecl *D)
Determine whether the given declaration is visible to the program.
Definition: Sema/Lookup.h:290
unsigned getNumTemplateParameterLists() const
Definition: Decl.h:645
NamedDecl * ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams)
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...
unsigned ActOnReenterTemplateScope(Scope *S, Decl *Template)
static void DiagnoseNamespaceInlineMismatch(Sema &S, SourceLocation KeywordLoc, SourceLocation Loc, IdentifierInfo *II, bool *IsInline, NamespaceDecl *PrevNS)
Diagnose a mismatch in 'inline' qualifiers when a namespace is reopened.
A RAII object to temporarily push a declaration context.
Definition: Sema.h:601
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any...
Definition: Decl.cpp:3009
The subobject is a non-static data member.
SourceLocation getTemplateLoc() const
Definition: DeclTemplate.h:130