clang  10.0.0git
SemaDeclCXX.cpp
Go to the documentation of this file.
1 //===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements semantic analysis for C++ declarations.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/AST/ASTConsumer.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/ASTLambda.h"
18 #include "clang/AST/CharUnits.h"
21 #include "clang/AST/ExprCXX.h"
22 #include "clang/AST/RecordLayout.h"
24 #include "clang/AST/StmtVisitor.h"
25 #include "clang/AST/TypeLoc.h"
26 #include "clang/AST/TypeOrdering.h"
29 #include "clang/Basic/TargetInfo.h"
31 #include "clang/Lex/Preprocessor.h"
33 #include "clang/Sema/DeclSpec.h"
35 #include "clang/Sema/Lookup.h"
37 #include "clang/Sema/Scope.h"
38 #include "clang/Sema/ScopeInfo.h"
40 #include "clang/Sema/Template.h"
41 #include "llvm/ADT/STLExtras.h"
42 #include "llvm/ADT/SmallString.h"
43 #include "llvm/ADT/StringExtras.h"
44 #include <map>
45 #include <set>
46 
47 using namespace clang;
48 
49 //===----------------------------------------------------------------------===//
50 // CheckDefaultArgumentVisitor
51 //===----------------------------------------------------------------------===//
52 
53 namespace {
54  /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
55  /// the default argument of a parameter to determine whether it
56  /// contains any ill-formed subexpressions. For example, this will
57  /// diagnose the use of local variables or parameters within the
58  /// default argument expression.
59  class CheckDefaultArgumentVisitor
60  : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
61  Expr *DefaultArg;
62  Sema *S;
63 
64  public:
65  CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
66  : DefaultArg(defarg), S(s) {}
67 
68  bool VisitExpr(Expr *Node);
69  bool VisitDeclRefExpr(DeclRefExpr *DRE);
70  bool VisitCXXThisExpr(CXXThisExpr *ThisE);
71  bool VisitLambdaExpr(LambdaExpr *Lambda);
72  bool VisitPseudoObjectExpr(PseudoObjectExpr *POE);
73  };
74 
75  /// VisitExpr - Visit all of the children of this expression.
76  bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
77  bool IsInvalid = false;
78  for (Stmt *SubStmt : Node->children())
79  IsInvalid |= Visit(SubStmt);
80  return IsInvalid;
81  }
82 
83  /// VisitDeclRefExpr - Visit a reference to a declaration, to
84  /// determine whether this declaration can be used in the default
85  /// argument expression.
86  bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
87  NamedDecl *Decl = DRE->getDecl();
88  if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
89  // C++ [dcl.fct.default]p9
90  // Default arguments are evaluated each time the function is
91  // called. The order of evaluation of function arguments is
92  // unspecified. Consequently, parameters of a function shall not
93  // be used in default argument expressions, even if they are not
94  // evaluated. Parameters of a function declared before a default
95  // argument expression are in scope and can hide namespace and
96  // class member names.
97  return S->Diag(DRE->getBeginLoc(),
98  diag::err_param_default_argument_references_param)
99  << Param->getDeclName() << DefaultArg->getSourceRange();
100  } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
101  // C++ [dcl.fct.default]p7
102  // Local variables shall not be used in default argument
103  // expressions.
104  if (VDecl->isLocalVarDecl())
105  return S->Diag(DRE->getBeginLoc(),
106  diag::err_param_default_argument_references_local)
107  << VDecl->getDeclName() << DefaultArg->getSourceRange();
108  }
109 
110  return false;
111  }
112 
113  /// VisitCXXThisExpr - Visit a C++ "this" expression.
114  bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
115  // C++ [dcl.fct.default]p8:
116  // The keyword this shall not be used in a default argument of a
117  // member function.
118  return S->Diag(ThisE->getBeginLoc(),
119  diag::err_param_default_argument_references_this)
120  << ThisE->getSourceRange();
121  }
122 
123  bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(PseudoObjectExpr *POE) {
124  bool Invalid = false;
126  i = POE->semantics_begin(), e = POE->semantics_end(); i != e; ++i) {
127  Expr *E = *i;
128 
129  // Look through bindings.
130  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
131  E = OVE->getSourceExpr();
132  assert(E && "pseudo-object binding without source expression?");
133  }
134 
135  Invalid |= Visit(E);
136  }
137  return Invalid;
138  }
139 
140  bool CheckDefaultArgumentVisitor::VisitLambdaExpr(LambdaExpr *Lambda) {
141  // C++11 [expr.lambda.prim]p13:
142  // A lambda-expression appearing in a default argument shall not
143  // implicitly or explicitly capture any entity.
144  if (Lambda->capture_begin() == Lambda->capture_end())
145  return false;
146 
147  return S->Diag(Lambda->getBeginLoc(), diag::err_lambda_capture_default_arg);
148  }
149 }
150 
151 void
153  const CXXMethodDecl *Method) {
154  // If we have an MSAny spec already, don't bother.
155  if (!Method || ComputedEST == EST_MSAny)
156  return;
157 
158  const FunctionProtoType *Proto
159  = Method->getType()->getAs<FunctionProtoType>();
160  Proto = Self->ResolveExceptionSpec(CallLoc, Proto);
161  if (!Proto)
162  return;
163 
165 
166  // If we have a throw-all spec at this point, ignore the function.
167  if (ComputedEST == EST_None)
168  return;
169 
170  if (EST == EST_None && Method->hasAttr<NoThrowAttr>())
171  EST = EST_BasicNoexcept;
172 
173  switch (EST) {
174  case EST_Unparsed:
175  case EST_Uninstantiated:
176  case EST_Unevaluated:
177  llvm_unreachable("should not see unresolved exception specs here");
178 
179  // If this function can throw any exceptions, make a note of that.
180  case EST_MSAny:
181  case EST_None:
182  // FIXME: Whichever we see last of MSAny and None determines our result.
183  // We should make a consistent, order-independent choice here.
184  ClearExceptions();
185  ComputedEST = EST;
186  return;
187  case EST_NoexceptFalse:
188  ClearExceptions();
189  ComputedEST = EST_None;
190  return;
191  // FIXME: If the call to this decl is using any of its default arguments, we
192  // need to search them for potentially-throwing calls.
193  // If this function has a basic noexcept, it doesn't affect the outcome.
194  case EST_BasicNoexcept:
195  case EST_NoexceptTrue:
196  case EST_NoThrow:
197  return;
198  // If we're still at noexcept(true) and there's a throw() callee,
199  // change to that specification.
200  case EST_DynamicNone:
201  if (ComputedEST == EST_BasicNoexcept)
202  ComputedEST = EST_DynamicNone;
203  return;
205  llvm_unreachable(
206  "should not generate implicit declarations for dependent cases");
207  case EST_Dynamic:
208  break;
209  }
210  assert(EST == EST_Dynamic && "EST case not considered earlier.");
211  assert(ComputedEST != EST_None &&
212  "Shouldn't collect exceptions when throw-all is guaranteed.");
213  ComputedEST = EST_Dynamic;
214  // Record the exceptions in this function's exception specification.
215  for (const auto &E : Proto->exceptions())
216  if (ExceptionsSeen.insert(Self->Context.getCanonicalType(E)).second)
217  Exceptions.push_back(E);
218 }
219 
221  if (!S || ComputedEST == EST_MSAny)
222  return;
223 
224  // FIXME:
225  //
226  // C++0x [except.spec]p14:
227  // [An] implicit exception-specification specifies the type-id T if and
228  // only if T is allowed by the exception-specification of a function directly
229  // invoked by f's implicit definition; f shall allow all exceptions if any
230  // function it directly invokes allows all exceptions, and f shall allow no
231  // exceptions if every function it directly invokes allows no exceptions.
232  //
233  // Note in particular that if an implicit exception-specification is generated
234  // for a function containing a throw-expression, that specification can still
235  // be noexcept(true).
236  //
237  // Note also that 'directly invoked' is not defined in the standard, and there
238  // is no indication that we should only consider potentially-evaluated calls.
239  //
240  // Ultimately we should implement the intent of the standard: the exception
241  // specification should be the set of exceptions which can be thrown by the
242  // implicit definition. For now, we assume that any non-nothrow expression can
243  // throw any exception.
244 
245  if (Self->canThrow(S))
246  ComputedEST = EST_None;
247 }
248 
249 bool
251  SourceLocation EqualLoc) {
252  if (RequireCompleteType(Param->getLocation(), Param->getType(),
253  diag::err_typecheck_decl_incomplete_type)) {
254  Param->setInvalidDecl();
255  return true;
256  }
257 
258  // C++ [dcl.fct.default]p5
259  // A default argument expression is implicitly converted (clause
260  // 4) to the parameter type. The default argument expression has
261  // the same semantic constraints as the initializer expression in
262  // a declaration of a variable of the parameter type, using the
263  // copy-initialization semantics (8.5).
265  Param);
267  EqualLoc);
268  InitializationSequence InitSeq(*this, Entity, Kind, Arg);
269  ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg);
270  if (Result.isInvalid())
271  return true;
272  Arg = Result.getAs<Expr>();
273 
274  CheckCompletedExpr(Arg, EqualLoc);
275  Arg = MaybeCreateExprWithCleanups(Arg);
276 
277  // Okay: add the default argument to the parameter
278  Param->setDefaultArg(Arg);
279 
280  // We have already instantiated this parameter; provide each of the
281  // instantiations with the uninstantiated default argument.
282  UnparsedDefaultArgInstantiationsMap::iterator InstPos
283  = UnparsedDefaultArgInstantiations.find(Param);
284  if (InstPos != UnparsedDefaultArgInstantiations.end()) {
285  for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
286  InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
287 
288  // We're done tracking this parameter's instantiations.
289  UnparsedDefaultArgInstantiations.erase(InstPos);
290  }
291 
292  return false;
293 }
294 
295 /// ActOnParamDefaultArgument - Check whether the default argument
296 /// provided for a function parameter is well-formed. If so, attach it
297 /// to the parameter declaration.
298 void
300  Expr *DefaultArg) {
301  if (!param || !DefaultArg)
302  return;
303 
304  ParmVarDecl *Param = cast<ParmVarDecl>(param);
305  UnparsedDefaultArgLocs.erase(Param);
306 
307  // Default arguments are only permitted in C++
308  if (!getLangOpts().CPlusPlus) {
309  Diag(EqualLoc, diag::err_param_default_argument)
310  << DefaultArg->getSourceRange();
311  Param->setInvalidDecl();
312  return;
313  }
314 
315  // Check for unexpanded parameter packs.
316  if (DiagnoseUnexpandedParameterPack(DefaultArg, UPPC_DefaultArgument)) {
317  Param->setInvalidDecl();
318  return;
319  }
320 
321  // C++11 [dcl.fct.default]p3
322  // A default argument expression [...] shall not be specified for a
323  // parameter pack.
324  if (Param->isParameterPack()) {
325  Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
326  << DefaultArg->getSourceRange();
327  return;
328  }
329 
330  // Check that the default argument is well-formed
331  CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg, this);
332  if (DefaultArgChecker.Visit(DefaultArg)) {
333  Param->setInvalidDecl();
334  return;
335  }
336 
337  SetParamDefaultArgument(Param, DefaultArg, EqualLoc);
338 }
339 
340 /// ActOnParamUnparsedDefaultArgument - We've seen a default
341 /// argument for a function parameter, but we can't parse it yet
342 /// because we're inside a class definition. Note that this default
343 /// argument will be parsed later.
345  SourceLocation EqualLoc,
346  SourceLocation ArgLoc) {
347  if (!param)
348  return;
349 
350  ParmVarDecl *Param = cast<ParmVarDecl>(param);
351  Param->setUnparsedDefaultArg();
352  UnparsedDefaultArgLocs[Param] = ArgLoc;
353 }
354 
355 /// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
356 /// the default argument for the parameter param failed.
358  SourceLocation EqualLoc) {
359  if (!param)
360  return;
361 
362  ParmVarDecl *Param = cast<ParmVarDecl>(param);
363  Param->setInvalidDecl();
364  UnparsedDefaultArgLocs.erase(Param);
365  Param->setDefaultArg(new(Context)
366  OpaqueValueExpr(EqualLoc,
367  Param->getType().getNonReferenceType(),
368  VK_RValue));
369 }
370 
371 /// CheckExtraCXXDefaultArguments - Check for any extra default
372 /// arguments in the declarator, which is not a function declaration
373 /// or definition and therefore is not permitted to have default
374 /// arguments. This routine should be invoked for every declarator
375 /// that is not a function declaration or definition.
377  // C++ [dcl.fct.default]p3
378  // A default argument expression shall be specified only in the
379  // parameter-declaration-clause of a function declaration or in a
380  // template-parameter (14.1). It shall not be specified for a
381  // parameter pack. If it is specified in a
382  // parameter-declaration-clause, it shall not occur within a
383  // declarator or abstract-declarator of a parameter-declaration.
384  bool MightBeFunction = D.isFunctionDeclarationContext();
385  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
386  DeclaratorChunk &chunk = D.getTypeObject(i);
387  if (chunk.Kind == DeclaratorChunk::Function) {
388  if (MightBeFunction) {
389  // This is a function declaration. It can have default arguments, but
390  // keep looking in case its return type is a function type with default
391  // arguments.
392  MightBeFunction = false;
393  continue;
394  }
395  for (unsigned argIdx = 0, e = chunk.Fun.NumParams; argIdx != e;
396  ++argIdx) {
397  ParmVarDecl *Param = cast<ParmVarDecl>(chunk.Fun.Params[argIdx].Param);
398  if (Param->hasUnparsedDefaultArg()) {
399  std::unique_ptr<CachedTokens> Toks =
400  std::move(chunk.Fun.Params[argIdx].DefaultArgTokens);
401  SourceRange SR;
402  if (Toks->size() > 1)
403  SR = SourceRange((*Toks)[1].getLocation(),
404  Toks->back().getLocation());
405  else
406  SR = UnparsedDefaultArgLocs[Param];
407  Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
408  << SR;
409  } else if (Param->getDefaultArg()) {
410  Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
411  << Param->getDefaultArg()->getSourceRange();
412  Param->setDefaultArg(nullptr);
413  }
414  }
415  } else if (chunk.Kind != DeclaratorChunk::Paren) {
416  MightBeFunction = false;
417  }
418  }
419 }
420 
422  for (unsigned NumParams = FD->getNumParams(); NumParams > 0; --NumParams) {
423  const ParmVarDecl *PVD = FD->getParamDecl(NumParams-1);
424  if (!PVD->hasDefaultArg())
425  return false;
426  if (!PVD->hasInheritedDefaultArg())
427  return true;
428  }
429  return false;
430 }
431 
432 /// MergeCXXFunctionDecl - Merge two declarations of the same C++
433 /// function, once we already know that they have the same
434 /// type. Subroutine of MergeFunctionDecl. Returns true if there was an
435 /// error, false otherwise.
437  Scope *S) {
438  bool Invalid = false;
439 
440  // The declaration context corresponding to the scope is the semantic
441  // parent, unless this is a local function declaration, in which case
442  // it is that surrounding function.
443  DeclContext *ScopeDC = New->isLocalExternDecl()
444  ? New->getLexicalDeclContext()
445  : New->getDeclContext();
446 
447  // Find the previous declaration for the purpose of default arguments.
448  FunctionDecl *PrevForDefaultArgs = Old;
449  for (/**/; PrevForDefaultArgs;
450  // Don't bother looking back past the latest decl if this is a local
451  // extern declaration; nothing else could work.
452  PrevForDefaultArgs = New->isLocalExternDecl()
453  ? nullptr
454  : PrevForDefaultArgs->getPreviousDecl()) {
455  // Ignore hidden declarations.
456  if (!LookupResult::isVisible(*this, PrevForDefaultArgs))
457  continue;
458 
459  if (S && !isDeclInScope(PrevForDefaultArgs, ScopeDC, S) &&
460  !New->isCXXClassMember()) {
461  // Ignore default arguments of old decl if they are not in
462  // the same scope and this is not an out-of-line definition of
463  // a member function.
464  continue;
465  }
466 
467  if (PrevForDefaultArgs->isLocalExternDecl() != New->isLocalExternDecl()) {
468  // If only one of these is a local function declaration, then they are
469  // declared in different scopes, even though isDeclInScope may think
470  // they're in the same scope. (If both are local, the scope check is
471  // sufficient, and if neither is local, then they are in the same scope.)
472  continue;
473  }
474 
475  // We found the right previous declaration.
476  break;
477  }
478 
479  // C++ [dcl.fct.default]p4:
480  // For non-template functions, default arguments can be added in
481  // later declarations of a function in the same
482  // scope. Declarations in different scopes have completely
483  // distinct sets of default arguments. That is, declarations in
484  // inner scopes do not acquire default arguments from
485  // declarations in outer scopes, and vice versa. In a given
486  // function declaration, all parameters subsequent to a
487  // parameter with a default argument shall have default
488  // arguments supplied in this or previous declarations. A
489  // default argument shall not be redefined by a later
490  // declaration (not even to the same value).
491  //
492  // C++ [dcl.fct.default]p6:
493  // Except for member functions of class templates, the default arguments
494  // in a member function definition that appears outside of the class
495  // definition are added to the set of default arguments provided by the
496  // member function declaration in the class definition.
497  for (unsigned p = 0, NumParams = PrevForDefaultArgs
498  ? PrevForDefaultArgs->getNumParams()
499  : 0;
500  p < NumParams; ++p) {
501  ParmVarDecl *OldParam = PrevForDefaultArgs->getParamDecl(p);
502  ParmVarDecl *NewParam = New->getParamDecl(p);
503 
504  bool OldParamHasDfl = OldParam ? OldParam->hasDefaultArg() : false;
505  bool NewParamHasDfl = NewParam->hasDefaultArg();
506 
507  if (OldParamHasDfl && NewParamHasDfl) {
508  unsigned DiagDefaultParamID =
509  diag::err_param_default_argument_redefinition;
510 
511  // MSVC accepts that default parameters be redefined for member functions
512  // of template class. The new default parameter's value is ignored.
513  Invalid = true;
514  if (getLangOpts().MicrosoftExt) {
515  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(New);
516  if (MD && MD->getParent()->getDescribedClassTemplate()) {
517  // Merge the old default argument into the new parameter.
518  NewParam->setHasInheritedDefaultArg();
519  if (OldParam->hasUninstantiatedDefaultArg())
520  NewParam->setUninstantiatedDefaultArg(
521  OldParam->getUninstantiatedDefaultArg());
522  else
523  NewParam->setDefaultArg(OldParam->getInit());
524  DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
525  Invalid = false;
526  }
527  }
528 
529  // FIXME: If we knew where the '=' was, we could easily provide a fix-it
530  // hint here. Alternatively, we could walk the type-source information
531  // for NewParam to find the last source location in the type... but it
532  // isn't worth the effort right now. This is the kind of test case that
533  // is hard to get right:
534  // int f(int);
535  // void g(int (*fp)(int) = f);
536  // void g(int (*fp)(int) = &f);
537  Diag(NewParam->getLocation(), DiagDefaultParamID)
538  << NewParam->getDefaultArgRange();
539 
540  // Look for the function declaration where the default argument was
541  // actually written, which may be a declaration prior to Old.
542  for (auto Older = PrevForDefaultArgs;
543  OldParam->hasInheritedDefaultArg(); /**/) {
544  Older = Older->getPreviousDecl();
545  OldParam = Older->getParamDecl(p);
546  }
547 
548  Diag(OldParam->getLocation(), diag::note_previous_definition)
549  << OldParam->getDefaultArgRange();
550  } else if (OldParamHasDfl) {
551  // Merge the old default argument into the new parameter unless the new
552  // function is a friend declaration in a template class. In the latter
553  // case the default arguments will be inherited when the friend
554  // declaration will be instantiated.
555  if (New->getFriendObjectKind() == Decl::FOK_None ||
557  // It's important to use getInit() here; getDefaultArg()
558  // strips off any top-level ExprWithCleanups.
559  NewParam->setHasInheritedDefaultArg();
560  if (OldParam->hasUnparsedDefaultArg())
561  NewParam->setUnparsedDefaultArg();
562  else if (OldParam->hasUninstantiatedDefaultArg())
563  NewParam->setUninstantiatedDefaultArg(
564  OldParam->getUninstantiatedDefaultArg());
565  else
566  NewParam->setDefaultArg(OldParam->getInit());
567  }
568  } else if (NewParamHasDfl) {
569  if (New->getDescribedFunctionTemplate()) {
570  // Paragraph 4, quoted above, only applies to non-template functions.
571  Diag(NewParam->getLocation(),
572  diag::err_param_default_argument_template_redecl)
573  << NewParam->getDefaultArgRange();
574  Diag(PrevForDefaultArgs->getLocation(),
575  diag::note_template_prev_declaration)
576  << false;
577  } else if (New->getTemplateSpecializationKind()
580  // C++ [temp.expr.spec]p21:
581  // Default function arguments shall not be specified in a declaration
582  // or a definition for one of the following explicit specializations:
583  // - the explicit specialization of a function template;
584  // - the explicit specialization of a member function template;
585  // - the explicit specialization of a member function of a class
586  // template where the class template specialization to which the
587  // member function specialization belongs is implicitly
588  // instantiated.
589  Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
591  << New->getDeclName()
592  << NewParam->getDefaultArgRange();
593  } else if (New->getDeclContext()->isDependentContext()) {
594  // C++ [dcl.fct.default]p6 (DR217):
595  // Default arguments for a member function of a class template shall
596  // be specified on the initial declaration of the member function
597  // within the class template.
598  //
599  // Reading the tea leaves a bit in DR217 and its reference to DR205
600  // leads me to the conclusion that one cannot add default function
601  // arguments for an out-of-line definition of a member function of a
602  // dependent type.
603  int WhichKind = 2;
604  if (CXXRecordDecl *Record
605  = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
606  if (Record->getDescribedClassTemplate())
607  WhichKind = 0;
608  else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
609  WhichKind = 1;
610  else
611  WhichKind = 2;
612  }
613 
614  Diag(NewParam->getLocation(),
615  diag::err_param_default_argument_member_template_redecl)
616  << WhichKind
617  << NewParam->getDefaultArgRange();
618  }
619  }
620  }
621 
622  // DR1344: If a default argument is added outside a class definition and that
623  // default argument makes the function a special member function, the program
624  // is ill-formed. This can only happen for constructors.
625  if (isa<CXXConstructorDecl>(New) &&
627  CXXSpecialMember NewSM = getSpecialMember(cast<CXXMethodDecl>(New)),
628  OldSM = getSpecialMember(cast<CXXMethodDecl>(Old));
629  if (NewSM != OldSM) {
630  ParmVarDecl *NewParam = New->getParamDecl(New->getMinRequiredArguments());
631  assert(NewParam->hasDefaultArg());
632  Diag(NewParam->getLocation(), diag::err_default_arg_makes_ctor_special)
633  << NewParam->getDefaultArgRange() << NewSM;
634  Diag(Old->getLocation(), diag::note_previous_declaration);
635  }
636  }
637 
638  const FunctionDecl *Def;
639  // C++11 [dcl.constexpr]p1: If any declaration of a function or function
640  // template has a constexpr specifier then all its declarations shall
641  // contain the constexpr specifier.
642  if (New->getConstexprKind() != Old->getConstexprKind()) {
643  Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
644  << New << New->getConstexprKind() << Old->getConstexprKind();
645  Diag(Old->getLocation(), diag::note_previous_declaration);
646  Invalid = true;
647  } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
648  Old->isDefined(Def) &&
649  // If a friend function is inlined but does not have 'inline'
650  // specifier, it is a definition. Do not report attribute conflict
651  // in this case, redefinition will be diagnosed later.
652  (New->isInlineSpecified() ||
653  New->getFriendObjectKind() == Decl::FOK_None)) {
654  // C++11 [dcl.fcn.spec]p4:
655  // If the definition of a function appears in a translation unit before its
656  // first declaration as inline, the program is ill-formed.
657  Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
658  Diag(Def->getLocation(), diag::note_previous_definition);
659  Invalid = true;
660  }
661 
662  // C++17 [temp.deduct.guide]p3:
663  // Two deduction guide declarations in the same translation unit
664  // for the same class template shall not have equivalent
665  // parameter-declaration-clauses.
666  if (isa<CXXDeductionGuideDecl>(New) &&
668  Diag(New->getLocation(), diag::err_deduction_guide_redeclared);
669  Diag(Old->getLocation(), diag::note_previous_declaration);
670  }
671 
672  // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
673  // argument expression, that declaration shall be a definition and shall be
674  // the only declaration of the function or function template in the
675  // translation unit.
678  Diag(New->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
679  Diag(Old->getLocation(), diag::note_previous_declaration);
680  Invalid = true;
681  }
682 
683  return Invalid;
684 }
685 
686 NamedDecl *
688  MultiTemplateParamsArg TemplateParamLists) {
689  assert(D.isDecompositionDeclarator());
691 
692  // The syntax only allows a decomposition declarator as a simple-declaration,
693  // a for-range-declaration, or a condition in Clang, but we parse it in more
694  // cases than that.
696  Diag(Decomp.getLSquareLoc(), diag::err_decomp_decl_context)
697  << Decomp.getSourceRange();
698  return nullptr;
699  }
700 
701  if (!TemplateParamLists.empty()) {
702  // FIXME: There's no rule against this, but there are also no rules that
703  // would actually make it usable, so we reject it for now.
704  Diag(TemplateParamLists.front()->getTemplateLoc(),
705  diag::err_decomp_decl_template);
706  return nullptr;
707  }
708 
709  Diag(Decomp.getLSquareLoc(),
710  !getLangOpts().CPlusPlus17
711  ? diag::ext_decomp_decl
713  ? diag::ext_decomp_decl_cond
714  : diag::warn_cxx14_compat_decomp_decl)
715  << Decomp.getSourceRange();
716 
717  // The semantic context is always just the current context.
718  DeclContext *const DC = CurContext;
719 
720  // C++17 [dcl.dcl]/8:
721  // The decl-specifier-seq shall contain only the type-specifier auto
722  // and cv-qualifiers.
723  // C++2a [dcl.dcl]/8:
724  // If decl-specifier-seq contains any decl-specifier other than static,
725  // thread_local, auto, or cv-qualifiers, the program is ill-formed.
726  auto &DS = D.getDeclSpec();
727  {
728  SmallVector<StringRef, 8> BadSpecifiers;
729  SmallVector<SourceLocation, 8> BadSpecifierLocs;
730  SmallVector<StringRef, 8> CPlusPlus20Specifiers;
731  SmallVector<SourceLocation, 8> CPlusPlus20SpecifierLocs;
732  if (auto SCS = DS.getStorageClassSpec()) {
733  if (SCS == DeclSpec::SCS_static) {
734  CPlusPlus20Specifiers.push_back(DeclSpec::getSpecifierName(SCS));
735  CPlusPlus20SpecifierLocs.push_back(DS.getStorageClassSpecLoc());
736  } else {
737  BadSpecifiers.push_back(DeclSpec::getSpecifierName(SCS));
738  BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());
739  }
740  }
741  if (auto TSCS = DS.getThreadStorageClassSpec()) {
742  CPlusPlus20Specifiers.push_back(DeclSpec::getSpecifierName(TSCS));
743  CPlusPlus20SpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());
744  }
745  if (DS.hasConstexprSpecifier()) {
746  BadSpecifiers.push_back(
747  DeclSpec::getSpecifierName(DS.getConstexprSpecifier()));
748  BadSpecifierLocs.push_back(DS.getConstexprSpecLoc());
749  }
750  if (DS.isInlineSpecified()) {
751  BadSpecifiers.push_back("inline");
752  BadSpecifierLocs.push_back(DS.getInlineSpecLoc());
753  }
754  if (!BadSpecifiers.empty()) {
755  auto &&Err = Diag(BadSpecifierLocs.front(), diag::err_decomp_decl_spec);
756  Err << (int)BadSpecifiers.size()
757  << llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(), " ");
758  // Don't add FixItHints to remove the specifiers; we do still respect
759  // them when building the underlying variable.
760  for (auto Loc : BadSpecifierLocs)
761  Err << SourceRange(Loc, Loc);
762  } else if (!CPlusPlus20Specifiers.empty()) {
763  auto &&Warn = Diag(CPlusPlus20SpecifierLocs.front(),
764  getLangOpts().CPlusPlus2a
765  ? diag::warn_cxx17_compat_decomp_decl_spec
766  : diag::ext_decomp_decl_spec);
767  Warn << (int)CPlusPlus20Specifiers.size()
768  << llvm::join(CPlusPlus20Specifiers.begin(),
769  CPlusPlus20Specifiers.end(), " ");
770  for (auto Loc : CPlusPlus20SpecifierLocs)
771  Warn << SourceRange(Loc, Loc);
772  }
773  // We can't recover from it being declared as a typedef.
774  if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
775  return nullptr;
776  }
777 
778  // C++2a [dcl.struct.bind]p1:
779  // A cv that includes volatile is deprecated
780  if ((DS.getTypeQualifiers() & DeclSpec::TQ_volatile) &&
781  getLangOpts().CPlusPlus2a)
782  Diag(DS.getVolatileSpecLoc(),
783  diag::warn_deprecated_volatile_structured_binding);
784 
785  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
786  QualType R = TInfo->getType();
787 
788  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
789  UPPC_DeclarationType))
790  D.setInvalidType();
791 
792  // The syntax only allows a single ref-qualifier prior to the decomposition
793  // declarator. No other declarator chunks are permitted. Also check the type
794  // specifier here.
795  if (DS.getTypeSpecType() != DeclSpec::TST_auto ||
796  D.hasGroupingParens() || D.getNumTypeObjects() > 1 ||
797  (D.getNumTypeObjects() == 1 &&
799  Diag(Decomp.getLSquareLoc(),
800  (D.hasGroupingParens() ||
801  (D.getNumTypeObjects() &&
803  ? diag::err_decomp_decl_parens
804  : diag::err_decomp_decl_type)
805  << R;
806 
807  // In most cases, there's no actual problem with an explicitly-specified
808  // type, but a function type won't work here, and ActOnVariableDeclarator
809  // shouldn't be called for such a type.
810  if (R->isFunctionType())
811  D.setInvalidType();
812  }
813 
814  // Build the BindingDecls.
816 
817  // Build the BindingDecls.
818  for (auto &B : D.getDecompositionDeclarator().bindings()) {
819  // Check for name conflicts.
820  DeclarationNameInfo NameInfo(B.Name, B.NameLoc);
821  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
822  ForVisibleRedeclaration);
823  LookupName(Previous, S,
824  /*CreateBuiltins*/DC->getRedeclContext()->isTranslationUnit());
825 
826  // It's not permitted to shadow a template parameter name.
827  if (Previous.isSingleResult() &&
828  Previous.getFoundDecl()->isTemplateParameter()) {
829  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
830  Previous.getFoundDecl());
831  Previous.clear();
832  }
833 
834  bool ConsiderLinkage = DC->isFunctionOrMethod() &&
835  DS.getStorageClassSpec() == DeclSpec::SCS_extern;
836  FilterLookupForScope(Previous, DC, S, ConsiderLinkage,
837  /*AllowInlineNamespace*/false);
838  if (!Previous.empty()) {
839  auto *Old = Previous.getRepresentativeDecl();
840  Diag(B.NameLoc, diag::err_redefinition) << B.Name;
841  Diag(Old->getLocation(), diag::note_previous_definition);
842  }
843 
844  auto *BD = BindingDecl::Create(Context, DC, B.NameLoc, B.Name);
845  PushOnScopeChains(BD, S, true);
846  Bindings.push_back(BD);
847  ParsingInitForAutoVars.insert(BD);
848  }
849 
850  // There are no prior lookup results for the variable itself, because it
851  // is unnamed.
852  DeclarationNameInfo NameInfo((IdentifierInfo *)nullptr,
853  Decomp.getLSquareLoc());
854  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
855  ForVisibleRedeclaration);
856 
857  // Build the variable that holds the non-decomposed object.
858  bool AddToScope = true;
859  NamedDecl *New =
860  ActOnVariableDeclarator(S, D, DC, TInfo, Previous,
861  MultiTemplateParamsArg(), AddToScope, Bindings);
862  if (AddToScope) {
863  S->AddDecl(New);
864  CurContext->addHiddenDecl(New);
865  }
866 
867  if (isInOpenMPDeclareTargetContext())
868  checkDeclIsAllowedInOpenMPTarget(nullptr, New);
869 
870  return New;
871 }
872 
874  Sema &S, ArrayRef<BindingDecl *> Bindings, ValueDecl *Src,
875  QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType,
876  llvm::function_ref<ExprResult(SourceLocation, Expr *, unsigned)> GetInit) {
877  if ((int64_t)Bindings.size() != NumElems) {
878  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
879  << DecompType << (unsigned)Bindings.size() << NumElems.toString(10)
880  << (NumElems < Bindings.size());
881  return true;
882  }
883 
884  unsigned I = 0;
885  for (auto *B : Bindings) {
886  SourceLocation Loc = B->getLocation();
887  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
888  if (E.isInvalid())
889  return true;
890  E = GetInit(Loc, E.get(), I++);
891  if (E.isInvalid())
892  return true;
893  B->setBinding(ElemType, E.get());
894  }
895 
896  return false;
897 }
898 
900  ArrayRef<BindingDecl *> Bindings,
901  ValueDecl *Src, QualType DecompType,
902  const llvm::APSInt &NumElems,
903  QualType ElemType) {
905  S, Bindings, Src, DecompType, NumElems, ElemType,
906  [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
907  ExprResult E = S.ActOnIntegerConstant(Loc, I);
908  if (E.isInvalid())
909  return ExprError();
910  return S.CreateBuiltinArraySubscriptExpr(Base, Loc, E.get(), Loc);
911  });
912 }
913 
915  ValueDecl *Src, QualType DecompType,
916  const ConstantArrayType *CAT) {
917  return checkArrayLikeDecomposition(S, Bindings, Src, DecompType,
918  llvm::APSInt(CAT->getSize()),
919  CAT->getElementType());
920 }
921 
923  ValueDecl *Src, QualType DecompType,
924  const VectorType *VT) {
926  S, Bindings, Src, DecompType, llvm::APSInt::get(VT->getNumElements()),
928  DecompType.getQualifiers()));
929 }
930 
932  ArrayRef<BindingDecl *> Bindings,
933  ValueDecl *Src, QualType DecompType,
934  const ComplexType *CT) {
936  S, Bindings, Src, DecompType, llvm::APSInt::get(2),
938  DecompType.getQualifiers()),
939  [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
940  return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
941  });
942 }
943 
945  TemplateArgumentListInfo &Args) {
946  SmallString<128> SS;
947  llvm::raw_svector_ostream OS(SS);
948  bool First = true;
949  for (auto &Arg : Args.arguments()) {
950  if (!First)
951  OS << ", ";
952  Arg.getArgument().print(PrintingPolicy, OS);
953  First = false;
954  }
955  return OS.str();
956 }
957 
958 static bool lookupStdTypeTraitMember(Sema &S, LookupResult &TraitMemberLookup,
959  SourceLocation Loc, StringRef Trait,
961  unsigned DiagID) {
962  auto DiagnoseMissing = [&] {
963  if (DiagID)
964  S.Diag(Loc, DiagID) << printTemplateArgs(S.Context.getPrintingPolicy(),
965  Args);
966  return true;
967  };
968 
969  // FIXME: Factor out duplication with lookupPromiseType in SemaCoroutine.
971  if (!Std)
972  return DiagnoseMissing();
973 
974  // Look up the trait itself, within namespace std. We can diagnose various
975  // problems with this lookup even if we've been asked to not diagnose a
976  // missing specialization, because this can only fail if the user has been
977  // declaring their own names in namespace std or we don't support the
978  // standard library implementation in use.
981  if (!S.LookupQualifiedName(Result, Std))
982  return DiagnoseMissing();
983  if (Result.isAmbiguous())
984  return true;
985 
986  ClassTemplateDecl *TraitTD = Result.getAsSingle<ClassTemplateDecl>();
987  if (!TraitTD) {
988  Result.suppressDiagnostics();
989  NamedDecl *Found = *Result.begin();
990  S.Diag(Loc, diag::err_std_type_trait_not_class_template) << Trait;
991  S.Diag(Found->getLocation(), diag::note_declared_at);
992  return true;
993  }
994 
995  // Build the template-id.
996  QualType TraitTy = S.CheckTemplateIdType(TemplateName(TraitTD), Loc, Args);
997  if (TraitTy.isNull())
998  return true;
999  if (!S.isCompleteType(Loc, TraitTy)) {
1000  if (DiagID)
1002  Loc, TraitTy, DiagID,
1004  return true;
1005  }
1006 
1007  CXXRecordDecl *RD = TraitTy->getAsCXXRecordDecl();
1008  assert(RD && "specialization of class template is not a class?");
1009 
1010  // Look up the member of the trait type.
1011  S.LookupQualifiedName(TraitMemberLookup, RD);
1012  return TraitMemberLookup.isAmbiguous();
1013 }
1014 
1015 static TemplateArgumentLoc
1017  uint64_t I) {
1018  TemplateArgument Arg(S.Context, S.Context.MakeIntValue(I, T), T);
1019  return S.getTrivialTemplateArgumentLoc(Arg, T, Loc);
1020 }
1021 
1022 static TemplateArgumentLoc
1025 }
1026 
1027 namespace { enum class IsTupleLike { TupleLike, NotTupleLike, Error }; }
1028 
1030  llvm::APSInt &Size) {
1033 
1035  LookupResult R(S, Value, Loc, Sema::LookupOrdinaryName);
1036 
1037  // Form template argument list for tuple_size<T>.
1038  TemplateArgumentListInfo Args(Loc, Loc);
1040 
1041  // If there's no tuple_size specialization or the lookup of 'value' is empty,
1042  // it's not tuple-like.
1043  if (lookupStdTypeTraitMember(S, R, Loc, "tuple_size", Args, /*DiagID*/ 0) ||
1044  R.empty())
1045  return IsTupleLike::NotTupleLike;
1046 
1047  // If we get this far, we've committed to the tuple interpretation, but
1048  // we can still fail if there actually isn't a usable ::value.
1049 
1050  struct ICEDiagnoser : Sema::VerifyICEDiagnoser {
1051  LookupResult &R;
1053  ICEDiagnoser(LookupResult &R, TemplateArgumentListInfo &Args)
1054  : R(R), Args(Args) {}
1055  void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) {
1056  S.Diag(Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
1058  }
1059  } Diagnoser(R, Args);
1060 
1061  ExprResult E =
1062  S.BuildDeclarationNameExpr(CXXScopeSpec(), R, /*NeedsADL*/false);
1063  if (E.isInvalid())
1064  return IsTupleLike::Error;
1065 
1066  E = S.VerifyIntegerConstantExpression(E.get(), &Size, Diagnoser, false);
1067  if (E.isInvalid())
1068  return IsTupleLike::Error;
1069 
1070  return IsTupleLike::TupleLike;
1071 }
1072 
1073 /// \return std::tuple_element<I, T>::type.
1075  unsigned I, QualType T) {
1076  // Form template argument list for tuple_element<I, T>.
1077  TemplateArgumentListInfo Args(Loc, Loc);
1078  Args.addArgument(
1081 
1082  DeclarationName TypeDN = S.PP.getIdentifierInfo("type");
1083  LookupResult R(S, TypeDN, Loc, Sema::LookupOrdinaryName);
1085  S, R, Loc, "tuple_element", Args,
1086  diag::err_decomp_decl_std_tuple_element_not_specialized))
1087  return QualType();
1088 
1089  auto *TD = R.getAsSingle<TypeDecl>();
1090  if (!TD) {
1091  R.suppressDiagnostics();
1092  S.Diag(Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
1094  if (!R.empty())
1095  S.Diag(R.getRepresentativeDecl()->getLocation(), diag::note_declared_at);
1096  return QualType();
1097  }
1098 
1099  return S.Context.getTypeDeclType(TD);
1100 }
1101 
1102 namespace {
1103 struct BindingDiagnosticTrap {
1104  Sema &S;
1105  DiagnosticErrorTrap Trap;
1106  BindingDecl *BD;
1107 
1108  BindingDiagnosticTrap(Sema &S, BindingDecl *BD)
1109  : S(S), Trap(S.Diags), BD(BD) {}
1110  ~BindingDiagnosticTrap() {
1111  if (Trap.hasErrorOccurred())
1112  S.Diag(BD->getLocation(), diag::note_in_binding_decl_init) << BD;
1113  }
1114 };
1115 }
1116 
1118  ArrayRef<BindingDecl *> Bindings,
1119  VarDecl *Src, QualType DecompType,
1120  const llvm::APSInt &TupleSize) {
1121  if ((int64_t)Bindings.size() != TupleSize) {
1122  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1123  << DecompType << (unsigned)Bindings.size() << TupleSize.toString(10)
1124  << (TupleSize < Bindings.size());
1125  return true;
1126  }
1127 
1128  if (Bindings.empty())
1129  return false;
1130 
1131  DeclarationName GetDN = S.PP.getIdentifierInfo("get");
1132 
1133  // [dcl.decomp]p3:
1134  // The unqualified-id get is looked up in the scope of E by class member
1135  // access lookup ...
1136  LookupResult MemberGet(S, GetDN, Src->getLocation(), Sema::LookupMemberName);
1137  bool UseMemberGet = false;
1138  if (S.isCompleteType(Src->getLocation(), DecompType)) {
1139  if (auto *RD = DecompType->getAsCXXRecordDecl())
1140  S.LookupQualifiedName(MemberGet, RD);
1141  if (MemberGet.isAmbiguous())
1142  return true;
1143  // ... and if that finds at least one declaration that is a function
1144  // template whose first template parameter is a non-type parameter ...
1145  for (NamedDecl *D : MemberGet) {
1146  if (FunctionTemplateDecl *FTD =
1147  dyn_cast<FunctionTemplateDecl>(D->getUnderlyingDecl())) {
1148  TemplateParameterList *TPL = FTD->getTemplateParameters();
1149  if (TPL->size() != 0 &&
1150  isa<NonTypeTemplateParmDecl>(TPL->getParam(0))) {
1151  // ... the initializer is e.get<i>().
1152  UseMemberGet = true;
1153  break;
1154  }
1155  }
1156  }
1157  }
1158 
1159  unsigned I = 0;
1160  for (auto *B : Bindings) {
1161  BindingDiagnosticTrap Trap(S, B);
1162  SourceLocation Loc = B->getLocation();
1163 
1164  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1165  if (E.isInvalid())
1166  return true;
1167 
1168  // e is an lvalue if the type of the entity is an lvalue reference and
1169  // an xvalue otherwise
1170  if (!Src->getType()->isLValueReferenceType())
1171  E = ImplicitCastExpr::Create(S.Context, E.get()->getType(), CK_NoOp,
1172  E.get(), nullptr, VK_XValue);
1173 
1174  TemplateArgumentListInfo Args(Loc, Loc);
1175  Args.addArgument(
1177 
1178  if (UseMemberGet) {
1179  // if [lookup of member get] finds at least one declaration, the
1180  // initializer is e.get<i-1>().
1181  E = S.BuildMemberReferenceExpr(E.get(), DecompType, Loc, false,
1182  CXXScopeSpec(), SourceLocation(), nullptr,
1183  MemberGet, &Args, nullptr);
1184  if (E.isInvalid())
1185  return true;
1186 
1187  E = S.BuildCallExpr(nullptr, E.get(), Loc, None, Loc);
1188  } else {
1189  // Otherwise, the initializer is get<i-1>(e), where get is looked up
1190  // in the associated namespaces.
1193  DeclarationNameInfo(GetDN, Loc), /*RequiresADL*/true, &Args,
1195 
1196  Expr *Arg = E.get();
1197  E = S.BuildCallExpr(nullptr, Get, Loc, Arg, Loc);
1198  }
1199  if (E.isInvalid())
1200  return true;
1201  Expr *Init = E.get();
1202 
1203  // Given the type T designated by std::tuple_element<i - 1, E>::type,
1204  QualType T = getTupleLikeElementType(S, Loc, I, DecompType);
1205  if (T.isNull())
1206  return true;
1207 
1208  // each vi is a variable of type "reference to T" initialized with the
1209  // initializer, where the reference is an lvalue reference if the
1210  // initializer is an lvalue and an rvalue reference otherwise
1211  QualType RefType =
1212  S.BuildReferenceType(T, E.get()->isLValue(), Loc, B->getDeclName());
1213  if (RefType.isNull())
1214  return true;
1215  auto *RefVD = VarDecl::Create(
1216  S.Context, Src->getDeclContext(), Loc, Loc,
1217  B->getDeclName().getAsIdentifierInfo(), RefType,
1220  RefVD->setTSCSpec(Src->getTSCSpec());
1221  RefVD->setImplicit();
1222  if (Src->isInlineSpecified())
1223  RefVD->setInlineSpecified();
1224  RefVD->getLexicalDeclContext()->addHiddenDecl(RefVD);
1225 
1228  InitializationSequence Seq(S, Entity, Kind, Init);
1229  E = Seq.Perform(S, Entity, Kind, Init);
1230  if (E.isInvalid())
1231  return true;
1232  E = S.ActOnFinishFullExpr(E.get(), Loc, /*DiscardedValue*/ false);
1233  if (E.isInvalid())
1234  return true;
1235  RefVD->setInit(E.get());
1236  if (!E.get()->isValueDependent())
1237  RefVD->checkInitIsICE();
1238 
1240  DeclarationNameInfo(B->getDeclName(), Loc),
1241  RefVD);
1242  if (E.isInvalid())
1243  return true;
1244 
1245  B->setBinding(T, E.get());
1246  I++;
1247  }
1248 
1249  return false;
1250 }
1251 
1252 /// Find the base class to decompose in a built-in decomposition of a class type.
1253 /// This base class search is, unfortunately, not quite like any other that we
1254 /// perform anywhere else in C++.
1256  const CXXRecordDecl *RD,
1257  CXXCastPath &BasePath) {
1258  auto BaseHasFields = [](const CXXBaseSpecifier *Specifier,
1259  CXXBasePath &Path) {
1260  return Specifier->getType()->getAsCXXRecordDecl()->hasDirectFields();
1261  };
1262 
1263  const CXXRecordDecl *ClassWithFields = nullptr;
1265  if (RD->hasDirectFields())
1266  // [dcl.decomp]p4:
1267  // Otherwise, all of E's non-static data members shall be public direct
1268  // members of E ...
1269  ClassWithFields = RD;
1270  else {
1271  // ... or of ...
1272  CXXBasePaths Paths;
1273  Paths.setOrigin(const_cast<CXXRecordDecl*>(RD));
1274  if (!RD->lookupInBases(BaseHasFields, Paths)) {
1275  // If no classes have fields, just decompose RD itself. (This will work
1276  // if and only if zero bindings were provided.)
1277  return DeclAccessPair::make(const_cast<CXXRecordDecl*>(RD), AS_public);
1278  }
1279 
1280  CXXBasePath *BestPath = nullptr;
1281  for (auto &P : Paths) {
1282  if (!BestPath)
1283  BestPath = &P;
1284  else if (!S.Context.hasSameType(P.back().Base->getType(),
1285  BestPath->back().Base->getType())) {
1286  // ... the same ...
1287  S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1288  << false << RD << BestPath->back().Base->getType()
1289  << P.back().Base->getType();
1290  return DeclAccessPair();
1291  } else if (P.Access < BestPath->Access) {
1292  BestPath = &P;
1293  }
1294  }
1295 
1296  // ... unambiguous ...
1297  QualType BaseType = BestPath->back().Base->getType();
1298  if (Paths.isAmbiguous(S.Context.getCanonicalType(BaseType))) {
1299  S.Diag(Loc, diag::err_decomp_decl_ambiguous_base)
1300  << RD << BaseType << S.getAmbiguousPathsDisplayString(Paths);
1301  return DeclAccessPair();
1302  }
1303 
1304  // ... [accessible, implied by other rules] base class of E.
1305  S.CheckBaseClassAccess(Loc, BaseType, S.Context.getRecordType(RD),
1306  *BestPath, diag::err_decomp_decl_inaccessible_base);
1307  AS = BestPath->Access;
1308 
1309  ClassWithFields = BaseType->getAsCXXRecordDecl();
1310  S.BuildBasePathArray(Paths, BasePath);
1311  }
1312 
1313  // The above search did not check whether the selected class itself has base
1314  // classes with fields, so check that now.
1315  CXXBasePaths Paths;
1316  if (ClassWithFields->lookupInBases(BaseHasFields, Paths)) {
1317  S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1318  << (ClassWithFields == RD) << RD << ClassWithFields
1319  << Paths.front().back().Base->getType();
1320  return DeclAccessPair();
1321  }
1322 
1323  return DeclAccessPair::make(const_cast<CXXRecordDecl*>(ClassWithFields), AS);
1324 }
1325 
1327  ValueDecl *Src, QualType DecompType,
1328  const CXXRecordDecl *OrigRD) {
1329  if (S.RequireCompleteType(Src->getLocation(), DecompType,
1330  diag::err_incomplete_type))
1331  return true;
1332 
1333  CXXCastPath BasePath;
1334  DeclAccessPair BasePair =
1335  findDecomposableBaseClass(S, Src->getLocation(), OrigRD, BasePath);
1336  const CXXRecordDecl *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
1337  if (!RD)
1338  return true;
1340  DecompType.getQualifiers());
1341 
1342  auto DiagnoseBadNumberOfBindings = [&]() -> bool {
1343  unsigned NumFields =
1344  std::count_if(RD->field_begin(), RD->field_end(),
1345  [](FieldDecl *FD) { return !FD->isUnnamedBitfield(); });
1346  assert(Bindings.size() != NumFields);
1347  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1348  << DecompType << (unsigned)Bindings.size() << NumFields
1349  << (NumFields < Bindings.size());
1350  return true;
1351  };
1352 
1353  // all of E's non-static data members shall be [...] well-formed
1354  // when named as e.name in the context of the structured binding,
1355  // E shall not have an anonymous union member, ...
1356  unsigned I = 0;
1357  for (auto *FD : RD->fields()) {
1358  if (FD->isUnnamedBitfield())
1359  continue;
1360 
1361  if (FD->isAnonymousStructOrUnion()) {
1362  S.Diag(Src->getLocation(), diag::err_decomp_decl_anon_union_member)
1363  << DecompType << FD->getType()->isUnionType();
1364  S.Diag(FD->getLocation(), diag::note_declared_at);
1365  return true;
1366  }
1367 
1368  // We have a real field to bind.
1369  if (I >= Bindings.size())
1370  return DiagnoseBadNumberOfBindings();
1371  auto *B = Bindings[I++];
1372  SourceLocation Loc = B->getLocation();
1373 
1374  // The field must be accessible in the context of the structured binding.
1375  // We already checked that the base class is accessible.
1376  // FIXME: Add 'const' to AccessedEntity's classes so we can remove the
1377  // const_cast here.
1379  Loc, const_cast<CXXRecordDecl *>(OrigRD),
1381  BasePair.getAccess(), FD->getAccess())));
1382 
1383  // Initialize the binding to Src.FD.
1384  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1385  if (E.isInvalid())
1386  return true;
1387  E = S.ImpCastExprToType(E.get(), BaseType, CK_UncheckedDerivedToBase,
1388  VK_LValue, &BasePath);
1389  if (E.isInvalid())
1390  return true;
1391  E = S.BuildFieldReferenceExpr(E.get(), /*IsArrow*/ false, Loc,
1392  CXXScopeSpec(), FD,
1393  DeclAccessPair::make(FD, FD->getAccess()),
1394  DeclarationNameInfo(FD->getDeclName(), Loc));
1395  if (E.isInvalid())
1396  return true;
1397 
1398  // If the type of the member is T, the referenced type is cv T, where cv is
1399  // the cv-qualification of the decomposition expression.
1400  //
1401  // FIXME: We resolve a defect here: if the field is mutable, we do not add
1402  // 'const' to the type of the field.
1403  Qualifiers Q = DecompType.getQualifiers();
1404  if (FD->isMutable())
1405  Q.removeConst();
1406  B->setBinding(S.BuildQualifiedType(FD->getType(), Loc, Q), E.get());
1407  }
1408 
1409  if (I != Bindings.size())
1410  return DiagnoseBadNumberOfBindings();
1411 
1412  return false;
1413 }
1414 
1416  QualType DecompType = DD->getType();
1417 
1418  // If the type of the decomposition is dependent, then so is the type of
1419  // each binding.
1420  if (DecompType->isDependentType()) {
1421  for (auto *B : DD->bindings())
1422  B->setType(Context.DependentTy);
1423  return;
1424  }
1425 
1426  DecompType = DecompType.getNonReferenceType();
1427  ArrayRef<BindingDecl*> Bindings = DD->bindings();
1428 
1429  // C++1z [dcl.decomp]/2:
1430  // If E is an array type [...]
1431  // As an extension, we also support decomposition of built-in complex and
1432  // vector types.
1433  if (auto *CAT = Context.getAsConstantArrayType(DecompType)) {
1434  if (checkArrayDecomposition(*this, Bindings, DD, DecompType, CAT))
1435  DD->setInvalidDecl();
1436  return;
1437  }
1438  if (auto *VT = DecompType->getAs<VectorType>()) {
1439  if (checkVectorDecomposition(*this, Bindings, DD, DecompType, VT))
1440  DD->setInvalidDecl();
1441  return;
1442  }
1443  if (auto *CT = DecompType->getAs<ComplexType>()) {
1444  if (checkComplexDecomposition(*this, Bindings, DD, DecompType, CT))
1445  DD->setInvalidDecl();
1446  return;
1447  }
1448 
1449  // C++1z [dcl.decomp]/3:
1450  // if the expression std::tuple_size<E>::value is a well-formed integral
1451  // constant expression, [...]
1452  llvm::APSInt TupleSize(32);
1453  switch (isTupleLike(*this, DD->getLocation(), DecompType, TupleSize)) {
1454  case IsTupleLike::Error:
1455  DD->setInvalidDecl();
1456  return;
1457 
1458  case IsTupleLike::TupleLike:
1459  if (checkTupleLikeDecomposition(*this, Bindings, DD, DecompType, TupleSize))
1460  DD->setInvalidDecl();
1461  return;
1462 
1463  case IsTupleLike::NotTupleLike:
1464  break;
1465  }
1466 
1467  // C++1z [dcl.dcl]/8:
1468  // [E shall be of array or non-union class type]
1469  CXXRecordDecl *RD = DecompType->getAsCXXRecordDecl();
1470  if (!RD || RD->isUnion()) {
1471  Diag(DD->getLocation(), diag::err_decomp_decl_unbindable_type)
1472  << DD << !RD << DecompType;
1473  DD->setInvalidDecl();
1474  return;
1475  }
1476 
1477  // C++1z [dcl.decomp]/4:
1478  // all of E's non-static data members shall be [...] direct members of
1479  // E or of the same unambiguous public base class of E, ...
1480  if (checkMemberDecomposition(*this, Bindings, DD, DecompType, RD))
1481  DD->setInvalidDecl();
1482 }
1483 
1484 /// Merge the exception specifications of two variable declarations.
1485 ///
1486 /// This is called when there's a redeclaration of a VarDecl. The function
1487 /// checks if the redeclaration might have an exception specification and
1488 /// validates compatibility and merges the specs if necessary.
1490  // Shortcut if exceptions are disabled.
1491  if (!getLangOpts().CXXExceptions)
1492  return;
1493 
1494  assert(Context.hasSameType(New->getType(), Old->getType()) &&
1495  "Should only be called if types are otherwise the same.");
1496 
1497  QualType NewType = New->getType();
1498  QualType OldType = Old->getType();
1499 
1500  // We're only interested in pointers and references to functions, as well
1501  // as pointers to member functions.
1502  if (const ReferenceType *R = NewType->getAs<ReferenceType>()) {
1503  NewType = R->getPointeeType();
1504  OldType = OldType->castAs<ReferenceType>()->getPointeeType();
1505  } else if (const PointerType *P = NewType->getAs<PointerType>()) {
1506  NewType = P->getPointeeType();
1507  OldType = OldType->castAs<PointerType>()->getPointeeType();
1508  } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) {
1509  NewType = M->getPointeeType();
1510  OldType = OldType->castAs<MemberPointerType>()->getPointeeType();
1511  }
1512 
1513  if (!NewType->isFunctionProtoType())
1514  return;
1515 
1516  // There's lots of special cases for functions. For function pointers, system
1517  // libraries are hopefully not as broken so that we don't need these
1518  // workarounds.
1519  if (CheckEquivalentExceptionSpec(
1520  OldType->getAs<FunctionProtoType>(), Old->getLocation(),
1521  NewType->getAs<FunctionProtoType>(), New->getLocation())) {
1522  New->setInvalidDecl();
1523  }
1524 }
1525 
1526 /// CheckCXXDefaultArguments - Verify that the default arguments for a
1527 /// function declaration are well-formed according to C++
1528 /// [dcl.fct.default].
1530  unsigned NumParams = FD->getNumParams();
1531  unsigned p;
1532 
1533  // Find first parameter with a default argument
1534  for (p = 0; p < NumParams; ++p) {
1535  ParmVarDecl *Param = FD->getParamDecl(p);
1536  if (Param->hasDefaultArg())
1537  break;
1538  }
1539 
1540  // C++11 [dcl.fct.default]p4:
1541  // In a given function declaration, each parameter subsequent to a parameter
1542  // with a default argument shall have a default argument supplied in this or
1543  // a previous declaration or shall be a function parameter pack. A default
1544  // argument shall not be redefined by a later declaration (not even to the
1545  // same value).
1546  unsigned LastMissingDefaultArg = 0;
1547  for (; p < NumParams; ++p) {
1548  ParmVarDecl *Param = FD->getParamDecl(p);
1549  if (!Param->hasDefaultArg() && !Param->isParameterPack()) {
1550  if (Param->isInvalidDecl())
1551  /* We already complained about this parameter. */;
1552  else if (Param->getIdentifier())
1553  Diag(Param->getLocation(),
1554  diag::err_param_default_argument_missing_name)
1555  << Param->getIdentifier();
1556  else
1557  Diag(Param->getLocation(),
1558  diag::err_param_default_argument_missing);
1559 
1560  LastMissingDefaultArg = p;
1561  }
1562  }
1563 
1564  if (LastMissingDefaultArg > 0) {
1565  // Some default arguments were missing. Clear out all of the
1566  // default arguments up to (and including) the last missing
1567  // default argument, so that we leave the function parameters
1568  // in a semantically valid state.
1569  for (p = 0; p <= LastMissingDefaultArg; ++p) {
1570  ParmVarDecl *Param = FD->getParamDecl(p);
1571  if (Param->hasDefaultArg()) {
1572  Param->setDefaultArg(nullptr);
1573  }
1574  }
1575  }
1576 }
1577 
1578 /// Check that the given type is a literal type. Issue a diagnostic if not,
1579 /// if Kind is Diagnose.
1580 /// \return \c true if a problem has been found (and optionally diagnosed).
1581 template <typename... Ts>
1583  SourceLocation Loc, QualType T, unsigned DiagID,
1584  Ts &&...DiagArgs) {
1585  if (T->isDependentType())
1586  return false;
1587 
1588  switch (Kind) {
1590  return SemaRef.RequireLiteralType(Loc, T, DiagID,
1591  std::forward<Ts>(DiagArgs)...);
1592 
1594  return !T->isLiteralType(SemaRef.Context);
1595  }
1596 
1597  llvm_unreachable("unknown CheckConstexprKind");
1598 }
1599 
1600 /// Determine whether a destructor cannot be constexpr due to
1602  const CXXDestructorDecl *DD,
1604  auto Check = [&](SourceLocation Loc, QualType T, const FieldDecl *FD) {
1605  const CXXRecordDecl *RD =
1606  T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
1607  if (!RD || RD->hasConstexprDestructor())
1608  return true;
1609 
1610  if (Kind == Sema::CheckConstexprKind::Diagnose) {
1611  SemaRef.Diag(DD->getLocation(), diag::err_constexpr_dtor_subobject)
1612  << DD->getConstexprKind() << !FD
1613  << (FD ? FD->getDeclName() : DeclarationName()) << T;
1614  SemaRef.Diag(Loc, diag::note_constexpr_dtor_subobject)
1615  << !FD << (FD ? FD->getDeclName() : DeclarationName()) << T;
1616  }
1617  return false;
1618  };
1619 
1620  const CXXRecordDecl *RD = DD->getParent();
1621  for (const CXXBaseSpecifier &B : RD->bases())
1622  if (!Check(B.getBaseTypeLoc(), B.getType(), nullptr))
1623  return false;
1624  for (const FieldDecl *FD : RD->fields())
1625  if (!Check(FD->getLocation(), FD->getType(), FD))
1626  return false;
1627  return true;
1628 }
1629 
1630 /// Check whether a function's parameter types are all literal types. If so,
1631 /// return true. If not, produce a suitable diagnostic and return false.
1632 static bool CheckConstexprParameterTypes(Sema &SemaRef,
1633  const FunctionDecl *FD,
1635  unsigned ArgIndex = 0;
1636  const auto *FT = FD->getType()->castAs<FunctionProtoType>();
1637  for (FunctionProtoType::param_type_iterator i = FT->param_type_begin(),
1638  e = FT->param_type_end();
1639  i != e; ++i, ++ArgIndex) {
1640  const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
1641  SourceLocation ParamLoc = PD->getLocation();
1642  if (CheckLiteralType(SemaRef, Kind, ParamLoc, *i,
1643  diag::err_constexpr_non_literal_param, ArgIndex + 1,
1644  PD->getSourceRange(), isa<CXXConstructorDecl>(FD),
1645  FD->isConsteval()))
1646  return false;
1647  }
1648  return true;
1649 }
1650 
1651 /// Check whether a function's return type is a literal type. If so, return
1652 /// true. If not, produce a suitable diagnostic and return false.
1653 static bool CheckConstexprReturnType(Sema &SemaRef, const FunctionDecl *FD,
1655  if (CheckLiteralType(SemaRef, Kind, FD->getLocation(), FD->getReturnType(),
1656  diag::err_constexpr_non_literal_return,
1657  FD->isConsteval()))
1658  return false;
1659  return true;
1660 }
1661 
1662 /// Get diagnostic %select index for tag kind for
1663 /// record diagnostic message.
1664 /// WARNING: Indexes apply to particular diagnostics only!
1665 ///
1666 /// \returns diagnostic %select index.
1668  switch (Tag) {
1669  case TTK_Struct: return 0;
1670  case TTK_Interface: return 1;
1671  case TTK_Class: return 2;
1672  default: llvm_unreachable("Invalid tag kind for record diagnostic!");
1673  }
1674 }
1675 
1676 static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl,
1677  Stmt *Body,
1679 
1680 // Check whether a function declaration satisfies the requirements of a
1681 // constexpr function definition or a constexpr constructor definition. If so,
1682 // return true. If not, produce appropriate diagnostics (unless asked not to by
1683 // Kind) and return false.
1684 //
1685 // This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360.
1687  CheckConstexprKind Kind) {
1688  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
1689  if (MD && MD->isInstance()) {
1690  // C++11 [dcl.constexpr]p4:
1691  // The definition of a constexpr constructor shall satisfy the following
1692  // constraints:
1693  // - the class shall not have any virtual base classes;
1694  //
1695  // FIXME: This only applies to constructors and destructors, not arbitrary
1696  // member functions.
1697  const CXXRecordDecl *RD = MD->getParent();
1698  if (RD->getNumVBases()) {
1699  if (Kind == CheckConstexprKind::CheckValid)
1700  return false;
1701 
1702  Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base)
1703  << isa<CXXConstructorDecl>(NewFD)
1705  for (const auto &I : RD->vbases())
1706  Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
1707  << I.getSourceRange();
1708  return false;
1709  }
1710  }
1711 
1712  if (!isa<CXXConstructorDecl>(NewFD)) {
1713  // C++11 [dcl.constexpr]p3:
1714  // The definition of a constexpr function shall satisfy the following
1715  // constraints:
1716  // - it shall not be virtual; (removed in C++20)
1717  const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
1718  if (Method && Method->isVirtual()) {
1719  if (getLangOpts().CPlusPlus2a) {
1720  if (Kind == CheckConstexprKind::Diagnose)
1721  Diag(Method->getLocation(), diag::warn_cxx17_compat_constexpr_virtual);
1722  } else {
1723  if (Kind == CheckConstexprKind::CheckValid)
1724  return false;
1725 
1726  Method = Method->getCanonicalDecl();
1727  Diag(Method->getLocation(), diag::err_constexpr_virtual);
1728 
1729  // If it's not obvious why this function is virtual, find an overridden
1730  // function which uses the 'virtual' keyword.
1731  const CXXMethodDecl *WrittenVirtual = Method;
1732  while (!WrittenVirtual->isVirtualAsWritten())
1733  WrittenVirtual = *WrittenVirtual->begin_overridden_methods();
1734  if (WrittenVirtual != Method)
1735  Diag(WrittenVirtual->getLocation(),
1736  diag::note_overridden_virtual_function);
1737  return false;
1738  }
1739  }
1740 
1741  // - its return type shall be a literal type;
1742  if (!CheckConstexprReturnType(*this, NewFD, Kind))
1743  return false;
1744  }
1745 
1746  if (auto *Dtor = dyn_cast<CXXDestructorDecl>(NewFD)) {
1747  // A destructor can be constexpr only if the defaulted destructor could be;
1748  // we don't need to check the members and bases if we already know they all
1749  // have constexpr destructors.
1750  if (!Dtor->getParent()->defaultedDestructorIsConstexpr()) {
1751  if (Kind == CheckConstexprKind::CheckValid)
1752  return false;
1753  if (!CheckConstexprDestructorSubobjects(*this, Dtor, Kind))
1754  return false;
1755  }
1756  }
1757 
1758  // - each of its parameter types shall be a literal type;
1759  if (!CheckConstexprParameterTypes(*this, NewFD, Kind))
1760  return false;
1761 
1762  Stmt *Body = NewFD->getBody();
1763  assert(Body &&
1764  "CheckConstexprFunctionDefinition called on function with no body");
1765  return CheckConstexprFunctionBody(*this, NewFD, Body, Kind);
1766 }
1767 
1768 /// Check the given declaration statement is legal within a constexpr function
1769 /// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.
1770 ///
1771 /// \return true if the body is OK (maybe only as an extension), false if we
1772 /// have diagnosed a problem.
1773 static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
1774  DeclStmt *DS, SourceLocation &Cxx1yLoc,
1775  Sema::CheckConstexprKind Kind) {
1776  // C++11 [dcl.constexpr]p3 and p4:
1777  // The definition of a constexpr function(p3) or constructor(p4) [...] shall
1778  // contain only
1779  for (const auto *DclIt : DS->decls()) {
1780  switch (DclIt->getKind()) {
1781  case Decl::StaticAssert:
1782  case Decl::Using:
1783  case Decl::UsingShadow:
1784  case Decl::UsingDirective:
1785  case Decl::UnresolvedUsingTypename:
1786  case Decl::UnresolvedUsingValue:
1787  // - static_assert-declarations
1788  // - using-declarations,
1789  // - using-directives,
1790  continue;
1791 
1792  case Decl::Typedef:
1793  case Decl::TypeAlias: {
1794  // - typedef declarations and alias-declarations that do not define
1795  // classes or enumerations,
1796  const auto *TN = cast<TypedefNameDecl>(DclIt);
1797  if (TN->getUnderlyingType()->isVariablyModifiedType()) {
1798  // Don't allow variably-modified types in constexpr functions.
1799  if (Kind == Sema::CheckConstexprKind::Diagnose) {
1800  TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
1801  SemaRef.Diag(TL.getBeginLoc(), diag::err_constexpr_vla)
1802  << TL.getSourceRange() << TL.getType()
1803  << isa<CXXConstructorDecl>(Dcl);
1804  }
1805  return false;
1806  }
1807  continue;
1808  }
1809 
1810  case Decl::Enum:
1811  case Decl::CXXRecord:
1812  // C++1y allows types to be defined, not just declared.
1813  if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition()) {
1814  if (Kind == Sema::CheckConstexprKind::Diagnose) {
1815  SemaRef.Diag(DS->getBeginLoc(),
1816  SemaRef.getLangOpts().CPlusPlus14
1817  ? diag::warn_cxx11_compat_constexpr_type_definition
1818  : diag::ext_constexpr_type_definition)
1819  << isa<CXXConstructorDecl>(Dcl);
1820  } else if (!SemaRef.getLangOpts().CPlusPlus14) {
1821  return false;
1822  }
1823  }
1824  continue;
1825 
1826  case Decl::EnumConstant:
1827  case Decl::IndirectField:
1828  case Decl::ParmVar:
1829  // These can only appear with other declarations which are banned in
1830  // C++11 and permitted in C++1y, so ignore them.
1831  continue;
1832 
1833  case Decl::Var:
1834  case Decl::Decomposition: {
1835  // C++1y [dcl.constexpr]p3 allows anything except:
1836  // a definition of a variable of non-literal type or of static or
1837  // thread storage duration or [before C++2a] for which no
1838  // initialization is performed.
1839  const auto *VD = cast<VarDecl>(DclIt);
1840  if (VD->isThisDeclarationADefinition()) {
1841  if (VD->isStaticLocal()) {
1842  if (Kind == Sema::CheckConstexprKind::Diagnose) {
1843  SemaRef.Diag(VD->getLocation(),
1844  diag::err_constexpr_local_var_static)
1845  << isa<CXXConstructorDecl>(Dcl)
1846  << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
1847  }
1848  return false;
1849  }
1850  if (CheckLiteralType(SemaRef, Kind, VD->getLocation(), VD->getType(),
1851  diag::err_constexpr_local_var_non_literal_type,
1852  isa<CXXConstructorDecl>(Dcl)))
1853  return false;
1854  if (!VD->getType()->isDependentType() &&
1855  !VD->hasInit() && !VD->isCXXForRangeDecl()) {
1856  if (Kind == Sema::CheckConstexprKind::Diagnose) {
1857  SemaRef.Diag(
1858  VD->getLocation(),
1859  SemaRef.getLangOpts().CPlusPlus2a
1860  ? diag::warn_cxx17_compat_constexpr_local_var_no_init
1861  : diag::ext_constexpr_local_var_no_init)
1862  << isa<CXXConstructorDecl>(Dcl);
1863  } else if (!SemaRef.getLangOpts().CPlusPlus2a) {
1864  return false;
1865  }
1866  continue;
1867  }
1868  }
1869  if (Kind == Sema::CheckConstexprKind::Diagnose) {
1870  SemaRef.Diag(VD->getLocation(),
1871  SemaRef.getLangOpts().CPlusPlus14
1872  ? diag::warn_cxx11_compat_constexpr_local_var
1873  : diag::ext_constexpr_local_var)
1874  << isa<CXXConstructorDecl>(Dcl);
1875  } else if (!SemaRef.getLangOpts().CPlusPlus14) {
1876  return false;
1877  }
1878  continue;
1879  }
1880 
1881  case Decl::NamespaceAlias:
1882  case Decl::Function:
1883  // These are disallowed in C++11 and permitted in C++1y. Allow them
1884  // everywhere as an extension.
1885  if (!Cxx1yLoc.isValid())
1886  Cxx1yLoc = DS->getBeginLoc();
1887  continue;
1888 
1889  default:
1890  if (Kind == Sema::CheckConstexprKind::Diagnose) {
1891  SemaRef.Diag(DS->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
1892  << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval();
1893  }
1894  return false;
1895  }
1896  }
1897 
1898  return true;
1899 }
1900 
1901 /// Check that the given field is initialized within a constexpr constructor.
1902 ///
1903 /// \param Dcl The constexpr constructor being checked.
1904 /// \param Field The field being checked. This may be a member of an anonymous
1905 /// struct or union nested within the class being checked.
1906 /// \param Inits All declarations, including anonymous struct/union members and
1907 /// indirect members, for which any initialization was provided.
1908 /// \param Diagnosed Whether we've emitted the error message yet. Used to attach
1909 /// multiple notes for different members to the same error.
1910 /// \param Kind Whether we're diagnosing a constructor as written or determining
1911 /// whether the formal requirements are satisfied.
1912 /// \return \c false if we're checking for validity and the constructor does
1913 /// not satisfy the requirements on a constexpr constructor.
1915  const FunctionDecl *Dcl,
1916  FieldDecl *Field,
1917  llvm::SmallSet<Decl*, 16> &Inits,
1918  bool &Diagnosed,
1919  Sema::CheckConstexprKind Kind) {
1920  // In C++20 onwards, there's nothing to check for validity.
1922  SemaRef.getLangOpts().CPlusPlus2a)
1923  return true;
1924 
1925  if (Field->isInvalidDecl())
1926  return true;
1927 
1928  if (Field->isUnnamedBitfield())
1929  return true;
1930 
1931  // Anonymous unions with no variant members and empty anonymous structs do not
1932  // need to be explicitly initialized. FIXME: Anonymous structs that contain no
1933  // indirect fields don't need initializing.
1934  if (Field->isAnonymousStructOrUnion() &&
1935  (Field->getType()->isUnionType()
1936  ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
1937  : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
1938  return true;
1939 
1940  if (!Inits.count(Field)) {
1941  if (Kind == Sema::CheckConstexprKind::Diagnose) {
1942  if (!Diagnosed) {
1943  SemaRef.Diag(Dcl->getLocation(),
1944  SemaRef.getLangOpts().CPlusPlus2a
1945  ? diag::warn_cxx17_compat_constexpr_ctor_missing_init
1946  : diag::ext_constexpr_ctor_missing_init);
1947  Diagnosed = true;
1948  }
1949  SemaRef.Diag(Field->getLocation(),
1950  diag::note_constexpr_ctor_missing_init);
1951  } else if (!SemaRef.getLangOpts().CPlusPlus2a) {
1952  return false;
1953  }
1954  } else if (Field->isAnonymousStructOrUnion()) {
1955  const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
1956  for (auto *I : RD->fields())
1957  // If an anonymous union contains an anonymous struct of which any member
1958  // is initialized, all members must be initialized.
1959  if (!RD->isUnion() || Inits.count(I))
1960  if (!CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed,
1961  Kind))
1962  return false;
1963  }
1964  return true;
1965 }
1966 
1967 /// Check the provided statement is allowed in a constexpr function
1968 /// definition.
1969 static bool
1971  SmallVectorImpl<SourceLocation> &ReturnStmts,
1972  SourceLocation &Cxx1yLoc, SourceLocation &Cxx2aLoc,
1973  Sema::CheckConstexprKind Kind) {
1974  // - its function-body shall be [...] a compound-statement that contains only
1975  switch (S->getStmtClass()) {
1976  case Stmt::NullStmtClass:
1977  // - null statements,
1978  return true;
1979 
1980  case Stmt::DeclStmtClass:
1981  // - static_assert-declarations
1982  // - using-declarations,
1983  // - using-directives,
1984  // - typedef declarations and alias-declarations that do not define
1985  // classes or enumerations,
1986  if (!CheckConstexprDeclStmt(SemaRef, Dcl, cast<DeclStmt>(S), Cxx1yLoc, Kind))
1987  return false;
1988  return true;
1989 
1990  case Stmt::ReturnStmtClass:
1991  // - and exactly one return statement;
1992  if (isa<CXXConstructorDecl>(Dcl)) {
1993  // C++1y allows return statements in constexpr constructors.
1994  if (!Cxx1yLoc.isValid())
1995  Cxx1yLoc = S->getBeginLoc();
1996  return true;
1997  }
1998 
1999  ReturnStmts.push_back(S->getBeginLoc());
2000  return true;
2001 
2002  case Stmt::CompoundStmtClass: {
2003  // C++1y allows compound-statements.
2004  if (!Cxx1yLoc.isValid())
2005  Cxx1yLoc = S->getBeginLoc();
2006 
2007  CompoundStmt *CompStmt = cast<CompoundStmt>(S);
2008  for (auto *BodyIt : CompStmt->body()) {
2009  if (!CheckConstexprFunctionStmt(SemaRef, Dcl, BodyIt, ReturnStmts,
2010  Cxx1yLoc, Cxx2aLoc, Kind))
2011  return false;
2012  }
2013  return true;
2014  }
2015 
2016  case Stmt::AttributedStmtClass:
2017  if (!Cxx1yLoc.isValid())
2018  Cxx1yLoc = S->getBeginLoc();
2019  return true;
2020 
2021  case Stmt::IfStmtClass: {
2022  // C++1y allows if-statements.
2023  if (!Cxx1yLoc.isValid())
2024  Cxx1yLoc = S->getBeginLoc();
2025 
2026  IfStmt *If = cast<IfStmt>(S);
2027  if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
2028  Cxx1yLoc, Cxx2aLoc, Kind))
2029  return false;
2030  if (If->getElse() &&
2031  !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
2032  Cxx1yLoc, Cxx2aLoc, Kind))
2033  return false;
2034  return true;
2035  }
2036 
2037  case Stmt::WhileStmtClass:
2038  case Stmt::DoStmtClass:
2039  case Stmt::ForStmtClass:
2040  case Stmt::CXXForRangeStmtClass:
2041  case Stmt::ContinueStmtClass:
2042  // C++1y allows all of these. We don't allow them as extensions in C++11,
2043  // because they don't make sense without variable mutation.
2044  if (!SemaRef.getLangOpts().CPlusPlus14)
2045  break;
2046  if (!Cxx1yLoc.isValid())
2047  Cxx1yLoc = S->getBeginLoc();
2048  for (Stmt *SubStmt : S->children())
2049  if (SubStmt &&
2050  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2051  Cxx1yLoc, Cxx2aLoc, Kind))
2052  return false;
2053  return true;
2054 
2055  case Stmt::SwitchStmtClass:
2056  case Stmt::CaseStmtClass:
2057  case Stmt::DefaultStmtClass:
2058  case Stmt::BreakStmtClass:
2059  // C++1y allows switch-statements, and since they don't need variable
2060  // mutation, we can reasonably allow them in C++11 as an extension.
2061  if (!Cxx1yLoc.isValid())
2062  Cxx1yLoc = S->getBeginLoc();
2063  for (Stmt *SubStmt : S->children())
2064  if (SubStmt &&
2065  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2066  Cxx1yLoc, Cxx2aLoc, Kind))
2067  return false;
2068  return true;
2069 
2070  case Stmt::GCCAsmStmtClass:
2071  case Stmt::MSAsmStmtClass:
2072  // C++2a allows inline assembly statements.
2073  case Stmt::CXXTryStmtClass:
2074  if (Cxx2aLoc.isInvalid())
2075  Cxx2aLoc = S->getBeginLoc();
2076  for (Stmt *SubStmt : S->children()) {
2077  if (SubStmt &&
2078  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2079  Cxx1yLoc, Cxx2aLoc, Kind))
2080  return false;
2081  }
2082  return true;
2083 
2084  case Stmt::CXXCatchStmtClass:
2085  // Do not bother checking the language mode (already covered by the
2086  // try block check).
2087  if (!CheckConstexprFunctionStmt(SemaRef, Dcl,
2088  cast<CXXCatchStmt>(S)->getHandlerBlock(),
2089  ReturnStmts, Cxx1yLoc, Cxx2aLoc, Kind))
2090  return false;
2091  return true;
2092 
2093  default:
2094  if (!isa<Expr>(S))
2095  break;
2096 
2097  // C++1y allows expression-statements.
2098  if (!Cxx1yLoc.isValid())
2099  Cxx1yLoc = S->getBeginLoc();
2100  return true;
2101  }
2102 
2103  if (Kind == Sema::CheckConstexprKind::Diagnose) {
2104  SemaRef.Diag(S->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
2105  << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval();
2106  }
2107  return false;
2108 }
2109 
2110 /// Check the body for the given constexpr function declaration only contains
2111 /// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.
2112 ///
2113 /// \return true if the body is OK, false if we have found or diagnosed a
2114 /// problem.
2115 static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl,
2116  Stmt *Body,
2117  Sema::CheckConstexprKind Kind) {
2118  SmallVector<SourceLocation, 4> ReturnStmts;
2119 
2120  if (isa<CXXTryStmt>(Body)) {
2121  // C++11 [dcl.constexpr]p3:
2122  // The definition of a constexpr function shall satisfy the following
2123  // constraints: [...]
2124  // - its function-body shall be = delete, = default, or a
2125  // compound-statement
2126  //
2127  // C++11 [dcl.constexpr]p4:
2128  // In the definition of a constexpr constructor, [...]
2129  // - its function-body shall not be a function-try-block;
2130  //
2131  // This restriction is lifted in C++2a, as long as inner statements also
2132  // apply the general constexpr rules.
2133  switch (Kind) {
2135  if (!SemaRef.getLangOpts().CPlusPlus2a)
2136  return false;
2137  break;
2138 
2140  SemaRef.Diag(Body->getBeginLoc(),
2141  !SemaRef.getLangOpts().CPlusPlus2a
2142  ? diag::ext_constexpr_function_try_block_cxx2a
2143  : diag::warn_cxx17_compat_constexpr_function_try_block)
2144  << isa<CXXConstructorDecl>(Dcl);
2145  break;
2146  }
2147  }
2148 
2149  // - its function-body shall be [...] a compound-statement that contains only
2150  // [... list of cases ...]
2151  //
2152  // Note that walking the children here is enough to properly check for
2153  // CompoundStmt and CXXTryStmt body.
2154  SourceLocation Cxx1yLoc, Cxx2aLoc;
2155  for (Stmt *SubStmt : Body->children()) {
2156  if (SubStmt &&
2157  !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2158  Cxx1yLoc, Cxx2aLoc, Kind))
2159  return false;
2160  }
2161 
2163  // If this is only valid as an extension, report that we don't satisfy the
2164  // constraints of the current language.
2165  if ((Cxx2aLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus2a) ||
2166  (Cxx1yLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus17))
2167  return false;
2168  } else if (Cxx2aLoc.isValid()) {
2169  SemaRef.Diag(Cxx2aLoc,
2170  SemaRef.getLangOpts().CPlusPlus2a
2171  ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt
2172  : diag::ext_constexpr_body_invalid_stmt_cxx2a)
2173  << isa<CXXConstructorDecl>(Dcl);
2174  } else if (Cxx1yLoc.isValid()) {
2175  SemaRef.Diag(Cxx1yLoc,
2176  SemaRef.getLangOpts().CPlusPlus14
2177  ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
2178  : diag::ext_constexpr_body_invalid_stmt)
2179  << isa<CXXConstructorDecl>(Dcl);
2180  }
2181 
2182  if (const CXXConstructorDecl *Constructor
2183  = dyn_cast<CXXConstructorDecl>(Dcl)) {
2184  const CXXRecordDecl *RD = Constructor->getParent();
2185  // DR1359:
2186  // - every non-variant non-static data member and base class sub-object
2187  // shall be initialized;
2188  // DR1460:
2189  // - if the class is a union having variant members, exactly one of them
2190  // shall be initialized;
2191  if (RD->isUnion()) {
2192  if (Constructor->getNumCtorInitializers() == 0 &&
2193  RD->hasVariantMembers()) {
2194  if (Kind == Sema::CheckConstexprKind::Diagnose) {
2195  SemaRef.Diag(
2196  Dcl->getLocation(),
2197  SemaRef.getLangOpts().CPlusPlus2a
2198  ? diag::warn_cxx17_compat_constexpr_union_ctor_no_init
2199  : diag::ext_constexpr_union_ctor_no_init);
2200  } else if (!SemaRef.getLangOpts().CPlusPlus2a) {
2201  return false;
2202  }
2203  }
2204  } else if (!Constructor->isDependentContext() &&
2205  !Constructor->isDelegatingConstructor()) {
2206  assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases");
2207 
2208  // Skip detailed checking if we have enough initializers, and we would
2209  // allow at most one initializer per member.
2210  bool AnyAnonStructUnionMembers = false;
2211  unsigned Fields = 0;
2213  E = RD->field_end(); I != E; ++I, ++Fields) {
2214  if (I->isAnonymousStructOrUnion()) {
2215  AnyAnonStructUnionMembers = true;
2216  break;
2217  }
2218  }
2219  // DR1460:
2220  // - if the class is a union-like class, but is not a union, for each of
2221  // its anonymous union members having variant members, exactly one of
2222  // them shall be initialized;
2223  if (AnyAnonStructUnionMembers ||
2224  Constructor->getNumCtorInitializers() != RD->getNumBases() + Fields) {
2225  // Check initialization of non-static data members. Base classes are
2226  // always initialized so do not need to be checked. Dependent bases
2227  // might not have initializers in the member initializer list.
2228  llvm::SmallSet<Decl*, 16> Inits;
2229  for (const auto *I: Constructor->inits()) {
2230  if (FieldDecl *FD = I->getMember())
2231  Inits.insert(FD);
2232  else if (IndirectFieldDecl *ID = I->getIndirectMember())
2233  Inits.insert(ID->chain_begin(), ID->chain_end());
2234  }
2235 
2236  bool Diagnosed = false;
2237  for (auto *I : RD->fields())
2238  if (!CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed,
2239  Kind))
2240  return false;
2241  }
2242  }
2243  } else {
2244  if (ReturnStmts.empty()) {
2245  // C++1y doesn't require constexpr functions to contain a 'return'
2246  // statement. We still do, unless the return type might be void, because
2247  // otherwise if there's no return statement, the function cannot
2248  // be used in a core constant expression.
2249  bool OK = SemaRef.getLangOpts().CPlusPlus14 &&
2250  (Dcl->getReturnType()->isVoidType() ||
2251  Dcl->getReturnType()->isDependentType());
2252  switch (Kind) {
2254  SemaRef.Diag(Dcl->getLocation(),
2255  OK ? diag::warn_cxx11_compat_constexpr_body_no_return
2256  : diag::err_constexpr_body_no_return)
2257  << Dcl->isConsteval();
2258  if (!OK)
2259  return false;
2260  break;
2261 
2263  // The formal requirements don't include this rule in C++14, even
2264  // though the "must be able to produce a constant expression" rules
2265  // still imply it in some cases.
2266  if (!SemaRef.getLangOpts().CPlusPlus14)
2267  return false;
2268  break;
2269  }
2270  } else if (ReturnStmts.size() > 1) {
2271  switch (Kind) {
2273  SemaRef.Diag(
2274  ReturnStmts.back(),
2275  SemaRef.getLangOpts().CPlusPlus14
2276  ? diag::warn_cxx11_compat_constexpr_body_multiple_return
2277  : diag::ext_constexpr_body_multiple_return);
2278  for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
2279  SemaRef.Diag(ReturnStmts[I],
2280  diag::note_constexpr_body_previous_return);
2281  break;
2282 
2284  if (!SemaRef.getLangOpts().CPlusPlus14)
2285  return false;
2286  break;
2287  }
2288  }
2289  }
2290 
2291  // C++11 [dcl.constexpr]p5:
2292  // if no function argument values exist such that the function invocation
2293  // substitution would produce a constant expression, the program is
2294  // ill-formed; no diagnostic required.
2295  // C++11 [dcl.constexpr]p3:
2296  // - every constructor call and implicit conversion used in initializing the
2297  // return value shall be one of those allowed in a constant expression.
2298  // C++11 [dcl.constexpr]p4:
2299  // - every constructor involved in initializing non-static data members and
2300  // base class sub-objects shall be a constexpr constructor.
2301  //
2302  // Note that this rule is distinct from the "requirements for a constexpr
2303  // function", so is not checked in CheckValid mode.
2305  if (Kind == Sema::CheckConstexprKind::Diagnose &&
2306  !Expr::isPotentialConstantExpr(Dcl, Diags)) {
2307  SemaRef.Diag(Dcl->getLocation(),
2308  diag::ext_constexpr_function_never_constant_expr)
2309  << isa<CXXConstructorDecl>(Dcl);
2310  for (size_t I = 0, N = Diags.size(); I != N; ++I)
2311  SemaRef.Diag(Diags[I].first, Diags[I].second);
2312  // Don't return false here: we allow this for compatibility in
2313  // system headers.
2314  }
2315 
2316  return true;
2317 }
2318 
2319 /// Get the class that is directly named by the current context. This is the
2320 /// class for which an unqualified-id in this scope could name a constructor
2321 /// or destructor.
2322 ///
2323 /// If the scope specifier denotes a class, this will be that class.
2324 /// If the scope specifier is empty, this will be the class whose
2325 /// member-specification we are currently within. Otherwise, there
2326 /// is no such class.
2328  assert(getLangOpts().CPlusPlus && "No class names in C!");
2329 
2330  if (SS && SS->isInvalid())
2331  return nullptr;
2332 
2333  if (SS && SS->isNotEmpty()) {
2334  DeclContext *DC = computeDeclContext(*SS, true);
2335  return dyn_cast_or_null<CXXRecordDecl>(DC);
2336  }
2337 
2338  return dyn_cast_or_null<CXXRecordDecl>(CurContext);
2339 }
2340 
2341 /// isCurrentClassName - Determine whether the identifier II is the
2342 /// name of the class type currently being defined. In the case of
2343 /// nested classes, this will only return true if II is the name of
2344 /// the innermost class.
2346  const CXXScopeSpec *SS) {
2347  CXXRecordDecl *CurDecl = getCurrentClass(S, SS);
2348  return CurDecl && &II == CurDecl->getIdentifier();
2349 }
2350 
2351 /// Determine whether the identifier II is a typo for the name of
2352 /// the class type currently being defined. If so, update it to the identifier
2353 /// that should have been used.
2355  assert(getLangOpts().CPlusPlus && "No class names in C!");
2356 
2357  if (!getLangOpts().SpellChecking)
2358  return false;
2359 
2360  CXXRecordDecl *CurDecl;
2361  if (SS && SS->isSet() && !SS->isInvalid()) {
2362  DeclContext *DC = computeDeclContext(*SS, true);
2363  CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
2364  } else
2365  CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
2366 
2367  if (CurDecl && CurDecl->getIdentifier() && II != CurDecl->getIdentifier() &&
2368  3 * II->getName().edit_distance(CurDecl->getIdentifier()->getName())
2369  < II->getLength()) {
2370  II = CurDecl->getIdentifier();
2371  return true;
2372  }
2373 
2374  return false;
2375 }
2376 
2377 /// Determine whether the given class is a base class of the given
2378 /// class, including looking at dependent bases.
2379 static bool findCircularInheritance(const CXXRecordDecl *Class,
2380  const CXXRecordDecl *Current) {
2382 
2383  Class = Class->getCanonicalDecl();
2384  while (true) {
2385  for (const auto &I : Current->bases()) {
2386  CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl();
2387  if (!Base)
2388  continue;
2389 
2390  Base = Base->getDefinition();
2391  if (!Base)
2392  continue;
2393 
2394  if (Base->getCanonicalDecl() == Class)
2395  return true;
2396 
2397  Queue.push_back(Base);
2398  }
2399 
2400  if (Queue.empty())
2401  return false;
2402 
2403  Current = Queue.pop_back_val();
2404  }
2405 
2406  return false;
2407 }
2408 
2409 /// Check the validity of a C++ base class specifier.
2410 ///
2411 /// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
2412 /// and returns NULL otherwise.
2415  SourceRange SpecifierRange,
2416  bool Virtual, AccessSpecifier Access,
2417  TypeSourceInfo *TInfo,
2418  SourceLocation EllipsisLoc) {
2419  QualType BaseType = TInfo->getType();
2420 
2421  // C++ [class.union]p1:
2422  // A union shall not have base classes.
2423  if (Class->isUnion()) {
2424  Diag(Class->getLocation(), diag::err_base_clause_on_union)
2425  << SpecifierRange;
2426  return nullptr;
2427  }
2428 
2429  if (EllipsisLoc.isValid() &&
2431  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
2432  << TInfo->getTypeLoc().getSourceRange();
2433  EllipsisLoc = SourceLocation();
2434  }
2435 
2436  SourceLocation BaseLoc = TInfo->getTypeLoc().getBeginLoc();
2437 
2438  if (BaseType->isDependentType()) {
2439  // Make sure that we don't have circular inheritance among our dependent
2440  // bases. For non-dependent bases, the check for completeness below handles
2441  // this.
2442  if (CXXRecordDecl *BaseDecl = BaseType->getAsCXXRecordDecl()) {
2443  if (BaseDecl->getCanonicalDecl() == Class->getCanonicalDecl() ||
2444  ((BaseDecl = BaseDecl->getDefinition()) &&
2445  findCircularInheritance(Class, BaseDecl))) {
2446  Diag(BaseLoc, diag::err_circular_inheritance)
2447  << BaseType << Context.getTypeDeclType(Class);
2448 
2449  if (BaseDecl->getCanonicalDecl() != Class->getCanonicalDecl())
2450  Diag(BaseDecl->getLocation(), diag::note_previous_decl)
2451  << BaseType;
2452 
2453  return nullptr;
2454  }
2455  }
2456 
2457  return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
2458  Class->getTagKind() == TTK_Class,
2459  Access, TInfo, EllipsisLoc);
2460  }
2461 
2462  // Base specifiers must be record types.
2463  if (!BaseType->isRecordType()) {
2464  Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
2465  return nullptr;
2466  }
2467 
2468  // C++ [class.union]p1:
2469  // A union shall not be used as a base class.
2470  if (BaseType->isUnionType()) {
2471  Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
2472  return nullptr;
2473  }
2474 
2475  // For the MS ABI, propagate DLL attributes to base class templates.
2476  if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
2477  if (Attr *ClassAttr = getDLLAttr(Class)) {
2478  if (auto *BaseTemplate = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
2479  BaseType->getAsCXXRecordDecl())) {
2480  propagateDLLAttrToBaseClassTemplate(Class, ClassAttr, BaseTemplate,
2481  BaseLoc);
2482  }
2483  }
2484  }
2485 
2486  // C++ [class.derived]p2:
2487  // The class-name in a base-specifier shall not be an incompletely
2488  // defined class.
2489  if (RequireCompleteType(BaseLoc, BaseType,
2490  diag::err_incomplete_base_class, SpecifierRange)) {
2491  Class->setInvalidDecl();
2492  return nullptr;
2493  }
2494 
2495  // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
2496  RecordDecl *BaseDecl = BaseType->castAs<RecordType>()->getDecl();
2497  assert(BaseDecl && "Record type has no declaration");
2498  BaseDecl = BaseDecl->getDefinition();
2499  assert(BaseDecl && "Base type is not incomplete, but has no definition");
2500  CXXRecordDecl *CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
2501  assert(CXXBaseDecl && "Base type is not a C++ type");
2502 
2503  // Microsoft docs say:
2504  // "If a base-class has a code_seg attribute, derived classes must have the
2505  // same attribute."
2506  const auto *BaseCSA = CXXBaseDecl->getAttr<CodeSegAttr>();
2507  const auto *DerivedCSA = Class->getAttr<CodeSegAttr>();
2508  if ((DerivedCSA || BaseCSA) &&
2509  (!BaseCSA || !DerivedCSA || BaseCSA->getName() != DerivedCSA->getName())) {
2510  Diag(Class->getLocation(), diag::err_mismatched_code_seg_base);
2511  Diag(CXXBaseDecl->getLocation(), diag::note_base_class_specified_here)
2512  << CXXBaseDecl;
2513  return nullptr;
2514  }
2515 
2516  // A class which contains a flexible array member is not suitable for use as a
2517  // base class:
2518  // - If the layout determines that a base comes before another base,
2519  // the flexible array member would index into the subsequent base.
2520  // - If the layout determines that base comes before the derived class,
2521  // the flexible array member would index into the derived class.
2522  if (CXXBaseDecl->hasFlexibleArrayMember()) {
2523  Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
2524  << CXXBaseDecl->getDeclName();
2525  return nullptr;
2526  }
2527 
2528  // C++ [class]p3:
2529  // If a class is marked final and it appears as a base-type-specifier in
2530  // base-clause, the program is ill-formed.
2531  if (FinalAttr *FA = CXXBaseDecl->getAttr<FinalAttr>()) {
2532  Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
2533  << CXXBaseDecl->getDeclName()
2534  << FA->isSpelledAsSealed();
2535  Diag(CXXBaseDecl->getLocation(), diag::note_entity_declared_at)
2536  << CXXBaseDecl->getDeclName() << FA->getRange();
2537  return nullptr;
2538  }
2539 
2540  if (BaseDecl->isInvalidDecl())
2541  Class->setInvalidDecl();
2542 
2543  // Create the base specifier.
2544  return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
2545  Class->getTagKind() == TTK_Class,
2546  Access, TInfo, EllipsisLoc);
2547 }
2548 
2549 /// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
2550 /// one entry in the base class list of a class specifier, for
2551 /// example:
2552 /// class foo : public bar, virtual private baz {
2553 /// 'public bar' and 'virtual private baz' are each base-specifiers.
2554 BaseResult
2555 Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange,
2556  ParsedAttributes &Attributes,
2557  bool Virtual, AccessSpecifier Access,
2558  ParsedType basetype, SourceLocation BaseLoc,
2559  SourceLocation EllipsisLoc) {
2560  if (!classdecl)
2561  return true;
2562 
2563  AdjustDeclIfTemplate(classdecl);
2564  CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl);
2565  if (!Class)
2566  return true;
2567 
2568  // We haven't yet attached the base specifiers.
2569  Class->setIsParsingBaseSpecifiers();
2570 
2571  // We do not support any C++11 attributes on base-specifiers yet.
2572  // Diagnose any attributes we see.
2573  for (const ParsedAttr &AL : Attributes) {
2574  if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute)
2575  continue;
2576  Diag(AL.getLoc(), AL.getKind() == ParsedAttr::UnknownAttribute
2577  ? (unsigned)diag::warn_unknown_attribute_ignored
2578  : (unsigned)diag::err_base_specifier_attribute)
2579  << AL;
2580  }
2581 
2582  TypeSourceInfo *TInfo = nullptr;
2583  GetTypeFromParser(basetype, &TInfo);
2584 
2585  if (EllipsisLoc.isInvalid() &&
2586  DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo,
2587  UPPC_BaseType))
2588  return true;
2589 
2590  if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
2591  Virtual, Access, TInfo,
2592  EllipsisLoc))
2593  return BaseSpec;
2594  else
2595  Class->setInvalidDecl();
2596 
2597  return true;
2598 }
2599 
2600 /// Use small set to collect indirect bases. As this is only used
2601 /// locally, there's no need to abstract the small size parameter.
2602 typedef llvm::SmallPtrSet<QualType, 4> IndirectBaseSet;
2603 
2604 /// Recursively add the bases of Type. Don't add Type itself.
2605 static void
2606 NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set,
2607  const QualType &Type)
2608 {
2609  // Even though the incoming type is a base, it might not be
2610  // a class -- it could be a template parm, for instance.
2611  if (auto Rec = Type->getAs<RecordType>()) {
2612  auto Decl = Rec->getAsCXXRecordDecl();
2613 
2614  // Iterate over its bases.
2615  for (const auto &BaseSpec : Decl->bases()) {
2616  QualType Base = Context.getCanonicalType(BaseSpec.getType())
2617  .getUnqualifiedType();
2618  if (Set.insert(Base).second)
2619  // If we've not already seen it, recurse.
2620  NoteIndirectBases(Context, Set, Base);
2621  }
2622  }
2623 }
2624 
2625 /// Performs the actual work of attaching the given base class
2626 /// specifiers to a C++ class.
2629  if (Bases.empty())
2630  return false;
2631 
2632  // Used to keep track of which base types we have already seen, so
2633  // that we can properly diagnose redundant direct base types. Note
2634  // that the key is always the unqualified canonical type of the base
2635  // class.
2636  std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
2637 
2638  // Used to track indirect bases so we can see if a direct base is
2639  // ambiguous.
2640  IndirectBaseSet IndirectBaseTypes;
2641 
2642  // Copy non-redundant base specifiers into permanent storage.
2643  unsigned NumGoodBases = 0;
2644  bool Invalid = false;
2645  for (unsigned idx = 0; idx < Bases.size(); ++idx) {
2646  QualType NewBaseType
2647  = Context.getCanonicalType(Bases[idx]->getType());
2648  NewBaseType = NewBaseType.getLocalUnqualifiedType();
2649 
2650  CXXBaseSpecifier *&KnownBase = KnownBaseTypes[NewBaseType];
2651  if (KnownBase) {
2652  // C++ [class.mi]p3:
2653  // A class shall not be specified as a direct base class of a
2654  // derived class more than once.
2655  Diag(Bases[idx]->getBeginLoc(), diag::err_duplicate_base_class)
2656  << KnownBase->getType() << Bases[idx]->getSourceRange();
2657 
2658  // Delete the duplicate base class specifier; we're going to
2659  // overwrite its pointer later.
2660  Context.Deallocate(Bases[idx]);
2661 
2662  Invalid = true;
2663  } else {
2664  // Okay, add this new base class.
2665  KnownBase = Bases[idx];
2666  Bases[NumGoodBases++] = Bases[idx];
2667 
2668  // Note this base's direct & indirect bases, if there could be ambiguity.
2669  if (Bases.size() > 1)
2670  NoteIndirectBases(Context, IndirectBaseTypes, NewBaseType);
2671 
2672  if (const RecordType *Record = NewBaseType->getAs<RecordType>()) {
2673  const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
2674  if (Class->isInterface() &&
2675  (!RD->isInterfaceLike() ||
2676  KnownBase->getAccessSpecifier() != AS_public)) {
2677  // The Microsoft extension __interface does not permit bases that
2678  // are not themselves public interfaces.
2679  Diag(KnownBase->getBeginLoc(), diag::err_invalid_base_in_interface)
2680  << getRecordDiagFromTagKind(RD->getTagKind()) << RD
2681  << RD->getSourceRange();
2682  Invalid = true;
2683  }
2684  if (RD->hasAttr<WeakAttr>())
2685  Class->addAttr(WeakAttr::CreateImplicit(Context));
2686  }
2687  }
2688  }
2689 
2690  // Attach the remaining base class specifiers to the derived class.
2691  Class->setBases(Bases.data(), NumGoodBases);
2692 
2693  // Check that the only base classes that are duplicate are virtual.
2694  for (unsigned idx = 0; idx < NumGoodBases; ++idx) {
2695  // Check whether this direct base is inaccessible due to ambiguity.
2696  QualType BaseType = Bases[idx]->getType();
2697 
2698  // Skip all dependent types in templates being used as base specifiers.
2699  // Checks below assume that the base specifier is a CXXRecord.
2700  if (BaseType->isDependentType())
2701  continue;
2702 
2703  CanQualType CanonicalBase = Context.getCanonicalType(BaseType)
2704  .getUnqualifiedType();
2705 
2706  if (IndirectBaseTypes.count(CanonicalBase)) {
2707  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2708  /*DetectVirtual=*/true);
2709  bool found
2710  = Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
2711  assert(found);
2712  (void)found;
2713 
2714  if (Paths.isAmbiguous(CanonicalBase))
2715  Diag(Bases[idx]->getBeginLoc(), diag::warn_inaccessible_base_class)
2716  << BaseType << getAmbiguousPathsDisplayString(Paths)
2717  << Bases[idx]->getSourceRange();
2718  else
2719  assert(Bases[idx]->isVirtual());
2720  }
2721 
2722  // Delete the base class specifier, since its data has been copied
2723  // into the CXXRecordDecl.
2724  Context.Deallocate(Bases[idx]);
2725  }
2726 
2727  return Invalid;
2728 }
2729 
2730 /// ActOnBaseSpecifiers - Attach the given base specifiers to the
2731 /// class, after checking whether there are any duplicate base
2732 /// classes.
2733 void Sema::ActOnBaseSpecifiers(Decl *ClassDecl,
2735  if (!ClassDecl || Bases.empty())
2736  return;
2737 
2738  AdjustDeclIfTemplate(ClassDecl);
2739  AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), Bases);
2740 }
2741 
2742 /// Determine whether the type \p Derived is a C++ class that is
2743 /// derived from the type \p Base.
2745  if (!getLangOpts().CPlusPlus)
2746  return false;
2747 
2748  CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
2749  if (!DerivedRD)
2750  return false;
2751 
2752  CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
2753  if (!BaseRD)
2754  return false;
2755 
2756  // If either the base or the derived type is invalid, don't try to
2757  // check whether one is derived from the other.
2758  if (BaseRD->isInvalidDecl() || DerivedRD->isInvalidDecl())
2759  return false;
2760 
2761  // FIXME: In a modules build, do we need the entire path to be visible for us
2762  // to be able to use the inheritance relationship?
2763  if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
2764  return false;
2765 
2766  return DerivedRD->isDerivedFrom(BaseRD);
2767 }
2768 
2769 /// Determine whether the type \p Derived is a C++ class that is
2770 /// derived from the type \p Base.
2772  CXXBasePaths &Paths) {
2773  if (!getLangOpts().CPlusPlus)
2774  return false;
2775 
2776  CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
2777  if (!DerivedRD)
2778  return false;
2779 
2780  CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
2781  if (!BaseRD)
2782  return false;
2783 
2784  if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
2785  return false;
2786 
2787  return DerivedRD->isDerivedFrom(BaseRD, Paths);
2788 }
2789 
2790 static void BuildBasePathArray(const CXXBasePath &Path,
2791  CXXCastPath &BasePathArray) {
2792  // We first go backward and check if we have a virtual base.
2793  // FIXME: It would be better if CXXBasePath had the base specifier for
2794  // the nearest virtual base.
2795  unsigned Start = 0;
2796  for (unsigned I = Path.size(); I != 0; --I) {
2797  if (Path[I - 1].Base->isVirtual()) {
2798  Start = I - 1;
2799  break;
2800  }
2801  }
2802 
2803  // Now add all bases.
2804  for (unsigned I = Start, E = Path.size(); I != E; ++I)
2805  BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
2806 }
2807 
2808 
2810  CXXCastPath &BasePathArray) {
2811  assert(BasePathArray.empty() && "Base path array must be empty!");
2812  assert(Paths.isRecordingPaths() && "Must record paths!");
2813  return ::BuildBasePathArray(Paths.front(), BasePathArray);
2814 }
2815 /// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
2816 /// conversion (where Derived and Base are class types) is
2817 /// well-formed, meaning that the conversion is unambiguous (and
2818 /// that all of the base classes are accessible). Returns true
2819 /// and emits a diagnostic if the code is ill-formed, returns false
2820 /// otherwise. Loc is the location where this routine should point to
2821 /// if there is an error, and Range is the source range to highlight
2822 /// if there is an error.
2823 ///
2824 /// If either InaccessibleBaseID or AmbigiousBaseConvID are 0, then the
2825 /// diagnostic for the respective type of error will be suppressed, but the
2826 /// check for ill-formed code will still be performed.
2827 bool
2829  unsigned InaccessibleBaseID,
2830  unsigned AmbigiousBaseConvID,
2831  SourceLocation Loc, SourceRange Range,
2832  DeclarationName Name,
2833  CXXCastPath *BasePath,
2834  bool IgnoreAccess) {
2835  // First, determine whether the path from Derived to Base is
2836  // ambiguous. This is slightly more expensive than checking whether
2837  // the Derived to Base conversion exists, because here we need to
2838  // explore multiple paths to determine if there is an ambiguity.
2839  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2840  /*DetectVirtual=*/false);
2841  bool DerivationOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
2842  if (!DerivationOkay)
2843  return true;
2844 
2845  const CXXBasePath *Path = nullptr;
2846  if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType()))
2847  Path = &Paths.front();
2848 
2849  // For MSVC compatibility, check if Derived directly inherits from Base. Clang
2850  // warns about this hierarchy under -Winaccessible-base, but MSVC allows the
2851  // user to access such bases.
2852  if (!Path && getLangOpts().MSVCCompat) {
2853  for (const CXXBasePath &PossiblePath : Paths) {
2854  if (PossiblePath.size() == 1) {
2855  Path = &PossiblePath;
2856  if (AmbigiousBaseConvID)
2857  Diag(Loc, diag::ext_ms_ambiguous_direct_base)
2858  << Base << Derived << Range;
2859  break;
2860  }
2861  }
2862  }
2863 
2864  if (Path) {
2865  if (!IgnoreAccess) {
2866  // Check that the base class can be accessed.
2867  switch (
2868  CheckBaseClassAccess(Loc, Base, Derived, *Path, InaccessibleBaseID)) {
2869  case AR_inaccessible:
2870  return true;
2871  case AR_accessible:
2872  case AR_dependent:
2873  case AR_delayed:
2874  break;
2875  }
2876  }
2877 
2878  // Build a base path if necessary.
2879  if (BasePath)
2880  ::BuildBasePathArray(*Path, *BasePath);
2881  return false;
2882  }
2883 
2884  if (AmbigiousBaseConvID) {
2885  // We know that the derived-to-base conversion is ambiguous, and
2886  // we're going to produce a diagnostic. Perform the derived-to-base
2887  // search just one more time to compute all of the possible paths so
2888  // that we can print them out. This is more expensive than any of
2889  // the previous derived-to-base checks we've done, but at this point
2890  // performance isn't as much of an issue.
2891  Paths.clear();
2892  Paths.setRecordingPaths(true);
2893  bool StillOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
2894  assert(StillOkay && "Can only be used with a derived-to-base conversion");
2895  (void)StillOkay;
2896 
2897  // Build up a textual representation of the ambiguous paths, e.g.,
2898  // D -> B -> A, that will be used to illustrate the ambiguous
2899  // conversions in the diagnostic. We only print one of the paths
2900  // to each base class subobject.
2901  std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
2902 
2903  Diag(Loc, AmbigiousBaseConvID)
2904  << Derived << Base << PathDisplayStr << Range << Name;
2905  }
2906  return true;
2907 }
2908 
2909 bool
2911  SourceLocation Loc, SourceRange Range,
2912  CXXCastPath *BasePath,
2913  bool IgnoreAccess) {
2914  return CheckDerivedToBaseConversion(
2915  Derived, Base, diag::err_upcast_to_inaccessible_base,
2916  diag::err_ambiguous_derived_to_base_conv, Loc, Range, DeclarationName(),
2917  BasePath, IgnoreAccess);
2918 }
2919 
2920 
2921 /// Builds a string representing ambiguous paths from a
2922 /// specific derived class to different subobjects of the same base
2923 /// class.
2924 ///
2925 /// This function builds a string that can be used in error messages
2926 /// to show the different paths that one can take through the
2927 /// inheritance hierarchy to go from the derived class to different
2928 /// subobjects of a base class. The result looks something like this:
2929 /// @code
2930 /// struct D -> struct B -> struct A
2931 /// struct D -> struct C -> struct A
2932 /// @endcode
2934  std::string PathDisplayStr;
2935  std::set<unsigned> DisplayedPaths;
2936  for (CXXBasePaths::paths_iterator Path = Paths.begin();
2937  Path != Paths.end(); ++Path) {
2938  if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
2939  // We haven't displayed a path to this particular base
2940  // class subobject yet.
2941  PathDisplayStr += "\n ";
2942  PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
2943  for (CXXBasePath::const_iterator Element = Path->begin();
2944  Element != Path->end(); ++Element)
2945  PathDisplayStr += " -> " + Element->Base->getType().getAsString();
2946  }
2947  }
2948 
2949  return PathDisplayStr;
2950 }
2951 
2952 //===----------------------------------------------------------------------===//
2953 // C++ class member Handling
2954 //===----------------------------------------------------------------------===//
2955 
2956 /// ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
2959  const ParsedAttributesView &Attrs) {
2960  assert(Access != AS_none && "Invalid kind for syntactic access specifier!");
2961  AccessSpecDecl *ASDecl = AccessSpecDecl::Create(Context, Access, CurContext,
2962  ASLoc, ColonLoc);
2963  CurContext->addHiddenDecl(ASDecl);
2964  return ProcessAccessDeclAttributeList(ASDecl, Attrs);
2965 }
2966 
2967 /// CheckOverrideControl - Check C++11 override control semantics.
2969  if (D->isInvalidDecl())
2970  return;
2971 
2972  // We only care about "override" and "final" declarations.
2973  if (!D->hasAttr<OverrideAttr>() && !D->hasAttr<FinalAttr>())
2974  return;
2975 
2976  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
2977 
2978  // We can't check dependent instance methods.
2979  if (MD && MD->isInstance() &&
2980  (MD->getParent()->hasAnyDependentBases() ||
2981  MD->getType()->isDependentType()))
2982  return;
2983 
2984  if (MD && !MD->isVirtual()) {
2985  // If we have a non-virtual method, check if if hides a virtual method.
2986  // (In that case, it's most likely the method has the wrong type.)
2987  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
2988  FindHiddenVirtualMethods(MD, OverloadedMethods);
2989 
2990  if (!OverloadedMethods.empty()) {
2991  if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
2992  Diag(OA->getLocation(),
2993  diag::override_keyword_hides_virtual_member_function)
2994  << "override" << (OverloadedMethods.size() > 1);
2995  } else if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
2996  Diag(FA->getLocation(),
2997  diag::override_keyword_hides_virtual_member_function)
2998  << (FA->isSpelledAsSealed() ? "sealed" : "final")
2999  << (OverloadedMethods.size() > 1);
3000  }
3001  NoteHiddenVirtualMethods(MD, OverloadedMethods);
3002  MD->setInvalidDecl();
3003  return;
3004  }
3005  // Fall through into the general case diagnostic.
3006  // FIXME: We might want to attempt typo correction here.
3007  }
3008 
3009  if (!MD || !MD->isVirtual()) {
3010  if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
3011  Diag(OA->getLocation(),
3012  diag::override_keyword_only_allowed_on_virtual_member_functions)
3013  << "override" << FixItHint::CreateRemoval(OA->getLocation());
3014  D->dropAttr<OverrideAttr>();
3015  }
3016  if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
3017  Diag(FA->getLocation(),
3018  diag::override_keyword_only_allowed_on_virtual_member_functions)
3019  << (FA->isSpelledAsSealed() ? "sealed" : "final")
3020  << FixItHint::CreateRemoval(FA->getLocation());
3021  D->dropAttr<FinalAttr>();
3022  }
3023  return;
3024  }
3025 
3026  // C++11 [class.virtual]p5:
3027  // If a function is marked with the virt-specifier override and
3028  // does not override a member function of a base class, the program is
3029  // ill-formed.
3030  bool HasOverriddenMethods = MD->size_overridden_methods() != 0;
3031  if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)
3032  Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding)
3033  << MD->getDeclName();
3034 }
3035 
3037  if (D->isInvalidDecl() || D->hasAttr<OverrideAttr>())
3038  return;
3039  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
3040  if (!MD || MD->isImplicit() || MD->hasAttr<FinalAttr>())
3041  return;
3042 
3043  SourceLocation Loc = MD->getLocation();
3044  SourceLocation SpellingLoc = Loc;
3045  if (getSourceManager().isMacroArgExpansion(Loc))
3046  SpellingLoc = getSourceManager().getImmediateExpansionRange(Loc).getBegin();
3047  SpellingLoc = getSourceManager().getSpellingLoc(SpellingLoc);
3048  if (SpellingLoc.isValid() && getSourceManager().isInSystemHeader(SpellingLoc))
3049  return;
3050 
3051  if (MD->size_overridden_methods() > 0) {
3052  unsigned DiagID = isa<CXXDestructorDecl>(MD)
3053  ? diag::warn_destructor_marked_not_override_overriding
3054  : diag::warn_function_marked_not_override_overriding;
3055  Diag(MD->getLocation(), DiagID) << MD->getDeclName();
3056  const CXXMethodDecl *OMD = *MD->begin_overridden_methods();
3057  Diag(OMD->getLocation(), diag::note_overridden_virtual_function);
3058  }
3059 }
3060 
3061 /// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member
3062 /// function overrides a virtual member function marked 'final', according to
3063 /// C++11 [class.virtual]p4.
3065  const CXXMethodDecl *Old) {
3066  FinalAttr *FA = Old->getAttr<FinalAttr>();
3067  if (!FA)
3068  return false;
3069 
3070  Diag(New->getLocation(), diag::err_final_function_overridden)
3071  << New->getDeclName()
3072  << FA->isSpelledAsSealed();
3073  Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3074  return true;
3075 }
3076 
3077 static bool InitializationHasSideEffects(const FieldDecl &FD) {
3078  const Type *T = FD.getType()->getBaseElementTypeUnsafe();
3079  // FIXME: Destruction of ObjC lifetime types has side-effects.
3080  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3081  return !RD->isCompleteDefinition() ||
3082  !RD->hasTrivialDefaultConstructor() ||
3083  !RD->hasTrivialDestructor();
3084  return false;
3085 }
3086 
3089  llvm::find_if(list, [](const ParsedAttr &AL) {
3090  return AL.isDeclspecPropertyAttribute();
3091  });
3092  if (Itr != list.end())
3093  return &*Itr;
3094  return nullptr;
3095 }
3096 
3097 // Check if there is a field shadowing.
3098 void Sema::CheckShadowInheritedFields(const SourceLocation &Loc,
3099  DeclarationName FieldName,
3100  const CXXRecordDecl *RD,
3101  bool DeclIsField) {
3102  if (Diags.isIgnored(diag::warn_shadow_field, Loc))
3103  return;
3104 
3105  // To record a shadowed field in a base
3106  std::map<CXXRecordDecl*, NamedDecl*> Bases;
3107  auto FieldShadowed = [&](const CXXBaseSpecifier *Specifier,
3108  CXXBasePath &Path) {
3109  const auto Base = Specifier->getType()->getAsCXXRecordDecl();
3110  // Record an ambiguous path directly
3111  if (Bases.find(Base) != Bases.end())
3112  return true;
3113  for (const auto Field : Base->lookup(FieldName)) {
3114  if ((isa<FieldDecl>(Field) || isa<IndirectFieldDecl>(Field)) &&
3115  Field->getAccess() != AS_private) {
3116  assert(Field->getAccess() != AS_none);
3117  assert(Bases.find(Base) == Bases.end());
3118  Bases[Base] = Field;
3119  return true;
3120  }
3121  }
3122  return false;
3123  };
3124 
3125  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3126  /*DetectVirtual=*/true);
3127  if (!RD->lookupInBases(FieldShadowed, Paths))
3128  return;
3129 
3130  for (const auto &P : Paths) {
3131  auto Base = P.back().Base->getType()->getAsCXXRecordDecl();
3132  auto It = Bases.find(Base);
3133  // Skip duplicated bases
3134  if (It == Bases.end())
3135  continue;
3136  auto BaseField = It->second;
3137  assert(BaseField->getAccess() != AS_private);
3138  if (AS_none !=
3139  CXXRecordDecl::MergeAccess(P.Access, BaseField->getAccess())) {
3140  Diag(Loc, diag::warn_shadow_field)
3141  << FieldName << RD << Base << DeclIsField;
3142  Diag(BaseField->getLocation(), diag::note_shadow_field);
3143  Bases.erase(It);
3144  }
3145  }
3146 }
3147 
3148 /// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
3149 /// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
3150 /// bitfield width if there is one, 'InitExpr' specifies the initializer if
3151 /// one has been parsed, and 'InitStyle' is set if an in-class initializer is
3152 /// present (but parsing it has been deferred).
3153 NamedDecl *
3155  MultiTemplateParamsArg TemplateParameterLists,
3156  Expr *BW, const VirtSpecifiers &VS,
3157  InClassInitStyle InitStyle) {
3158  const DeclSpec &DS = D.getDeclSpec();
3159  DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
3160  DeclarationName Name = NameInfo.getName();
3161  SourceLocation Loc = NameInfo.getLoc();
3162 
3163  // For anonymous bitfields, the location should point to the type.
3164  if (Loc.isInvalid())
3165  Loc = D.getBeginLoc();
3166 
3167  Expr *BitWidth = static_cast<Expr*>(BW);
3168 
3169  assert(isa<CXXRecordDecl>(CurContext));
3170  assert(!DS.isFriendSpecified());
3171 
3172  bool isFunc = D.isDeclarationOfFunction();
3173  const ParsedAttr *MSPropertyAttr =
3175 
3176  if (cast<CXXRecordDecl>(CurContext)->isInterface()) {
3177  // The Microsoft extension __interface only permits public member functions
3178  // and prohibits constructors, destructors, operators, non-public member
3179  // functions, static methods and data members.
3180  unsigned InvalidDecl;
3181  bool ShowDeclName = true;
3182  if (!isFunc &&
3183  (DS.getStorageClassSpec() == DeclSpec::SCS_typedef || MSPropertyAttr))
3184  InvalidDecl = 0;
3185  else if (!isFunc)
3186  InvalidDecl = 1;
3187  else if (AS != AS_public)
3188  InvalidDecl = 2;
3189  else if (DS.getStorageClassSpec() == DeclSpec::SCS_static)
3190  InvalidDecl = 3;
3191  else switch (Name.getNameKind()) {
3193  InvalidDecl = 4;
3194  ShowDeclName = false;
3195  break;
3196 
3198  InvalidDecl = 5;
3199  ShowDeclName = false;
3200  break;
3201 
3204  InvalidDecl = 6;
3205  break;
3206 
3207  default:
3208  InvalidDecl = 0;
3209  break;
3210  }
3211 
3212  if (InvalidDecl) {
3213  if (ShowDeclName)
3214  Diag(Loc, diag::err_invalid_member_in_interface)
3215  << (InvalidDecl-1) << Name;
3216  else
3217  Diag(Loc, diag::err_invalid_member_in_interface)
3218  << (InvalidDecl-1) << "";
3219  return nullptr;
3220  }
3221  }
3222 
3223  // C++ 9.2p6: A member shall not be declared to have automatic storage
3224  // duration (auto, register) or with the extern storage-class-specifier.
3225  // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
3226  // data members and cannot be applied to names declared const or static,
3227  // and cannot be applied to reference members.
3228  switch (DS.getStorageClassSpec()) {
3230  case DeclSpec::SCS_typedef:
3231  case DeclSpec::SCS_static:
3232  break;
3233  case DeclSpec::SCS_mutable:
3234  if (isFunc) {
3235  Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
3236 
3237  // FIXME: It would be nicer if the keyword was ignored only for this
3238  // declarator. Otherwise we could get follow-up errors.
3240  }
3241  break;
3242  default:
3244  diag::err_storageclass_invalid_for_member);
3246  break;
3247  }
3248 
3249  bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
3251  !isFunc);
3252 
3253  if (DS.hasConstexprSpecifier() && isInstField) {
3255  Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr_member);
3256  SourceLocation ConstexprLoc = DS.getConstexprSpecLoc();
3257  if (InitStyle == ICIS_NoInit) {
3258  B << 0 << 0;
3260  B << FixItHint::CreateRemoval(ConstexprLoc);
3261  else {
3262  B << FixItHint::CreateReplacement(ConstexprLoc, "const");
3264  const char *PrevSpec;
3265  unsigned DiagID;
3266  bool Failed = D.getMutableDeclSpec().SetTypeQual(
3267  DeclSpec::TQ_const, ConstexprLoc, PrevSpec, DiagID, getLangOpts());
3268  (void)Failed;
3269  assert(!Failed && "Making a constexpr member const shouldn't fail");
3270  }
3271  } else {
3272  B << 1;
3273  const char *PrevSpec;
3274  unsigned DiagID;
3276  *this, DeclSpec::SCS_static, ConstexprLoc, PrevSpec, DiagID,
3277  Context.getPrintingPolicy())) {
3278  assert(DS.getStorageClassSpec() == DeclSpec::SCS_mutable &&
3279  "This is the only DeclSpec that should fail to be applied");
3280  B << 1;
3281  } else {
3282  B << 0 << FixItHint::CreateInsertion(ConstexprLoc, "static ");
3283  isInstField = false;
3284  }
3285  }
3286  }
3287 
3288  NamedDecl *Member;
3289  if (isInstField) {
3290  CXXScopeSpec &SS = D.getCXXScopeSpec();
3291 
3292  // Data members must have identifiers for names.
3293  if (!Name.isIdentifier()) {
3294  Diag(Loc, diag::err_bad_variable_name)
3295  << Name;
3296  return nullptr;
3297  }
3298 
3299  IdentifierInfo *II = Name.getAsIdentifierInfo();
3300 
3301  // Member field could not be with "template" keyword.
3302  // So TemplateParameterLists should be empty in this case.
3303  if (TemplateParameterLists.size()) {
3304  TemplateParameterList* TemplateParams = TemplateParameterLists[0];
3305  if (TemplateParams->size()) {
3306  // There is no such thing as a member field template.
3307  Diag(D.getIdentifierLoc(), diag::err_template_member)
3308  << II
3309  << SourceRange(TemplateParams->getTemplateLoc(),
3310  TemplateParams->getRAngleLoc());
3311  } else {
3312  // There is an extraneous 'template<>' for this member.
3313  Diag(TemplateParams->getTemplateLoc(),
3314  diag::err_template_member_noparams)
3315  << II
3316  << SourceRange(TemplateParams->getTemplateLoc(),
3317  TemplateParams->getRAngleLoc());
3318  }
3319  return nullptr;
3320  }
3321 
3322  if (SS.isSet() && !SS.isInvalid()) {
3323  // The user provided a superfluous scope specifier inside a class
3324  // definition:
3325  //
3326  // class X {
3327  // int X::member;
3328  // };
3329  if (DeclContext *DC = computeDeclContext(SS, false))
3330  diagnoseQualifiedDeclaration(SS, DC, Name, D.getIdentifierLoc(),
3331  D.getName().getKind() ==
3333  else
3334  Diag(D.getIdentifierLoc(), diag::err_member_qualification)
3335  << Name << SS.getRange();
3336 
3337  SS.clear();
3338  }
3339 
3340  if (MSPropertyAttr) {
3341  Member = HandleMSProperty(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3342  BitWidth, InitStyle, AS, *MSPropertyAttr);
3343  if (!Member)
3344  return nullptr;
3345  isInstField = false;
3346  } else {
3347  Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3348  BitWidth, InitStyle, AS);
3349  if (!Member)
3350  return nullptr;
3351  }
3352 
3353  CheckShadowInheritedFields(Loc, Name, cast<CXXRecordDecl>(CurContext));
3354  } else {
3355  Member = HandleDeclarator(S, D, TemplateParameterLists);
3356  if (!Member)
3357  return nullptr;
3358 
3359  // Non-instance-fields can't have a bitfield.
3360  if (BitWidth) {
3361  if (Member->isInvalidDecl()) {
3362  // don't emit another diagnostic.
3363  } else if (isa<VarDecl>(Member) || isa<VarTemplateDecl>(Member)) {
3364  // C++ 9.6p3: A bit-field shall not be a static member.
3365  // "static member 'A' cannot be a bit-field"
3366  Diag(Loc, diag::err_static_not_bitfield)
3367  << Name << BitWidth->getSourceRange();
3368  } else if (isa<TypedefDecl>(Member)) {
3369  // "typedef member 'x' cannot be a bit-field"
3370  Diag(Loc, diag::err_typedef_not_bitfield)
3371  << Name << BitWidth->getSourceRange();
3372  } else {
3373  // A function typedef ("typedef int f(); f a;").
3374  // C++ 9.6p3: A bit-field shall have integral or enumeration type.
3375  Diag(Loc, diag::err_not_integral_type_bitfield)
3376  << Name << cast<ValueDecl>(Member)->getType()
3377  << BitWidth->getSourceRange();
3378  }
3379 
3380  BitWidth = nullptr;
3381  Member->setInvalidDecl();
3382  }
3383 
3384  NamedDecl *NonTemplateMember = Member;
3385  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
3386  NonTemplateMember = FunTmpl->getTemplatedDecl();
3387  else if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(Member))
3388  NonTemplateMember = VarTmpl->getTemplatedDecl();
3389 
3390  Member->setAccess(AS);
3391 
3392  // If we have declared a member function template or static data member
3393  // template, set the access of the templated declaration as well.
3394  if (NonTemplateMember != Member)
3395  NonTemplateMember->setAccess(AS);
3396 
3397  // C++ [temp.deduct.guide]p3:
3398  // A deduction guide [...] for a member class template [shall be
3399  // declared] with the same access [as the template].
3400  if (auto *DG = dyn_cast<CXXDeductionGuideDecl>(NonTemplateMember)) {
3401  auto *TD = DG->getDeducedTemplate();
3402  // Access specifiers are only meaningful if both the template and the
3403  // deduction guide are from the same scope.
3404  if (AS != TD->getAccess() &&
3405  TD->getDeclContext()->getRedeclContext()->Equals(
3406  DG->getDeclContext()->getRedeclContext())) {
3407  Diag(DG->getBeginLoc(), diag::err_deduction_guide_wrong_access);
3408  Diag(TD->getBeginLoc(), diag::note_deduction_guide_template_access)
3409  << TD->getAccess();
3410  const AccessSpecDecl *LastAccessSpec = nullptr;
3411  for (const auto *D : cast<CXXRecordDecl>(CurContext)->decls()) {
3412  if (const auto *AccessSpec = dyn_cast<AccessSpecDecl>(D))
3413  LastAccessSpec = AccessSpec;
3414  }
3415  assert(LastAccessSpec && "differing access with no access specifier");
3416  Diag(LastAccessSpec->getBeginLoc(), diag::note_deduction_guide_access)
3417  << AS;
3418  }
3419  }
3420  }
3421 
3422  if (VS.isOverrideSpecified())
3423  Member->addAttr(OverrideAttr::Create(Context, VS.getOverrideLoc(),
3425  if (VS.isFinalSpecified())
3426  Member->addAttr(FinalAttr::Create(
3428  static_cast<FinalAttr::Spelling>(VS.isFinalSpelledSealed())));
3429 
3430  if (VS.getLastLocation().isValid()) {
3431  // Update the end location of a method that has a virt-specifiers.
3432  if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member))
3433  MD->setRangeEnd(VS.getLastLocation());
3434  }
3435 
3436  CheckOverrideControl(Member);
3437 
3438  assert((Name || isInstField) && "No identifier for non-field ?");
3439 
3440  if (isInstField) {
3441  FieldDecl *FD = cast<FieldDecl>(Member);
3442  FieldCollector->Add(FD);
3443 
3444  if (!Diags.isIgnored(diag::warn_unused_private_field, FD->getLocation())) {
3445  // Remember all explicit private FieldDecls that have a name, no side
3446  // effects and are not part of a dependent type declaration.
3447  if (!FD->isImplicit() && FD->getDeclName() &&
3448  FD->getAccess() == AS_private &&
3449  !FD->hasAttr<UnusedAttr>() &&
3450  !FD->getParent()->isDependentContext() &&
3452  UnusedPrivateFields.insert(FD);
3453  }
3454  }
3455 
3456  return Member;
3457 }
3458 
3459 namespace {
3460  class UninitializedFieldVisitor
3461  : public EvaluatedExprVisitor<UninitializedFieldVisitor> {
3462  Sema &S;
3463  // List of Decls to generate a warning on. Also remove Decls that become
3464  // initialized.
3465  llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
3466  // List of base classes of the record. Classes are removed after their
3467  // initializers.
3468  llvm::SmallPtrSetImpl<QualType> &BaseClasses;
3469  // Vector of decls to be removed from the Decl set prior to visiting the
3470  // nodes. These Decls may have been initialized in the prior initializer.
3471  llvm::SmallVector<ValueDecl*, 4> DeclsToRemove;
3472  // If non-null, add a note to the warning pointing back to the constructor.
3473  const CXXConstructorDecl *Constructor;
3474  // Variables to hold state when processing an initializer list. When
3475  // InitList is true, special case initialization of FieldDecls matching
3476  // InitListFieldDecl.
3477  bool InitList;
3478  FieldDecl *InitListFieldDecl;
3479  llvm::SmallVector<unsigned, 4> InitFieldIndex;
3480 
3481  public:
3483  UninitializedFieldVisitor(Sema &S,
3484  llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
3485  llvm::SmallPtrSetImpl<QualType> &BaseClasses)
3486  : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
3487  Constructor(nullptr), InitList(false), InitListFieldDecl(nullptr) {}
3488 
3489  // Returns true if the use of ME is not an uninitialized use.
3490  bool IsInitListMemberExprInitialized(MemberExpr *ME,
3491  bool CheckReferenceOnly) {
3493  bool ReferenceField = false;
3494  while (ME) {
3495  FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
3496  if (!FD)
3497  return false;
3498  Fields.push_back(FD);
3499  if (FD->getType()->isReferenceType())
3500  ReferenceField = true;
3501  ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParenImpCasts());
3502  }
3503 
3504  // Binding a reference to an uninitialized field is not an
3505  // uninitialized use.
3506  if (CheckReferenceOnly && !ReferenceField)
3507  return true;
3508 
3509  llvm::SmallVector<unsigned, 4> UsedFieldIndex;
3510  // Discard the first field since it is the field decl that is being
3511  // initialized.
3512  for (auto I = Fields.rbegin() + 1, E = Fields.rend(); I != E; ++I) {
3513  UsedFieldIndex.push_back((*I)->getFieldIndex());
3514  }
3515 
3516  for (auto UsedIter = UsedFieldIndex.begin(),
3517  UsedEnd = UsedFieldIndex.end(),
3518  OrigIter = InitFieldIndex.begin(),
3519  OrigEnd = InitFieldIndex.end();
3520  UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
3521  if (*UsedIter < *OrigIter)
3522  return true;
3523  if (*UsedIter > *OrigIter)
3524  break;
3525  }
3526 
3527  return false;
3528  }
3529 
3530  void HandleMemberExpr(MemberExpr *ME, bool CheckReferenceOnly,
3531  bool AddressOf) {
3532  if (isa<EnumConstantDecl>(ME->getMemberDecl()))
3533  return;
3534 
3535  // FieldME is the inner-most MemberExpr that is not an anonymous struct
3536  // or union.
3537  MemberExpr *FieldME = ME;
3538 
3539  bool AllPODFields = FieldME->getType().isPODType(S.Context);
3540 
3541  Expr *Base = ME;
3542  while (MemberExpr *SubME =
3543  dyn_cast<MemberExpr>(Base->IgnoreParenImpCasts())) {
3544 
3545  if (isa<VarDecl>(SubME->getMemberDecl()))
3546  return;
3547 
3548  if (FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
3549  if (!FD->isAnonymousStructOrUnion())
3550  FieldME = SubME;
3551 
3552  if (!FieldME->getType().isPODType(S.Context))
3553  AllPODFields = false;
3554 
3555  Base = SubME->getBase();
3556  }
3557 
3558  if (!isa<CXXThisExpr>(Base->IgnoreParenImpCasts()))
3559  return;
3560 
3561  if (AddressOf && AllPODFields)
3562  return;
3563 
3564  ValueDecl* FoundVD = FieldME->getMemberDecl();
3565 
3566  if (ImplicitCastExpr *BaseCast = dyn_cast<ImplicitCastExpr>(Base)) {
3567  while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
3568  BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
3569  }
3570 
3571  if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
3572  QualType T = BaseCast->getType();
3573  if (T->isPointerType() &&
3574  BaseClasses.count(T->getPointeeType())) {
3575  S.Diag(FieldME->getExprLoc(), diag::warn_base_class_is_uninit)
3576  << T->getPointeeType() << FoundVD;
3577  }
3578  }
3579  }
3580 
3581  if (!Decls.count(FoundVD))
3582  return;
3583 
3584  const bool IsReference = FoundVD->getType()->isReferenceType();
3585 
3586  if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
3587  // Special checking for initializer lists.
3588  if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
3589  return;
3590  }
3591  } else {
3592  // Prevent double warnings on use of unbounded references.
3593  if (CheckReferenceOnly && !IsReference)
3594  return;
3595  }
3596 
3597  unsigned diag = IsReference
3598  ? diag::warn_reference_field_is_uninit
3599  : diag::warn_field_is_uninit;
3600  S.Diag(FieldME->getExprLoc(), diag) << FoundVD;
3601  if (Constructor)
3602  S.Diag(Constructor->getLocation(),
3603  diag::note_uninit_in_this_constructor)
3604  << (Constructor->isDefaultConstructor() && Constructor->isImplicit());
3605 
3606  }
3607 
3608  void HandleValue(Expr *E, bool AddressOf) {
3609  E = E->IgnoreParens();
3610 
3611  if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
3612  HandleMemberExpr(ME, false /*CheckReferenceOnly*/,
3613  AddressOf /*AddressOf*/);
3614  return;
3615  }
3616 
3617  if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
3618  Visit(CO->getCond());
3619  HandleValue(CO->getTrueExpr(), AddressOf);
3620  HandleValue(CO->getFalseExpr(), AddressOf);
3621  return;
3622  }
3623 
3624  if (BinaryConditionalOperator *BCO =
3625  dyn_cast<BinaryConditionalOperator>(E)) {
3626  Visit(BCO->getCond());
3627  HandleValue(BCO->getFalseExpr(), AddressOf);
3628  return;
3629  }
3630 
3631  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
3632  HandleValue(OVE->getSourceExpr(), AddressOf);
3633  return;
3634  }
3635 
3636  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
3637  switch (BO->getOpcode()) {
3638  default:
3639  break;
3640  case(BO_PtrMemD):
3641  case(BO_PtrMemI):
3642  HandleValue(BO->getLHS(), AddressOf);
3643  Visit(BO->getRHS());
3644  return;
3645  case(BO_Comma):
3646  Visit(BO->getLHS());
3647  HandleValue(BO->getRHS(), AddressOf);
3648  return;
3649  }
3650  }
3651 
3652  Visit(E);
3653  }
3654 
3655  void CheckInitListExpr(InitListExpr *ILE) {
3656  InitFieldIndex.push_back(0);
3657  for (auto Child : ILE->children()) {
3658  if (InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
3659  CheckInitListExpr(SubList);
3660  } else {
3661  Visit(Child);
3662  }
3663  ++InitFieldIndex.back();
3664  }
3665  InitFieldIndex.pop_back();
3666  }
3667 
3668  void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor,
3669  FieldDecl *Field, const Type *BaseClass) {
3670  // Remove Decls that may have been initialized in the previous
3671  // initializer.
3672  for (ValueDecl* VD : DeclsToRemove)
3673  Decls.erase(VD);
3674  DeclsToRemove.clear();
3675 
3676  Constructor = FieldConstructor;
3677  InitListExpr *ILE = dyn_cast<InitListExpr>(E);
3678 
3679  if (ILE && Field) {
3680  InitList = true;
3681  InitListFieldDecl = Field;
3682  InitFieldIndex.clear();
3683  CheckInitListExpr(ILE);
3684  } else {
3685  InitList = false;
3686  Visit(E);
3687  }
3688 
3689  if (Field)
3690  Decls.erase(Field);
3691  if (BaseClass)
3692  BaseClasses.erase(BaseClass->getCanonicalTypeInternal());
3693  }
3694 
3695  void VisitMemberExpr(MemberExpr *ME) {
3696  // All uses of unbounded reference fields will warn.
3697  HandleMemberExpr(ME, true /*CheckReferenceOnly*/, false /*AddressOf*/);
3698  }
3699 
3700  void VisitImplicitCastExpr(ImplicitCastExpr *E) {
3701  if (E->getCastKind() == CK_LValueToRValue) {
3702  HandleValue(E->getSubExpr(), false /*AddressOf*/);
3703  return;
3704  }
3705 
3706  Inherited::VisitImplicitCastExpr(E);
3707  }
3708 
3709  void VisitCXXConstructExpr(CXXConstructExpr *E) {
3710  if (E->getConstructor()->isCopyConstructor()) {
3711  Expr *ArgExpr = E->getArg(0);
3712  if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
3713  if (ILE->getNumInits() == 1)
3714  ArgExpr = ILE->getInit(0);
3715  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
3716  if (ICE->getCastKind() == CK_NoOp)
3717  ArgExpr = ICE->getSubExpr();
3718  HandleValue(ArgExpr, false /*AddressOf*/);
3719  return;
3720  }
3721  Inherited::VisitCXXConstructExpr(E);
3722  }
3723 
3724  void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
3725  Expr *Callee = E->getCallee();
3726  if (isa<MemberExpr>(Callee)) {
3727  HandleValue(Callee, false /*AddressOf*/);
3728  for (auto Arg : E->arguments())
3729  Visit(Arg);
3730  return;
3731  }
3732 
3733  Inherited::VisitCXXMemberCallExpr(E);
3734  }
3735 
3736  void VisitCallExpr(CallExpr *E) {
3737  // Treat std::move as a use.
3738  if (E->isCallToStdMove()) {
3739  HandleValue(E->getArg(0), /*AddressOf=*/false);
3740  return;
3741  }
3742 
3743  Inherited::VisitCallExpr(E);
3744  }
3745 
3746  void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
3747  Expr *Callee = E->getCallee();
3748 
3749  if (isa<UnresolvedLookupExpr>(Callee))
3750  return Inherited::VisitCXXOperatorCallExpr(E);
3751 
3752  Visit(Callee);
3753  for (auto Arg : E->arguments())
3754  HandleValue(Arg->IgnoreParenImpCasts(), false /*AddressOf*/);
3755  }
3756 
3757  void VisitBinaryOperator(BinaryOperator *E) {
3758  // If a field assignment is detected, remove the field from the
3759  // uninitiailized field set.
3760  if (E->getOpcode() == BO_Assign)
3761  if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getLHS()))
3762  if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
3763  if (!FD->getType()->isReferenceType())
3764  DeclsToRemove.push_back(FD);
3765 
3766  if (E->isCompoundAssignmentOp()) {
3767  HandleValue(E->getLHS(), false /*AddressOf*/);
3768  Visit(E->getRHS());
3769  return;
3770  }
3771 
3772  Inherited::VisitBinaryOperator(E);
3773  }
3774 
3775  void VisitUnaryOperator(UnaryOperator *E) {
3776  if (E->isIncrementDecrementOp()) {
3777  HandleValue(E->getSubExpr(), false /*AddressOf*/);
3778  return;
3779  }
3780  if (E->getOpcode() == UO_AddrOf) {
3781  if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getSubExpr())) {
3782  HandleValue(ME->getBase(), true /*AddressOf*/);
3783  return;
3784  }
3785  }
3786 
3787  Inherited::VisitUnaryOperator(E);
3788  }
3789  };
3790 
3791  // Diagnose value-uses of fields to initialize themselves, e.g.
3792  // foo(foo)
3793  // where foo is not also a parameter to the constructor.
3794  // Also diagnose across field uninitialized use such as
3795  // x(y), y(x)
3796  // TODO: implement -Wuninitialized and fold this into that framework.
3797  static void DiagnoseUninitializedFields(
3798  Sema &SemaRef, const CXXConstructorDecl *Constructor) {
3799 
3800  if (SemaRef.getDiagnostics().isIgnored(diag::warn_field_is_uninit,
3801  Constructor->getLocation())) {
3802  return;
3803  }
3804 
3805  if (Constructor->isInvalidDecl())
3806  return;
3807 
3808  const CXXRecordDecl *RD = Constructor->getParent();
3809 
3810  if (RD->isDependentContext())
3811  return;
3812 
3813  // Holds fields that are uninitialized.
3814  llvm::SmallPtrSet<ValueDecl*, 4> UninitializedFields;
3815 
3816  // At the beginning, all fields are uninitialized.
3817  for (auto *I : RD->decls()) {
3818  if (auto *FD = dyn_cast<FieldDecl>(I)) {
3819  UninitializedFields.insert(FD);
3820  } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
3821  UninitializedFields.insert(IFD->getAnonField());
3822  }
3823  }
3824 
3825  llvm::SmallPtrSet<QualType, 4> UninitializedBaseClasses;
3826  for (auto I : RD->bases())
3827  UninitializedBaseClasses.insert(I.getType().getCanonicalType());
3828 
3829  if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
3830  return;
3831 
3832  UninitializedFieldVisitor UninitializedChecker(SemaRef,
3833  UninitializedFields,
3834  UninitializedBaseClasses);
3835 
3836  for (const auto *FieldInit : Constructor->inits()) {
3837  if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
3838  break;
3839 
3840  Expr *InitExpr = FieldInit->getInit();
3841  if (!InitExpr)
3842  continue;
3843 
3845  dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
3846  InitExpr = Default->getExpr();
3847  if (!InitExpr)
3848  continue;
3849  // In class initializers will point to the constructor.
3850  UninitializedChecker.CheckInitializer(InitExpr, Constructor,
3851  FieldInit->getAnyMember(),
3852  FieldInit->getBaseClass());
3853  } else {
3854  UninitializedChecker.CheckInitializer(InitExpr, nullptr,
3855  FieldInit->getAnyMember(),
3856  FieldInit->getBaseClass());
3857  }
3858  }
3859  }
3860 } // namespace
3861 
3862 /// Enter a new C++ default initializer scope. After calling this, the
3863 /// caller must call \ref ActOnFinishCXXInClassMemberInitializer, even if
3864 /// parsing or instantiating the initializer failed.
3866  // Create a synthetic function scope to represent the call to the constructor
3867  // that notionally surrounds a use of this initializer.
3868  PushFunctionScope();
3869 }
3870 
3872  if (!D.isFunctionDeclarator())
3873  return;
3874  auto &FTI = D.getFunctionTypeInfo();
3875  if (!FTI.Params)
3876  return;
3877  for (auto &Param : ArrayRef<DeclaratorChunk::ParamInfo>(FTI.Params,
3878  FTI.NumParams)) {
3879  auto *ParamDecl = cast<NamedDecl>(Param.Param);
3880  if (ParamDecl->getDeclName())
3881  PushOnScopeChains(ParamDecl, S, /*AddToContext=*/false);
3882  }
3883 }
3884 
3886  if (ConstraintExpr.isInvalid())
3887  return ExprError();
3888  return CorrectDelayedTyposInExpr(ConstraintExpr);
3889 }
3890 
3891 /// This is invoked after parsing an in-class initializer for a
3892 /// non-static C++ class member, and after instantiating an in-class initializer
3893 /// in a class template. Such actions are deferred until the class is complete.
3895  SourceLocation InitLoc,
3896  Expr *InitExpr) {
3897  // Pop the notional constructor scope we created earlier.
3898  PopFunctionScopeInfo(nullptr, D);
3899 
3900  FieldDecl *FD = dyn_cast<FieldDecl>(D);
3901  assert((isa<MSPropertyDecl>(D) || FD->getInClassInitStyle() != ICIS_NoInit) &&
3902  "must set init style when field is created");
3903 
3904  if (!InitExpr) {
3905  D->setInvalidDecl();
3906  if (FD)
3908  return;
3909  }
3910 
3911  if (DiagnoseUnexpandedParameterPack(InitExpr, UPPC_Initializer)) {
3912  FD->setInvalidDecl();
3914  return;
3915  }
3916 
3917  ExprResult Init = InitExpr;
3918  if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent()) {
3919  InitializedEntity Entity =
3921  InitializationKind Kind =
3924  InitExpr->getBeginLoc(),
3925  InitExpr->getEndLoc())
3926  : InitializationKind::CreateCopy(InitExpr->getBeginLoc(), InitLoc);
3927  InitializationSequence Seq(*this, Entity, Kind, InitExpr);
3928  Init = Seq.Perform(*this, Entity, Kind, InitExpr);
3929  if (Init.isInvalid()) {
3930  FD->setInvalidDecl();
3931  return;
3932  }
3933  }
3934 
3935  // C++11 [class.base.init]p7:
3936  // The initialization of each base and member constitutes a
3937  // full-expression.
3938  Init = ActOnFinishFullExpr(Init.get(), InitLoc, /*DiscardedValue*/ false);
3939  if (Init.isInvalid()) {
3940  FD->setInvalidDecl();
3941  return;
3942  }
3943 
3944  InitExpr = Init.get();
3945 
3946  FD->setInClassInitializer(InitExpr);
3947 }
3948 
3949 /// Find the direct and/or virtual base specifiers that
3950 /// correspond to the given base type, for use in base initialization
3951 /// within a constructor.
3952 static bool FindBaseInitializer(Sema &SemaRef,
3953  CXXRecordDecl *ClassDecl,
3954  QualType BaseType,
3955  const CXXBaseSpecifier *&DirectBaseSpec,
3956  const CXXBaseSpecifier *&VirtualBaseSpec) {
3957  // First, check for a direct base class.
3958  DirectBaseSpec = nullptr;
3959  for (const auto &Base : ClassDecl->bases()) {
3960  if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base.getType())) {
3961  // We found a direct base of this type. That's what we're
3962  // initializing.
3963  DirectBaseSpec = &Base;
3964  break;
3965  }
3966  }
3967 
3968  // Check for a virtual base class.
3969  // FIXME: We might be able to short-circuit this if we know in advance that
3970  // there are no virtual bases.
3971  VirtualBaseSpec = nullptr;
3972  if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
3973  // We haven't found a base yet; search the class hierarchy for a
3974  // virtual base class.
3975  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3976  /*DetectVirtual=*/false);
3977  if (SemaRef.IsDerivedFrom(ClassDecl->getLocation(),
3978  SemaRef.Context.getTypeDeclType(ClassDecl),
3979  BaseType, Paths)) {
3980  for (CXXBasePaths::paths_iterator Path = Paths.begin();
3981  Path != Paths.end(); ++Path) {
3982  if (Path->back().Base->isVirtual()) {
3983  VirtualBaseSpec = Path->back().Base;
3984  break;
3985  }
3986  }
3987  }
3988  }
3989 
3990  return DirectBaseSpec || VirtualBaseSpec;
3991 }
3992 
3993 /// Handle a C++ member initializer using braced-init-list syntax.
3995 Sema::ActOnMemInitializer(Decl *ConstructorD,
3996  Scope *S,
3997  CXXScopeSpec &SS,
3998  IdentifierInfo *MemberOrBase,
3999  ParsedType TemplateTypeTy,
4000  const DeclSpec &DS,
4001  SourceLocation IdLoc,
4002  Expr *InitList,
4003  SourceLocation EllipsisLoc) {
4004  return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
4005  DS, IdLoc, InitList,
4006  EllipsisLoc);
4007 }
4008 
4009 /// Handle a C++ member initializer using parentheses syntax.
4011 Sema::ActOnMemInitializer(Decl *ConstructorD,
4012  Scope *S,
4013  CXXScopeSpec &SS,
4014  IdentifierInfo *MemberOrBase,
4015  ParsedType TemplateTypeTy,
4016  const DeclSpec &DS,
4017  SourceLocation IdLoc,
4018  SourceLocation LParenLoc,
4019  ArrayRef<Expr *> Args,
4020  SourceLocation RParenLoc,
4021  SourceLocation EllipsisLoc) {
4022  Expr *List = ParenListExpr::Create(Context, LParenLoc, Args, RParenLoc);
4023  return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
4024  DS, IdLoc, List, EllipsisLoc);
4025 }
4026 
4027 namespace {
4028 
4029 // Callback to only accept typo corrections that can be a valid C++ member
4030 // intializer: either a non-static field member or a base class.
4031 class MemInitializerValidatorCCC final : public CorrectionCandidateCallback {
4032 public:
4033  explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl)
4034  : ClassDecl(ClassDecl) {}
4035 
4036  bool ValidateCandidate(const TypoCorrection &candidate) override {
4037  if (NamedDecl *ND = candidate.getCorrectionDecl()) {
4038  if (FieldDecl *Member = dyn_cast<FieldDecl>(ND))
4039  return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
4040  return isa<TypeDecl>(ND);
4041  }
4042  return false;
4043  }
4044 
4045  std::unique_ptr<CorrectionCandidateCallback> clone() override {
4046  return std::make_unique<MemInitializerValidatorCCC>(*this);
4047  }
4048 
4049 private:
4050  CXXRecordDecl *ClassDecl;
4051 };
4052 
4053 }
4054 
4055 ValueDecl *Sema::tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl,
4056  CXXScopeSpec &SS,
4057  ParsedType TemplateTypeTy,
4058  IdentifierInfo *MemberOrBase) {
4059  if (SS.getScopeRep() || TemplateTypeTy)
4060  return nullptr;
4061  DeclContext::lookup_result Result = ClassDecl->lookup(MemberOrBase);
4062  if (Result.empty())
4063  return nullptr;
4064  ValueDecl *Member;
4065  if ((Member = dyn_cast<FieldDecl>(Result.front())) ||
4066  (Member = dyn_cast<IndirectFieldDecl>(Result.front())))
4067  return Member;
4068  return nullptr;
4069 }
4070 
4071 /// Handle a C++ member initializer.
4073 Sema::BuildMemInitializer(Decl *ConstructorD,
4074  Scope *S,
4075  CXXScopeSpec &SS,
4076  IdentifierInfo *MemberOrBase,
4077  ParsedType TemplateTypeTy,
4078  const DeclSpec &DS,
4079  SourceLocation IdLoc,
4080  Expr *Init,
4081  SourceLocation EllipsisLoc) {
4082  ExprResult Res = CorrectDelayedTyposInExpr(Init);
4083  if (!Res.isUsable())
4084  return true;
4085  Init = Res.get();
4086 
4087  if (!ConstructorD)
4088  return true;
4089 
4090  AdjustDeclIfTemplate(ConstructorD);
4091 
4092  CXXConstructorDecl *Constructor
4093  = dyn_cast<CXXConstructorDecl>(ConstructorD);
4094  if (!Constructor) {
4095  // The user wrote a constructor initializer on a function that is
4096  // not a C++ constructor. Ignore the error for now, because we may
4097  // have more member initializers coming; we'll diagnose it just
4098  // once in ActOnMemInitializers.
4099  return true;
4100  }
4101 
4102  CXXRecordDecl *ClassDecl = Constructor->getParent();
4103 
4104  // C++ [class.base.init]p2:
4105  // Names in a mem-initializer-id are looked up in the scope of the
4106  // constructor's class and, if not found in that scope, are looked
4107  // up in the scope containing the constructor's definition.
4108  // [Note: if the constructor's class contains a member with the
4109  // same name as a direct or virtual base class of the class, a
4110  // mem-initializer-id naming the member or base class and composed
4111  // of a single identifier refers to the class member. A
4112  // mem-initializer-id for the hidden base class may be specified
4113  // using a qualified name. ]
4114 
4115  // Look for a member, first.
4116  if (ValueDecl *Member = tryLookupCtorInitMemberDecl(
4117  ClassDecl, SS, TemplateTypeTy, MemberOrBase)) {
4118  if (EllipsisLoc.isValid())
4119  Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
4120  << MemberOrBase
4121  << SourceRange(IdLoc, Init->getSourceRange().getEnd());
4122 
4123  return BuildMemberInitializer(Member, Init, IdLoc);
4124  }
4125  // It didn't name a member, so see if it names a class.
4126  QualType BaseType;
4127  TypeSourceInfo *TInfo = nullptr;
4128 
4129  if (TemplateTypeTy) {
4130  BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
4131  if (BaseType.isNull())
4132  return true;
4133  } else if (DS.getTypeSpecType() == TST_decltype) {
4134  BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
4135  } else if (DS.getTypeSpecType() == TST_decltype_auto) {
4136  Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);
4137  return true;
4138  } else {
4139  LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
4140  LookupParsedName(R, S, &SS);
4141 
4142  TypeDecl *TyD = R.getAsSingle<TypeDecl>();
4143  if (!TyD) {
4144  if (R.isAmbiguous()) return true;
4145 
4146  // We don't want access-control diagnostics here.
4147  R.suppressDiagnostics();
4148 
4149  if (SS.isSet() && isDependentScopeSpecifier(SS)) {
4150  bool NotUnknownSpecialization = false;
4151  DeclContext *DC = computeDeclContext(SS, false);
4152  if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
4153  NotUnknownSpecialization = !Record->hasAnyDependentBases();
4154 
4155  if (!NotUnknownSpecialization) {
4156  // When the scope specifier can refer to a member of an unknown
4157  // specialization, we take it as a type name.
4158  BaseType = CheckTypenameType(ETK_None, SourceLocation(),
4159  SS.getWithLocInContext(Context),
4160  *MemberOrBase, IdLoc);
4161  if (BaseType.isNull())
4162  return true;
4163 
4164  TInfo = Context.CreateTypeSourceInfo(BaseType);
4167  if (!TL.isNull()) {
4168  TL.setNameLoc(IdLoc);
4170  TL.setQualifierLoc(SS.getWithLocInContext(Context));
4171  }
4172 
4173  R.clear();
4174  R.setLookupName(MemberOrBase);
4175  }
4176  }
4177 
4178  // If no results were found, try to correct typos.
4179  TypoCorrection Corr;
4180  MemInitializerValidatorCCC CCC(ClassDecl);
4181  if (R.empty() && BaseType.isNull() &&
4182  (Corr = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
4183  CCC, CTK_ErrorRecovery, ClassDecl))) {
4184  if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
4185  // We have found a non-static data member with a similar
4186  // name to what was typed; complain and initialize that
4187  // member.
4188  diagnoseTypo(Corr,
4189  PDiag(diag::err_mem_init_not_member_or_class_suggest)
4190  << MemberOrBase << true);
4191  return BuildMemberInitializer(Member, Init, IdLoc);
4192  } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
4193  const CXXBaseSpecifier *DirectBaseSpec;
4194  const CXXBaseSpecifier *VirtualBaseSpec;
4195  if (FindBaseInitializer(*this, ClassDecl,
4196  Context.getTypeDeclType(Type),
4197  DirectBaseSpec, VirtualBaseSpec)) {
4198  // We have found a direct or virtual base class with a
4199  // similar name to what was typed; complain and initialize
4200  // that base class.
4201  diagnoseTypo(Corr,
4202  PDiag(diag::err_mem_init_not_member_or_class_suggest)
4203  << MemberOrBase << false,
4204  PDiag() /*Suppress note, we provide our own.*/);
4205 
4206  const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
4207  : VirtualBaseSpec;
4208  Diag(BaseSpec->getBeginLoc(), diag::note_base_class_specified_here)
4209  << BaseSpec->getType() << BaseSpec->getSourceRange();
4210 
4211  TyD = Type;
4212  }
4213  }
4214  }
4215 
4216  if (!TyD && BaseType.isNull()) {
4217  Diag(IdLoc, diag::err_mem_init_not_member_or_class)
4218  << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
4219  return true;
4220  }
4221  }
4222 
4223  if (BaseType.isNull()) {
4224  BaseType = Context.getTypeDeclType(TyD);
4225  MarkAnyDeclReferenced(TyD->getLocation(), TyD, /*OdrUse=*/false);
4226  if (SS.isSet()) {
4227  BaseType = Context.getElaboratedType(ETK_None, SS.getScopeRep(),
4228  BaseType);
4229  TInfo = Context.CreateTypeSourceInfo(BaseType);
4231  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
4233  TL.setQualifierLoc(SS.getWithLocInContext(Context));
4234  }
4235  }
4236  }
4237 
4238  if (!TInfo)
4239  TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
4240 
4241  return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc);
4242 }
4243 
4246  SourceLocation IdLoc) {
4247  FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member);
4248  IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member);
4249  assert((DirectMember || IndirectMember) &&
4250  "Member must be a FieldDecl or IndirectFieldDecl");
4251 
4252  if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
4253  return true;
4254 
4255  if (Member->isInvalidDecl())
4256  return true;
4257 
4258  MultiExprArg Args;
4259  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4260  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4261  } else if (InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
4262  Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
4263  } else {
4264  // Template instantiation doesn't reconstruct ParenListExprs for us.
4265  Args = Init;
4266  }
4267 
4268  SourceRange InitRange = Init->getSourceRange();
4269 
4270  if (Member->getType()->isDependentType() || Init->isTypeDependent()) {
4271  // Can't check initialization for a member of dependent type or when
4272  // any of the arguments are type-dependent expressions.
4273  DiscardCleanupsInEvaluationContext();
4274  } else {
4275  bool InitList = false;
4276  if (isa<InitListExpr>(Init)) {
4277  InitList = true;
4278  Args = Init;
4279  }
4280 
4281  // Initialize the member.
4282  InitializedEntity MemberEntity =
4283  DirectMember ? InitializedEntity::InitializeMember(DirectMember, nullptr)
4284  : InitializedEntity::InitializeMember(IndirectMember,
4285  nullptr);
4286  InitializationKind Kind =
4288  IdLoc, Init->getBeginLoc(), Init->getEndLoc())
4289  : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(),
4290  InitRange.getEnd());
4291 
4292  InitializationSequence InitSeq(*this, MemberEntity, Kind, Args);
4293  ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind, Args,
4294  nullptr);
4295  if (MemberInit.isInvalid())
4296  return true;
4297 
4298  // C++11 [class.base.init]p7:
4299  // The initialization of each base and member constitutes a
4300  // full-expression.
4301  MemberInit = ActOnFinishFullExpr(MemberInit.get(), InitRange.getBegin(),
4302  /*DiscardedValue*/ false);
4303  if (MemberInit.isInvalid())
4304  return true;
4305 
4306  Init = MemberInit.get();
4307  }
4308 
4309  if (DirectMember) {
4310  return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc,
4311  InitRange.getBegin(), Init,
4312  InitRange.getEnd());
4313  } else {
4314  return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc,
4315  InitRange.getBegin(), Init,
4316  InitRange.getEnd());
4317  }
4318 }
4319 
4322  CXXRecordDecl *ClassDecl) {
4323  SourceLocation NameLoc = TInfo->getTypeLoc().getLocalSourceRange().getBegin();
4324  if (!LangOpts.CPlusPlus11)
4325  return Diag(NameLoc, diag::err_delegating_ctor)
4326  << TInfo->getTypeLoc().getLocalSourceRange();
4327  Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
4328 
4329  bool InitList = true;
4330  MultiExprArg Args = Init;
4331  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4332  InitList = false;
4333  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4334  }
4335 
4336  SourceRange InitRange = Init->getSourceRange();
4337  // Initialize the object.
4339  QualType(ClassDecl->getTypeForDecl(), 0));
4340  InitializationKind Kind =
4342  NameLoc, Init->getBeginLoc(), Init->getEndLoc())
4343  : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(),
4344  InitRange.getEnd());
4345  InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args);
4346  ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind,
4347  Args, nullptr);
4348  if (DelegationInit.isInvalid())
4349  return true;
4350 
4351  assert(cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() &&
4352  "Delegating constructor with no target?");
4353 
4354  // C++11 [class.base.init]p7:
4355  // The initialization of each base and member constitutes a
4356  // full-expression.
4357  DelegationInit = ActOnFinishFullExpr(
4358  DelegationInit.get(), InitRange.getBegin(), /*DiscardedValue*/ false);
4359  if (DelegationInit.isInvalid())
4360  return true;
4361 
4362  // If we are in a dependent context, template instantiation will
4363  // perform this type-checking again. Just save the arguments that we
4364  // received in a ParenListExpr.
4365  // FIXME: This isn't quite ideal, since our ASTs don't capture all
4366  // of the information that we have about the base
4367  // initializer. However, deconstructing the ASTs is a dicey process,
4368  // and this approach is far more likely to get the corner cases right.
4369  if (CurContext->isDependentContext())
4370  DelegationInit = Init;
4371 
4372  return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(),
4373  DelegationInit.getAs<Expr>(),
4374  InitRange.getEnd());
4375 }
4376 
4379  Expr *Init, CXXRecordDecl *ClassDecl,
4380  SourceLocation EllipsisLoc) {
4381  SourceLocation BaseLoc
4382  = BaseTInfo->getTypeLoc().getLocalSourceRange().getBegin();
4383 
4384  if (!BaseType->isDependentType() && !BaseType->isRecordType())
4385  return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
4386  << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
4387 
4388  // C++ [class.base.init]p2:
4389  // [...] Unless the mem-initializer-id names a nonstatic data
4390  // member of the constructor's class or a direct or virtual base
4391  // of that class, the mem-initializer is ill-formed. A
4392  // mem-initializer-list can initialize a base class using any
4393  // name that denotes that base class type.
4394  bool Dependent = BaseType->isDependentType() || Init->isTypeDependent();
4395 
4396  SourceRange InitRange = Init->getSourceRange();
4397  if (EllipsisLoc.isValid()) {
4398  // This is a pack expansion.
4399  if (!BaseType->containsUnexpandedParameterPack()) {
4400  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
4401  << SourceRange(BaseLoc, InitRange.getEnd());
4402 
4403  EllipsisLoc = SourceLocation();
4404  }
4405  } else {
4406  // Check for any unexpanded parameter packs.
4407  if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer))
4408  return true;
4409 
4410  if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
4411  return true;
4412  }
4413 
4414  // Check for direct and virtual base classes.
4415  const CXXBaseSpecifier *DirectBaseSpec = nullptr;
4416  const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
4417  if (!Dependent) {
4418  if (Context.hasSameUnqualifiedType(QualType(ClassDecl->getTypeForDecl(),0),
4419  BaseType))
4420  return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl);
4421 
4422  FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
4423  VirtualBaseSpec);
4424 
4425  // C++ [base.class.init]p2:
4426  // Unless the mem-initializer-id names a nonstatic data member of the
4427  // constructor's class or a direct or virtual base of that class, the
4428  // mem-initializer is ill-formed.
4429  if (!DirectBaseSpec && !VirtualBaseSpec) {
4430  // If the class has any dependent bases, then it's possible that
4431  // one of those types will resolve to the same type as
4432  // BaseType. Therefore, just treat this as a dependent base
4433  // class initialization. FIXME: Should we try to check the
4434  // initialization anyway? It seems odd.
4435  if (ClassDecl->hasAnyDependentBases())
4436  Dependent = true;
4437  else
4438  return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
4439  << BaseType << Context.getTypeDeclType(ClassDecl)
4440  << BaseTInfo->getTypeLoc().getLocalSourceRange();
4441  }
4442  }
4443 
4444  if (Dependent) {
4445  DiscardCleanupsInEvaluationContext();
4446 
4447  return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4448  /*IsVirtual=*/false,
4449  InitRange.getBegin(), Init,
4450  InitRange.getEnd(), EllipsisLoc);
4451  }
4452 
4453  // C++ [base.class.init]p2:
4454  // If a mem-initializer-id is ambiguous because it designates both
4455  // a direct non-virtual base class and an inherited virtual base
4456  // class, the mem-initializer is ill-formed.
4457  if (DirectBaseSpec && VirtualBaseSpec)
4458  return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
4459  << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
4460 
4461  const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
4462  if (!BaseSpec)
4463  BaseSpec = VirtualBaseSpec;
4464 
4465  // Initialize the base.
4466  bool InitList = true;
4467  MultiExprArg Args = Init;
4468  if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4469  InitList = false;
4470  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4471  }
4472 
4473  InitializedEntity BaseEntity =
4474  InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec);
4475  InitializationKind Kind =
4476  InitList ? InitializationKind::CreateDirectList(BaseLoc)
4477  : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(),
4478  InitRange.getEnd());
4479  InitializationSequence InitSeq(*this, BaseEntity, Kind, Args);
4480  ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind, Args, nullptr);
4481  if (BaseInit.isInvalid())
4482  return true;
4483 
4484  // C++11 [class.base.init]p7:
4485  // The initialization of each base and member constitutes a
4486  // full-expression.
4487  BaseInit = ActOnFinishFullExpr(BaseInit.get(), InitRange.getBegin(),
4488  /*DiscardedValue*/ false);
4489  if (BaseInit.isInvalid())
4490  return true;
4491 
4492  // If we are in a dependent context, template instantiation will
4493  // perform this type-checking again. Just save the arguments that we
4494  // received in a ParenListExpr.
4495  // FIXME: This isn't quite ideal, since our ASTs don't capture all
4496  // of the information that we have about the base
4497  // initializer. However, deconstructing the ASTs is a dicey process,
4498  // and this approach is far more likely to get the corner cases right.
4499  if (CurContext->isDependentContext())
4500  BaseInit = Init;
4501 
4502  return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4503  BaseSpec->isVirtual(),
4504  InitRange.getBegin(),
4505  BaseInit.getAs<Expr>(),
4506  InitRange.getEnd(), EllipsisLoc);
4507 }
4508 
4509 // Create a static_cast<T&&>(expr).
4510 static Expr *CastForMoving(Sema &SemaRef, Expr *E, QualType T = QualType()) {
4511  if (T.isNull()) T = E->getType();
4512  QualType TargetType = SemaRef.BuildReferenceType(
4513  T, /*SpelledAsLValue*/false, SourceLocation(), DeclarationName());
4514  SourceLocation ExprLoc = E->getBeginLoc();
4515  TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo(
4516  TargetType, ExprLoc);
4517 
4518  return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
4519  SourceRange(ExprLoc, ExprLoc),
4520  E->getSourceRange()).get();
4521 }
4522 
4523 /// ImplicitInitializerKind - How an implicit base or member initializer should
4524 /// initialize its base or member.
4530 };
4531 
4532 static bool
4534  ImplicitInitializerKind ImplicitInitKind,
4535  CXXBaseSpecifier *BaseSpec,
4536  bool IsInheritedVirtualBase,
4537  CXXCtorInitializer *&CXXBaseInit) {
4538  InitializedEntity InitEntity
4539  = InitializedEntity::InitializeBase(SemaRef.Context, BaseSpec,
4540  IsInheritedVirtualBase);
4541 
4542  ExprResult BaseInit;
4543 
4544  switch (ImplicitInitKind) {
4545  case IIK_Inherit:
4546  case IIK_Default: {
4547  InitializationKind InitKind
4549  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
4550  BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
4551  break;
4552  }
4553 
4554  case IIK_Move:
4555  case IIK_Copy: {
4556  bool Moving = ImplicitInitKind == IIK_Move;
4557  ParmVarDecl *Param = Constructor->getParamDecl(0);
4558  QualType ParamType = Param->getType().getNonReferenceType();
4559 
4560  Expr *CopyCtorArg =
4562  SourceLocation(), Param, false,
4563  Constructor->getLocation(), ParamType,
4564  VK_LValue, nullptr);
4565 
4566  SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg));
4567 
4568  // Cast to the base class to avoid ambiguities.
4569  QualType ArgTy =
4570  SemaRef.Context.getQualifiedType(BaseSpec->getType().getUnqualifiedType(),
4571  ParamType.getQualifiers());
4572 
4573  if (Moving) {
4574  CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg);
4575  }
4576 
4577  CXXCastPath BasePath;
4578  BasePath.push_back(BaseSpec);
4579  CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy,
4580  CK_UncheckedDerivedToBase,
4581  Moving ? VK_XValue : VK_LValue,
4582  &BasePath).get();
4583 
4584  InitializationKind InitKind
4587  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, CopyCtorArg);
4588  BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, CopyCtorArg);
4589  break;
4590  }
4591  }
4592 
4593  BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit);
4594  if (BaseInit.isInvalid())
4595  return true;
4596 
4597  CXXBaseInit =
4598  new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4599  SemaRef.Context.getTrivialTypeSourceInfo(BaseSpec->getType(),
4600  SourceLocation()),
4601  BaseSpec->isVirtual(),
4602  SourceLocation(),
4603  BaseInit.getAs<Expr>(),
4604  SourceLocation(),
4605  SourceLocation());
4606 
4607  return false;
4608 }
4609 
4610 static bool RefersToRValueRef(Expr *MemRef) {
4611  ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
4612  return Referenced->getType()->isRValueReferenceType();
4613 }
4614 
4615 static bool
4617  ImplicitInitializerKind ImplicitInitKind,
4618  FieldDecl *Field, IndirectFieldDecl *Indirect,
4619  CXXCtorInitializer *&CXXMemberInit) {
4620  if (Field->isInvalidDecl())
4621  return true;
4622 
4623  SourceLocation Loc = Constructor->getLocation();
4624 
4625  if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) {
4626  bool Moving = ImplicitInitKind == IIK_Move;
4627  ParmVarDecl *Param = Constructor->getParamDecl(0);
4628  QualType ParamType = Param->getType().getNonReferenceType();
4629 
4630  // Suppress copying zero-width bitfields.
4631  if (Field->isZeroLengthBitField(SemaRef.Context))
4632  return false;
4633 
4634  Expr *MemberExprBase =
4636  SourceLocation(), Param, false,
4637  Loc, ParamType, VK_LValue, nullptr);
4638 
4639  SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase));
4640 
4641  if (Moving) {
4642  MemberExprBase = CastForMoving(SemaRef, MemberExprBase);
4643  }
4644 
4645  // Build a reference to this field within the parameter.
4646  CXXScopeSpec SS;
4647  LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
4649  MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect)
4650  : cast<ValueDecl>(Field), AS_public);
4651  MemberLookup.resolveKind();
4652  ExprResult CtorArg
4653  = SemaRef.BuildMemberReferenceExpr(MemberExprBase,
4654  ParamType, Loc,
4655  /*IsArrow=*/false,
4656  SS,
4657  /*TemplateKWLoc=*/SourceLocation(),
4658  /*FirstQualifierInScope=*/nullptr,
4659  MemberLookup,
4660  /*TemplateArgs=*/nullptr,
4661  /*S*/nullptr);
4662  if (CtorArg.isInvalid())
4663  return true;
4664 
4665  // C++11 [class.copy]p15:
4666  // - if a member m has rvalue reference type T&&, it is direct-initialized
4667  // with static_cast<T&&>(x.m);
4668  if (RefersToRValueRef(CtorArg.get())) {
4669  CtorArg = CastForMoving(SemaRef, CtorArg.get());
4670  }
4671 
4672  InitializedEntity Entity =
4673  Indirect ? InitializedEntity::InitializeMember(Indirect, nullptr,
4674  /*Implicit*/ true)
4675  : InitializedEntity::InitializeMember(Field, nullptr,
4676  /*Implicit*/ true);
4677 
4678  // Direct-initialize to use the copy constructor.
4679  InitializationKind InitKind =
4681 
4682  Expr *CtorArgE = CtorArg.getAs<Expr>();
4683  InitializationSequence InitSeq(SemaRef, Entity, InitKind, CtorArgE);
4684  ExprResult MemberInit =
4685  InitSeq.Perform(SemaRef, Entity, InitKind, MultiExprArg(&CtorArgE, 1));
4686  MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
4687  if (MemberInit.isInvalid())
4688  return true;
4689 
4690  if (Indirect)
4691  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
4692  SemaRef.Context, Indirect, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
4693  else
4694  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
4695  SemaRef.Context, Field, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
4696  return false;
4697  }
4698 
4699  assert((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) &&
4700  "Unhandled implicit init kind!");
4701 
4702  QualType FieldBaseElementType =
4703  SemaRef.Context.getBaseElementType(Field->getType());
4704 
4705  if (FieldBaseElementType->isRecordType()) {
4706  InitializedEntity InitEntity =
4707  Indirect ? InitializedEntity::InitializeMember(Indirect, nullptr,
4708  /*Implicit*/ true)
4709  : InitializedEntity::InitializeMember(Field, nullptr,
4710  /*Implicit*/ true);
4711  InitializationKind InitKind =
4713 
4714  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
4715  ExprResult MemberInit =
4716  InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
4717 
4718  MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
4719  if (MemberInit.isInvalid())
4720  return true;
4721 
4722  if (Indirect)
4723  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4724  Indirect, Loc,
4725  Loc,
4726  MemberInit.get(),
4727  Loc);
4728  else
4729  CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4730  Field, Loc, Loc,
4731  MemberInit.get(),
4732  Loc);
4733  return false;
4734  }
4735 
4736  if (!Field->getParent()->isUnion()) {
4737  if (FieldBaseElementType->isReferenceType()) {
4738  SemaRef.Diag(Constructor->getLocation(),
4739  diag::err_uninitialized_member_in_ctor)
4740  << (int)Constructor->isImplicit()
4741  << SemaRef.Context.getTagDeclType(Constructor->getParent())
4742  << 0 << Field->getDeclName();
4743  SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
4744  return true;
4745  }
4746 
4747  if (FieldBaseElementType.isConstQualified()) {
4748  SemaRef.Diag(Constructor->getLocation(),
4749  diag::err_uninitialized_member_in_ctor)
4750  << (int)Constructor->isImplicit()
4751  << SemaRef.Context.getTagDeclType(Constructor->getParent())
4752  << 1 << Field->getDeclName();
4753  SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
4754  return true;
4755  }
4756  }
4757 
4758  if (FieldBaseElementType.hasNonTrivialObjCLifetime()) {
4759  // ARC and Weak:
4760  // Default-initialize Objective-C pointers to NULL.
4761  CXXMemberInit
4762  = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
4763  Loc, Loc,
4764  new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()),
4765  Loc);
4766  return false;
4767  }
4768 
4769  // Nothing to initialize.
4770  CXXMemberInit = nullptr;
4771  return false;
4772 }
4773 
4774 namespace {
4775 struct BaseAndFieldInfo {
4776  Sema &S;
4777  CXXConstructorDecl *Ctor;
4778  bool AnyErrorsInInits;
4780  llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
4782  llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
4783 
4784  BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits)
4785  : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
4786  bool Generated = Ctor->isImplicit() || Ctor->isDefaulted();
4787  if (Ctor->getInheritedConstructor())
4788  IIK = IIK_Inherit;
4789  else if (Generated && Ctor->isCopyConstructor())
4790  IIK = IIK_Copy;
4791  else if (Generated && Ctor->isMoveConstructor())
4792  IIK = IIK_Move;
4793  else
4794  IIK = IIK_Default;
4795  }
4796 
4797  bool isImplicitCopyOrMove() const {
4798  switch (IIK) {
4799  case IIK_Copy:
4800  case IIK_Move:
4801  return true;
4802 
4803  case IIK_Default:
4804  case IIK_Inherit:
4805  return false;
4806  }
4807 
4808  llvm_unreachable("Invalid ImplicitInitializerKind!");
4809  }
4810 
4811  bool addFieldInitializer(CXXCtorInitializer *Init) {
4812  AllToInit.push_back(Init);
4813 
4814  // Check whether this initializer makes the field "used".
4815  if (Init->getInit()->HasSideEffects(S.Context))
4816  S.UnusedPrivateFields.remove(Init->getAnyMember());
4817 
4818  return false;
4819  }
4820 
4821  bool isInactiveUnionMember(FieldDecl *Field) {
4822  RecordDecl *Record = Field->getParent();
4823  if (!Record->isUnion())
4824  return false;
4825 
4826  if (FieldDecl *Active =
4827  ActiveUnionMember.lookup(Record->getCanonicalDecl()))
4828  return Active != Field->getCanonicalDecl();
4829 
4830  // In an implicit copy or move constructor, ignore any in-class initializer.
4831  if (isImplicitCopyOrMove())
4832  return true;
4833 
4834  // If there's no explicit initialization, the field is active only if it
4835  // has an in-class initializer...
4836  if (Field->hasInClassInitializer())
4837  return false;
4838  // ... or it's an anonymous struct or union whose class has an in-class
4839  // initializer.
4840  if (!Field->isAnonymousStructOrUnion())
4841  return true;
4842  CXXRecordDecl *FieldRD = Field->getType()->getAsCXXRecordDecl();
4843  return !FieldRD->hasInClassInitializer();
4844  }
4845 
4846  /// Determine whether the given field is, or is within, a union member
4847  /// that is inactive (because there was an initializer given for a different
4848  /// member of the union, or because the union was not initialized at all).
4849  bool isWithinInactiveUnionMember(FieldDecl *Field,
4850  IndirectFieldDecl *Indirect) {
4851  if (!Indirect)
4852  return isInactiveUnionMember(Field);
4853 
4854  for (auto *C : Indirect->chain()) {
4855  FieldDecl *Field = dyn_cast<FieldDecl>(C);
4856  if (Field && isInactiveUnionMember(Field))
4857  return true;
4858  }
4859  return false;
4860  }
4861 };
4862 }
4863 
4864 /// Determine whether the given type is an incomplete or zero-lenfgth
4865 /// array type.
4867  if (T->isIncompleteArrayType())
4868  return true;
4869 
4870  while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
4871  if (!ArrayT->getSize())
4872  return true;
4873 
4874  T = ArrayT->getElementType();
4875  }
4876 
4877  return false;
4878 }
4879 
4880 static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
4881  FieldDecl *Field,
4882  IndirectFieldDecl *Indirect = nullptr) {
4883  if (Field->isInvalidDecl())
4884  return false;
4885 
4886  // Overwhelmingly common case: we have a direct initializer for this field.
4887  if (CXXCtorInitializer *Init =
4888  Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
4889  return Info.addFieldInitializer(Init);
4890 
4891  // C++11 [class.base.init]p8:
4892  // if the entity is a non-static data member that has a
4893  // brace-or-equal-initializer and either
4894  // -- the constructor's class is a union and no other variant member of that
4895  // union is designated by a mem-initializer-id or
4896  // -- the constructor's class is not a union, and, if the entity is a member
4897  // of an anonymous union, no other member of that union is designated by
4898  // a mem-initializer-id,
4899  // the entity is initialized as specified in [dcl.init].
4900  //
4901  // We also apply the same rules to handle anonymous structs within anonymous
4902  // unions.
4903  if (Info.isWithinInactiveUnionMember(Field, Indirect))
4904  return false;
4905 
4906  if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
4907  ExprResult DIE =
4908  SemaRef.BuildCXXDefaultInitExpr(Info.Ctor->getLocation(), Field);
4909  if (DIE.isInvalid())
4910  return true;
4911 
4912  auto Entity = InitializedEntity::InitializeMember(Field, nullptr, true);
4913  SemaRef.checkInitializerLifetime(Entity, DIE.get());
4914 
4915  CXXCtorInitializer *Init;
4916  if (Indirect)
4917  Init = new (SemaRef.Context)
4918  CXXCtorInitializer(SemaRef.Context, Indirect, SourceLocation(),
4919  SourceLocation(), DIE.get(), SourceLocation());
4920  else
4921  Init = new (SemaRef.Context)
4922  CXXCtorInitializer(SemaRef.Context, Field, SourceLocation(),
4923  SourceLocation(), DIE.get(), SourceLocation());
4924  return Info.addFieldInitializer(Init);
4925  }
4926 
4927  // Don't initialize incomplete or zero-length arrays.
4928  if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType()))
4929  return false;
4930 
4931  // Don't try to build an implicit initializer if there were semantic
4932  // errors in any of the initializers (and therefore we might be
4933  // missing some that the user actually wrote).
4934  if (Info.AnyErrorsInInits)
4935  return false;
4936 
4937  CXXCtorInitializer *Init = nullptr;
4938  if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field,
4939  Indirect, Init))
4940  return true;
4941 
4942  if (!Init)
4943  return false;
4944 
4945  return Info.addFieldInitializer(Init);
4946 }
4947 
4948 bool
4951  assert(Initializer->isDelegatingInitializer());
4952  Constructor->setNumCtorInitializers(1);
4953  CXXCtorInitializer **initializer =
4954  new (Context) CXXCtorInitializer*[1];
4955  memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*));
4956  Constructor->setCtorInitializers(initializer);
4957 
4958  if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) {
4959  MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor);
4960  DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation());
4961  }
4962 
4963  DelegatingCtorDecls.push_back(Constructor);
4964 
4965  DiagnoseUninitializedFields(*this, Constructor);
4966 
4967  return false;
4968 }
4969 
4970 bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
4971  ArrayRef<CXXCtorInitializer *> Initializers) {
4972  if (Constructor->isDependentContext()) {
4973  // Just store the initializers as written, they will be checked during
4974  // instantiation.
4975  if (!Initializers.empty()) {
4976  Constructor->setNumCtorInitializers(Initializers.size());
4977  CXXCtorInitializer **baseOrMemberInitializers =
4978  new (Context) CXXCtorInitializer*[Initializers.size()];
4979  memcpy(baseOrMemberInitializers, Initializers.data(),
4980  Initializers.size() * sizeof(CXXCtorInitializer*));
4981  Constructor->setCtorInitializers(baseOrMemberInitializers);
4982  }
4983 
4984  // Let template instantiation know whether we had errors.
4985  if (AnyErrors)
4986  Constructor->setInvalidDecl();
4987 
4988  return false;
4989  }
4990 
4991  BaseAndFieldInfo Info(*this, Constructor, AnyErrors);
4992 
4993  // We need to build the initializer AST according to order of construction
4994  // and not what user specified in the Initializers list.
4995  CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
4996  if (!ClassDecl)
4997  return true;
4998 
4999  bool HadError = false;
5000 
5001  for (unsigned i = 0; i < Initializers.size(); i++) {
5002  CXXCtorInitializer *Member = Initializers[i];
5003 
5004  if (Member->isBaseInitializer())
5005  Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
5006  else {
5007  Info.AllBaseFields[Member->getAnyMember()->getCanonicalDecl()] = Member;
5008 
5009  if (IndirectFieldDecl *F = Member->getIndirectMember()) {
5010  for (auto *C : F->chain()) {
5011  FieldDecl *FD = dyn_cast<FieldDecl>(C);
5012  if (FD && FD->getParent()->isUnion())
5013  Info.ActiveUnionMember.insert(std::make_pair(
5014  FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
5015  }
5016  } else if (FieldDecl *FD = Member->getMember()) {
5017  if (FD->getParent()->isUnion())
5018  Info.ActiveUnionMember.insert(std::make_pair(
5019  FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
5020  }
5021  }
5022  }
5023 
5024  // Keep track of the direct virtual bases.
5025  llvm::SmallPtrSet<CXXBaseSpecifier *, 16> DirectVBases;
5026  for (auto &I : ClassDecl->bases()) {
5027  if (I.isVirtual())
5028  DirectVBases.insert(&I);
5029  }
5030 
5031  // Push virtual bases before others.
5032  for (auto &VBase : ClassDecl->vbases()) {
5034  = Info.AllBaseFields.lookup(VBase.getType()->getAs<RecordType>())) {
5035  // [class.base.init]p7, per DR257:
5036  // A mem-initializer where the mem-initializer-id names a virtual base
5037  // class is ignored during execution of a constructor of any class that
5038  // is not the most derived class.
5039  if (ClassDecl->isAbstract()) {
5040  // FIXME: Provide a fixit to remove the base specifier. This requires
5041  // tracking the location of the associated comma for a base specifier.
5042  Diag(Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
5043  << VBase.getType() << ClassDecl;
5044  DiagnoseAbstractType(ClassDecl);
5045  }
5046 
5047  Info.AllToInit.push_back(Value);
5048  } else if (!AnyErrors && !ClassDecl->isAbstract()) {
5049  // [class.base.init]p8, per DR257:
5050  // If a given [...] base class is not named by a mem-initializer-id
5051  // [...] and the entity is not a virtual base class of an abstract
5052  // class, then [...] the entity is default-initialized.
5053  bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
5054  CXXCtorInitializer *CXXBaseInit;
5055  if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
5056  &VBase, IsInheritedVirtualBase,
5057  CXXBaseInit)) {
5058  HadError = true;
5059  continue;
5060  }
5061 
5062  Info.AllToInit.push_back(CXXBaseInit);
5063  }
5064  }
5065 
5066  // Non-virtual bases.
5067  for (auto &Base : ClassDecl->bases()) {
5068  // Virtuals are in the virtual base list and already constructed.
5069  if (Base.isVirtual())
5070  continue;
5071 
5073  = Info.AllBaseFields.lookup(Base.getType()->getAs<RecordType>())) {
5074  Info.AllToInit.push_back(Value);
5075  } else if (!AnyErrors) {
5076  CXXCtorInitializer *CXXBaseInit;
5077  if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
5078  &Base, /*IsInheritedVirtualBase=*/false,
5079  CXXBaseInit)) {
5080  HadError = true;
5081  continue;
5082  }
5083 
5084  Info.AllToInit.push_back(CXXBaseInit);
5085  }
5086  }
5087 
5088  // Fields.
5089  for (auto *Mem : ClassDecl->decls()) {
5090  if (auto *F = dyn_cast<FieldDecl>(Mem)) {
5091  // C++ [class.bit]p2:
5092  // A declaration for a bit-field that omits the identifier declares an
5093  // unnamed bit-field. Unnamed bit-fields are not members and cannot be
5094  // initialized.
5095  if (F->isUnnamedBitfield())
5096  continue;
5097 
5098  // If we're not generating the implicit copy/move constructor, then we'll
5099  // handle anonymous struct/union fields based on their individual
5100  // indirect fields.
5101  if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
5102  continue;
5103 
5104  if (CollectFieldInitializer(*this, Info, F))
5105  HadError = true;
5106  continue;
5107  }
5108 
5109  // Beyond this point, we only consider default initialization.
5110  if (Info.isImplicitCopyOrMove())
5111  continue;
5112 
5113  if (auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
5114  if (F->getType()->isIncompleteArrayType()) {
5115  assert(ClassDecl->hasFlexibleArrayMember() &&
5116  "Incomplete array type is not valid");
5117  continue;
5118  }
5119 
5120  // Initialize each field of an anonymous struct individually.
5121  if (CollectFieldInitializer(*this, Info, F->getAnonField(), F))
5122  HadError = true;
5123 
5124  continue;
5125  }
5126  }
5127 
5128  unsigned NumInitializers = Info.AllToInit.size();
5129  if (NumInitializers > 0) {
5130  Constructor->setNumCtorInitializers(NumInitializers);
5131  CXXCtorInitializer **baseOrMemberInitializers =
5132  new (Context) CXXCtorInitializer*[NumInitializers];
5133  memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
5134  NumInitializers * sizeof(CXXCtorInitializer*));
5135  Constructor->setCtorInitializers(baseOrMemberInitializers);
5136 
5137  // Constructors implicitly reference the base and member
5138  // destructors.
5139  MarkBaseAndMemberDestructorsReferenced(Constructor->getLocation(),
5140  Constructor->getParent());
5141  }
5142 
5143  return HadError;
5144 }
5145 
5147  if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
5148  const RecordDecl *RD = RT->getDecl();
5149  if (RD->isAnonymousStructOrUnion()) {
5150  for (auto *Field : RD->fields())
5151  PopulateKeysForFields(Field, IdealInits);
5152  return;
5153  }
5154  }
5155  IdealInits.push_back(Field->getCanonicalDecl());
5156 }
5157 
5158 static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
5159  return Context.getCanonicalType(BaseType).getTypePtr();
5160 }
5161 
5162 static const void *GetKeyForMember(ASTContext &Context,
5163  CXXCtorInitializer *Member) {
5164  if (!Member->isAnyMemberInitializer())
5165  return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0));
5166 
5167  return Member->getAnyMember()->getCanonicalDecl();
5168 }
5169 
5171  Sema &SemaRef, const CXXConstructorDecl *Constructor,
5173  if (Constructor->getDeclContext()->isDependentContext())
5174  return;
5175 
5176  // Don't check initializers order unless the warning is enabled at the
5177  // location of at least one initializer.
5178  bool ShouldCheckOrder = false;
5179  for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5180  CXXCtorInitializer *Init = Inits[InitIndex];
5181  if (!SemaRef.Diags.isIgnored(diag::warn_initializer_out_of_order,
5182  Init->getSourceLocation())) {
5183  ShouldCheckOrder = true;
5184  break;
5185  }
5186  }
5187  if (!ShouldCheckOrder)
5188  return;
5189 
5190  // Build the list of bases and members in the order that they'll
5191  // actually be initialized. The explicit initializers should be in
5192  // this same order but may be missing things.
5193  SmallVector<const void*, 32> IdealInitKeys;
5194 
5195  const CXXRecordDecl *ClassDecl = Constructor->getParent();
5196 
5197  // 1. Virtual bases.
5198  for (const auto &VBase : ClassDecl->vbases())
5199  IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase.getType()));
5200 
5201  // 2. Non-virtual bases.
5202  for (const auto &Base : ClassDecl->bases()) {
5203  if (Base.isVirtual())
5204  continue;
5205  IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base.getType()));
5206  }
5207 
5208  // 3. Direct fields.
5209  for (auto *Field : ClassDecl->fields()) {
5210  if (Field->isUnnamedBitfield())
5211  continue;
5212 
5213  PopulateKeysForFields(Field, IdealInitKeys);
5214  }
5215 
5216  unsigned NumIdealInits = IdealInitKeys.size();
5217  unsigned IdealIndex = 0;
5218 
5219  CXXCtorInitializer *PrevInit = nullptr;
5220  for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5221  CXXCtorInitializer *Init = Inits[InitIndex];
5222  const void *InitKey = GetKeyForMember(SemaRef.Context, Init);
5223 
5224  // Scan forward to try to find this initializer in the idealized
5225  // initializers list.
5226  for (; IdealIndex != NumIdealInits; ++IdealIndex)
5227  if (InitKey == IdealInitKeys[IdealIndex])
5228  break;
5229 
5230  // If we didn't find this initializer, it must be because we
5231  // scanned past it on a previous iteration. That can only
5232  // happen if we're out of order; emit a warning.
5233  if (IdealIndex == NumIdealInits && PrevInit) {
5235  SemaRef.Diag(PrevInit->getSourceLocation(),
5236  diag::warn_initializer_out_of_order);
5237 
5238  if (PrevInit->isAnyMemberInitializer())
5239  D << 0 << PrevInit->getAnyMember()->getDeclName();
5240  else
5241  D << 1 << PrevInit->getTypeSourceInfo()->getType();
5242 
5243  if (Init->isAnyMemberInitializer())
5244  D << 0 << Init->getAnyMember()->getDeclName();
5245  else
5246  D << 1 << Init->getTypeSourceInfo()->getType();
5247 
5248  // Move back to the initializer's location in the ideal list.
5249  for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
5250  if (InitKey == IdealInitKeys[IdealIndex])
5251  break;
5252 
5253  assert(IdealIndex < NumIdealInits &&
5254  "initializer not found in initializer list");
5255  }
5256 
5257  PrevInit = Init;
5258  }
5259 }
5260 
5261 namespace {
5262 bool CheckRedundantInit(Sema &S,
5263  CXXCtorInitializer *Init,
5264  CXXCtorInitializer *&PrevInit) {
5265  if (!PrevInit) {
5266  PrevInit = Init;
5267  return false;
5268  }
5269 
5270  if (FieldDecl *Field = Init->getAnyMember())
5271  S.Diag(Init->getSourceLocation(),
5272  diag::err_multiple_mem_initialization)
5273  << Field->getDeclName()
5274  << Init->getSourceRange();
5275  else {
5276  const Type *BaseClass = Init->getBaseClass();
5277  assert(BaseClass && "neither field nor base");
5278  S.Diag(Init->getSourceLocation(),
5279  diag::err_multiple_base_initialization)
5280  << QualType(BaseClass, 0)
5281  << Init->getSourceRange();
5282  }
5283  S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer)
5284  << 0 << PrevInit->getSourceRange();
5285 
5286  return true;
5287 }
5288 
5289 typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
5290 typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
5291 
5292 bool CheckRedundantUnionInit(Sema &S,
5293  CXXCtorInitializer *Init,
5294  RedundantUnionMap &Unions) {
5295  FieldDecl *Field = Init->getAnyMember();
5296  RecordDecl *Parent = Field->getParent();
5297  NamedDecl *Child = Field;
5298 
5299  while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {
5300  if (Parent->isUnion()) {
5301  UnionEntry &En = Unions[Parent];
5302  if (En.first && En.first != Child) {
5303  S.Diag(Init->getSourceLocation(),
5304  diag::err_multiple_mem_union_initialization)
5305  << Field->getDeclName()
5306  << Init->getSourceRange();
5307  S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
5308  << 0 << En.second->getSourceRange();
5309  return true;
5310  }
5311  if (!En.first) {
5312  En.first = Child;
5313  En.second = Init;
5314  }
5315  if (!Parent->isAnonymousStructOrUnion())
5316  return false;
5317  }
5318 
5319  Child = Parent;
5320  Parent = cast<RecordDecl>(Parent->getDeclContext());
5321  }
5322 
5323  return false;
5324 }
5325 }
5326 
5327 /// ActOnMemInitializers - Handle the member initializers for a constructor.
5328 void Sema::ActOnMemInitializers(Decl *ConstructorDecl,
5331  bool AnyErrors) {
5332  if (!ConstructorDecl)
5333  return;
5334 
5335  AdjustDeclIfTemplate(ConstructorDecl);
5336 
5337  CXXConstructorDecl *Constructor
5338  = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
5339 
5340  if (!Constructor) {
5341  Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
5342  return;
5343  }
5344 
5345  // Mapping for the duplicate initializers check.
5346  // For member initializers, this is keyed with a FieldDecl*.
5347  // For base initializers, this is keyed with a Type*.
5348  llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
5349 
5350  // Mapping for the inconsistent anonymous-union initializers check.
5351  RedundantUnionMap MemberUnions;
5352 
5353  bool HadError = false;
5354  for (unsigned i = 0; i < MemInits.size(); i++) {
5355  CXXCtorInitializer *Init = MemInits[i];
5356 
5357  // Set the source order index.
5358  Init->setSourceOrder(i);
5359 
5360  if (Init->isAnyMemberInitializer()) {
5361  const void *Key = GetKeyForMember(Context, Init);
5362  if (CheckRedundantInit(*this, Init, Members[Key]) ||
5363  CheckRedundantUnionInit(*this, Init, MemberUnions))
5364  HadError = true;
5365  } else if (Init->isBaseInitializer()) {
5366  const void *Key = GetKeyForMember(Context, Init);
5367  if (CheckRedundantInit(*this, Init, Members[Key]))
5368  HadError = true;
5369  } else {
5370  assert(Init->isDelegatingInitializer());
5371  // This must be the only initializer
5372  if (MemInits.size() != 1) {
5373  Diag(Init->getSourceLocation(),
5374  diag::err_delegating_initializer_alone)
5375  << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
5376  // We will treat this as being the only initializer.
5377  }
5378  SetDelegatingInitializer(Constructor, MemInits[i]);
5379  // Return immediately as the initializer is set.
5380  return;
5381  }
5382  }
5383 
5384  if (HadError)
5385  return;
5386 
5387  DiagnoseBaseOrMemInitializerOrder(*this, Constructor, MemInits);
5388 
5389  SetCtorInitializers(Constructor, AnyErrors, MemInits);
5390 
5391  DiagnoseUninitializedFields(*this, Constructor);
5392 }
5393 
5394 void
5396  CXXRecordDecl *ClassDecl) {
5397  // Ignore dependent contexts. Also ignore unions, since their members never
5398  // have destructors implicitly called.
5399  if (ClassDecl->isDependentContext() || ClassDecl->isUnion())
5400  return;
5401 
5402  // FIXME: all the access-control diagnostics are positioned on the
5403  // field/base declaration. That's probably good; that said, the
5404  // user might reasonably want to know why the destructor is being
5405  // emitted, and we currently don't say.
5406 
5407  // Non-static data members.
5408  for (auto *Field : ClassDecl->fields()) {
5409  if (Field->isInvalidDecl())
5410  continue;
5411 
5412  // Don't destroy incomplete or zero-length arrays.
5413  if (isIncompleteOrZeroLengthArrayType(Context, Field->getType()))
5414  continue;
5415 
5416  QualType FieldType = Context.getBaseElementType(Field->getType());
5417 
5418  const RecordType* RT = FieldType->getAs<RecordType>();
5419  if (!RT)
5420  continue;
5421 
5422  CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
5423  if (FieldClassDecl->isInvalidDecl())
5424  continue;
5425  if (FieldClassDecl->hasIrrelevantDestructor())
5426  continue;
5427  // The destructor for an implicit anonymous union member is never invoked.
5428  if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
5429  continue;
5430 
5431  CXXDestructorDecl *Dtor = LookupDestructor(FieldClassDecl);
5432  assert(Dtor && "No dtor found for FieldClassDecl!");
5433  CheckDestructorAccess(Field->getLocation(), Dtor,
5434  PDiag(diag::err_access_dtor_field)
5435  << Field->getDeclName()
5436  << FieldType);
5437 
5438  MarkFunctionReferenced(Location, Dtor);
5439  DiagnoseUseOfDecl(Dtor, Location);
5440  }
5441 
5442  // We only potentially invoke the destructors of potentially constructed
5443  // subobjects.
5444  bool VisitVirtualBases = !ClassDecl->isAbstract();
5445 
5446  llvm::SmallPtrSet<const RecordType *, 8> DirectVirtualBases;
5447 
5448  // Bases.
5449  for (const auto &Base : ClassDecl->bases()) {
5450  // Bases are always records in a well-formed non-dependent class.
5451  const RecordType *RT = Base.getType()->getAs<RecordType>();
5452 
5453  // Remember direct virtual bases.
5454  if (Base.isVirtual()) {
5455  if (!VisitVirtualBases)
5456  continue;
5457  DirectVirtualBases.insert(RT);
5458  }
5459 
5460  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
5461  // If our base class is invalid, we probably can't get its dtor anyway.
5462  if (BaseClassDecl->isInvalidDecl())
5463  continue;
5464  if (BaseClassDecl->hasIrrelevantDestructor())
5465  continue;
5466 
5467  CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
5468  assert(Dtor && "No dtor found for BaseClassDecl!");
5469 
5470  // FIXME: caret should be on the start of the class name
5471  CheckDestructorAccess(Base.getBeginLoc(), Dtor,
5472  PDiag(diag::err_access_dtor_base)
5473  << Base.getType() << Base.getSourceRange(),
5474  Context.getTypeDeclType(ClassDecl));
5475 
5476  MarkFunctionReferenced(Location, Dtor);
5477  DiagnoseUseOfDecl(Dtor, Location);
5478  }
5479 
5480  if (!VisitVirtualBases)
5481  return;
5482 
5483  // Virtual bases.
5484  for (const auto &VBase : ClassDecl->vbases()) {
5485  // Bases are always records in a well-formed non-dependent class.
5486  const RecordType *RT = VBase.getType()->castAs<RecordType>();
5487 
5488  // Ignore direct virtual bases.
5489  if (DirectVirtualBases.count(RT))
5490  continue;
5491 
5492  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
5493  // If our base class is invalid, we probably can't get its dtor anyway.
5494  if (BaseClassDecl->isInvalidDecl())
5495  continue;
5496  if (BaseClassDecl->hasIrrelevantDestructor())
5497  continue;
5498 
5499  CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
5500  assert(Dtor && "No dtor found for BaseClassDecl!");
5501  if (CheckDestructorAccess(
5502  ClassDecl->getLocation(), Dtor,
5503  PDiag(diag::err_access_dtor_vbase)
5504  << Context.getTypeDeclType(ClassDecl) << VBase.getType(),
5505  Context.getTypeDeclType(ClassDecl)) ==
5506  AR_accessible) {
5507  CheckDerivedToBaseConversion(
5508  Context.getTypeDeclType(ClassDecl), VBase.getType(),
5509  diag::err_access_dtor_vbase, 0, ClassDecl->getLocation(),
5510  SourceRange(), DeclarationName(), nullptr);
5511  }
5512 
5513  MarkFunctionReferenced(Location, Dtor);
5514  DiagnoseUseOfDecl(Dtor, Location);
5515  }
5516 }
5517 
5518 void Sema::ActOnDefaultCtorInitializers(Decl *CDtorDecl) {
5519  if (!CDtorDecl)
5520  return;
5521 
5522  if (CXXConstructorDecl *Constructor
5523  = dyn_cast<CXXConstructorDecl>(CDtorDecl)) {
5524  SetCtorInitializers(Constructor, /*AnyErrors=*/false);
5525  DiagnoseUninitializedFields(*this, Constructor);
5526  }
5527 }
5528 
5530  if (!getLangOpts().CPlusPlus)
5531  return false;
5532 
5533  const auto *RD = Context.getBaseElementType(T)->getAsCXXRecordDecl();
5534  if (!RD)
5535  return false;
5536 
5537  // FIXME: Per [temp.inst]p1, we are supposed to trigger instantiation of a
5538  // class template specialization here, but doing so breaks a lot of code.
5539 
5540  // We can't answer whether something is abstract until it has a
5541  // definition. If it's currently being defined, we'll walk back
5542  // over all the declarations when we have a full definition.
5543  const CXXRecordDecl *Def = RD->getDefinition();
5544  if (!Def || Def->isBeingDefined())
5545  return false;
5546 
5547  return RD->isAbstract();
5548 }
5549 
5551  TypeDiagnoser &Diagnoser) {
5552  if (!isAbstractType(Loc, T))
5553  return false;
5554 
5555  T = Context.getBaseElementType(T);
5556  Diagnoser.diagnose(*this, Loc, T);
5557  DiagnoseAbstractType(T->getAsCXXRecordDecl());
5558  return true;
5559 }
5560 
5562  // Check if we've already emitted the list of pure virtual functions
5563  // for this class.
5564  if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
5565  return;
5566 
5567  // If the diagnostic is suppressed, don't emit the notes. We're only
5568  // going to emit them once, so try to attach them to a diagnostic we're
5569  // actually going to show.
5570  if (Diags.isLastDiagnosticIgnored())
5571  return;
5572 
5573  CXXFinalOverriderMap FinalOverriders;
5574  RD->getFinalOverriders(FinalOverriders);
5575 
5576  // Keep a set of seen pure methods so we won't diagnose the same method
5577  // more than once.
5578  llvm::SmallPtrSet<const CXXMethodDecl *, 8> SeenPureMethods;
5579 
5580  for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
5581  MEnd = FinalOverriders.end();
5582  M != MEnd;
5583  ++M) {
5584  for (OverridingMethods::iterator SO = M->second.begin(),
5585  SOEnd = M->second.end();
5586  SO != SOEnd; ++SO) {
5587  // C++ [class.abstract]p4:
5588  // A class is abstract if it contains or inherits at least one
5589  // pure virtual function for which the final overrider is pure
5590  // virtual.
5591 
5592  //
5593  if (SO->second.size() != 1)
5594  continue;
5595 
5596  if (!SO->second.front().Method->isPure())
5597  continue;
5598 
5599  if (!SeenPureMethods.insert(SO->second.front().Method).second)
5600  continue;
5601 
5602  Diag(SO->second.front().Method->getLocation(),
5603  diag::note_pure_virtual_function)
5604  << SO->second.front().Method->getDeclName() << RD->getDeclName();
5605  }
5606  }
5607 
5608  if (!PureVirtualClassDiagSet)
5609  PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
5610  PureVirtualClassDiagSet->insert(RD);
5611 }
5612 
5613 namespace {
5614 struct AbstractUsageInfo {
5615  Sema &S;
5616  CXXRecordDecl *Record;
5617  CanQualType AbstractType;
5618  bool Invalid;
5619 
5620  AbstractUsageInfo(Sema &S, CXXRecordDecl *Record)
5621  : S(S), Record(Record),
5622  AbstractType(S.Context.getCanonicalType(
5623  S.Context.getTypeDeclType(Record))),
5624  Invalid(false) {}
5625 
5626  void DiagnoseAbstractType() {
5627  if (Invalid) return;
5628  S.DiagnoseAbstractType(Record);
5629  Invalid = true;
5630  }
5631 
5632  void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
5633 };
5634 
5635 struct CheckAbstractUsage {
5636  AbstractUsageInfo &Info;
5637  const NamedDecl *Ctx;
5638 
5639  CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
5640  : Info(Info), Ctx(Ctx) {}
5641 
5642  void Visit(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
5643  switch (TL.getTypeLocClass()) {
5644 #define ABSTRACT_TYPELOC(CLASS, PARENT)
5645 #define TYPELOC(CLASS, PARENT) \
5646  case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
5647 #include "clang/AST/TypeLocNodes.def"
5648  }
5649  }
5650 
5651  void Check(FunctionProtoTypeLoc TL, Sema::AbstractDiagSelID Sel) {
5653  for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {
5654  if (!TL.getParam(I))
5655  continue;
5656 
5657  TypeSourceInfo *TSI = TL.getParam(I)->getTypeSourceInfo();
5658  if (TSI) Visit(TSI->getTypeLoc(), Sema::AbstractParamType);
5659  }
5660  }
5661 
5662  void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) {
5664  }
5665 
5667  // Visit the type parameters from a permissive context.
5668  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
5669  TemplateArgumentLoc TAL = TL.getArgLoc(I);
5671  if (TypeSourceInfo *TSI = TAL.getTypeSourceInfo())
5672  Visit(TSI->getTypeLoc(), Sema::AbstractNone);
5673  // TODO: other template argument types?
5674  }
5675  }
5676 
5677  // Visit pointee types from a permissive context.
5678 #define CheckPolymorphic(Type) \
5679  void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
5680  Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
5681  }
5687 
5688  /// Handle all the types we haven't given a more specific
5689  /// implementation for above.
5690  void Check(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
5691  // Every other kind of type that we haven't called out already
5692  // that has an inner type is either (1) sugar or (2) contains that
5693  // inner type in some way as a subobject.
5694  if (TypeLoc Next = TL.getNextTypeLoc())
5695  return Visit(Next, Sel);
5696 
5697  // If there's no inner type and we're in a permissive context,
5698  // don't diagnose.
5699  if (Sel == Sema::AbstractNone) return;
5700 
5701  // Check whether the type matches the abstract type.
5702  QualType T = TL.getType();
5703  if (T->isArrayType()) {
5705  T = Info.S.Context.getBaseElementType(T);
5706  }
5708  if (CT != Info.AbstractType) return;
5709 
5710  // It matched; do some magic.
5711  if (Sel == Sema::AbstractArrayType) {
5712  Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type)
5713  << T << TL.getSourceRange();
5714  } else {
5715  Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl)
5716  << Sel << T << TL.getSourceRange();
5717  }
5718  Info.DiagnoseAbstractType();
5719  }
5720 };
5721 
5722 void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
5724  CheckAbstractUsage(*this, D).Visit(TL, Sel);
5725 }
5726 
5727 }
5728 
5729 /// Check for invalid uses of an abstract type in a method declaration.
5730 static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
5731  CXXMethodDecl *MD) {
5732  // No need to do the check on definitions, which require that
5733  // the return/param types be complete.
5734  if (MD->doesThisDeclarationHaveABody())
5735  return;
5736 
5737  // For safety's sake, just ignore it if we don't have type source
5738  // information. This should never happen for non-implicit methods,
5739  // but...
5740  if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
5741  Info.CheckType(MD, TSI->getTypeLoc(), Sema::AbstractNone);
5742 }
5743 
5744 /// Check for invalid uses of an abstract type within a class definition.
5745 static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
5746  CXXRecordDecl *RD) {
5747  for (auto *D : RD->decls()) {
5748  if (D->isImplicit()) continue;
5749 
5750  // Methods and method templates.
5751  if (isa<CXXMethodDecl>(D)) {
5752  CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(D));
5753  } else if (isa<FunctionTemplateDecl>(D)) {
5754  FunctionDecl *FD = cast<FunctionTemplateDecl>(D)->getTemplatedDecl();
5755  CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(FD));
5756 
5757  // Fields and static variables.
5758  } else if (isa<FieldDecl>(D)) {
5759  FieldDecl *FD = cast<FieldDecl>(D);
5760  if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
5761  Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractFieldType);
5762  } else if (isa<VarDecl>(D)) {
5763  VarDecl *VD = cast<VarDecl>(D);
5764  if (TypeSourceInfo *TSI = VD->getTypeSourceInfo())
5765  Info.CheckType(VD, TSI->getTypeLoc(), Sema::AbstractVariableType);
5766 
5767  // Nested classes and class templates.
5768  } else if (isa<CXXRecordDecl>(D)) {
5769  CheckAbstractClassUsage(Info, cast<CXXRecordDecl>(D));
5770  } else if (isa<ClassTemplateDecl>(D)) {
5772  cast<ClassTemplateDecl>(D)->getTemplatedDecl());
5773  }
5774  }
5775 }
5776 
5778  Attr *ClassAttr = getDLLAttr(Class);
5779  if (!ClassAttr)
5780  return;
5781 
5782  assert(ClassAttr->getKind() == attr::DLLExport);
5783 
5785 
5787  // Don't go any further if this is just an explicit instantiation
5788  // declaration.
5789  return;
5790 
5791  if (S.Context.getTargetInfo().getTriple().isWindowsGNUEnvironment())
5792  S.MarkVTableUsed(Class->getLocation(), Class, true);
5793 
5794  for (Decl *Member : Class->decls()) {
5795  // Defined static variables that are members of an exported base
5796  // class must be marked export too.
5797  auto *VD = dyn_cast<VarDecl>(Member);
5798  if (VD && Member->getAttr<DLLExportAttr>() &&
5799  VD->getStorageClass() == SC_Static &&
5801  S.MarkVariableReferenced(VD->getLocation(), VD);
5802 
5803  auto *MD = dyn_cast<CXXMethodDecl>(Member);
5804  if (!MD)
5805  continue;
5806 
5807  if (Member->getAttr<DLLExportAttr>()) {
5808  if (MD->isUserProvided()) {
5809  // Instantiate non-default class member functions ...
5810 
5811  // .. except for certain kinds of template specializations.
5812  if (TSK == TSK_ImplicitInstantiation && !ClassAttr->isInherited())
5813  continue;
5814 
5815  S.MarkFunctionReferenced(Class->getLocation(), MD);
5816 
5817  // The function will be passed to the consumer when its definition is
5818  // encountered.
5819  } else if (!MD->isTrivial() || MD->isExplicitlyDefaulted() ||
5820  MD->isCopyAssignmentOperator() ||
5821  MD->isMoveAssignmentOperator()) {
5822  // Synthesize and instantiate non-trivial implicit methods, explicitly
5823  // defaulted methods, and the copy and move assignment operators. The
5824  // latter are exported even if they are trivial, because the address of
5825  // an operator can be taken and should compare equal across libraries.
5826  DiagnosticErrorTrap Trap(S.Diags);
5827  S.MarkFunctionReferenced(Class->getLocation(), MD);
5828  if (Trap.hasErrorOccurred()) {
5829  S.Diag(ClassAttr->getLocation(), diag::note_due_to_dllexported_class)
5830  << Class << !S.getLangOpts().CPlusPlus11;
5831  break;
5832  }
5833 
5834  // There is no later point when we will see the definition of this
5835  // function, so pass it to the consumer now.
5837  }
5838  }
5839  }
5840 }
5841 
5843  CXXRecordDecl *Class) {
5844  // Only the MS ABI has default constructor closures, so we don't need to do
5845  // this semantic checking anywhere else.
5847  return;
5848 
5849  CXXConstructorDecl *LastExportedDefaultCtor = nullptr;
5850  for (Decl *Member : Class->decls()) {
5851  // Look for exported default constructors.
5852  auto *CD = dyn_cast<CXXConstructorDecl>(Member);
5853  if (!CD || !CD->isDefaultConstructor())
5854  continue;
5855  auto *Attr = CD->getAttr<DLLExportAttr>();
5856  if (!Attr)
5857  continue;
5858 
5859  // If the class is non-dependent, mark the default arguments as ODR-used so
5860  // that we can properly codegen the constructor closure.
5861  if (!Class->isDependentContext()) {
5862  for (ParmVarDecl *PD : CD->parameters()) {
5863  (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), CD, PD);
5865  }
5866  }
5867 
5868  if (LastExportedDefaultCtor) {
5869  S.Diag(LastExportedDefaultCtor->getLocation(),
5870  diag::err_attribute_dll_ambiguous_default_ctor)
5871  << Class;
5872  S.Diag(CD->getLocation(), diag::note_entity_declared_at)
5873  << CD->getDeclName();
5874  return;
5875  }
5876  LastExportedDefaultCtor = CD;
5877  }
5878 }
5879 
5881  // Mark any compiler-generated routines with the implicit code_seg attribute.
5882  for (auto *Method : Class->methods()) {
5883  if (Method->isUserProvided())
5884  continue;
5885  if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(Method, /*IsDefinition=*/true))
5886  Method->addAttr(A);
5887  }
5888 }
5889 
5890 /// Check class-level dllimport/dllexport attribute.
5892  Attr *ClassAttr = getDLLAttr(Class);
5893 
5894  // MSVC inherits DLL attributes to partial class template specializations.
5895  if (Context.getTargetInfo().getCXXABI().isMicrosoft() && !ClassAttr) {
5896  if (auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(Class)) {
5897  if (Attr *TemplateAttr =
5898  getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
5899  auto *A = cast<InheritableAttr>(TemplateAttr->clone(getASTContext()));
5900  A->setInherited(true);
5901  ClassAttr = A;
5902  }
5903  }
5904  }
5905 
5906  if (!ClassAttr)
5907  return;
5908 
5909  if (!Class->isExternallyVisible()) {
5910  Diag(Class->getLocation(), diag::err_attribute_dll_not_extern)
5911  << Class << ClassAttr;
5912  return;
5913  }
5914 
5915  if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
5916  !ClassAttr->isInherited()) {
5917  // Diagnose dll attributes on members of class with dll attribute.
5918  for (Decl *Member : Class->decls()) {
5919  if (!isa<VarDecl>(Member) && !isa<CXXMethodDecl>(Member))
5920  continue;
5921  InheritableAttr *MemberAttr = getDLLAttr(Member);
5922  if (!MemberAttr || MemberAttr->isInherited() || Member->isInvalidDecl())
5923  continue;
5924 
5925  Diag(MemberAttr->getLocation(),
5926  diag::err_attribute_dll_member_of_dll_class)
5927  << MemberAttr << ClassAttr;
5928  Diag(ClassAttr->getLocation(), diag::note_previous_attribute);
5929  Member->setInvalidDecl();
5930  }
5931  }
5932 
5933  if (Class->getDescribedClassTemplate())
5934  // Don't inherit dll attribute until the template is instantiated.
5935  return;
5936 
5937  // The class is either imported or exported.
5938  const bool ClassExported = ClassAttr->getKind() == attr::DLLExport;
5939 
5940  // Check if this was a dllimport attribute propagated from a derived class to
5941  // a base class template specialization. We don't apply these attributes to
5942  // static data members.
5943  const bool PropagatedImport =
5944  !ClassExported &&
5945  cast<DLLImportAttr>(ClassAttr)->wasPropagatedToBaseTemplate();
5946 
5948 
5949  // Ignore explicit dllexport on explicit class template instantiation
5950  // declarations, except in MinGW mode.
5951  if (ClassExported && !ClassAttr->isInherited() &&
5953  !Context.getTargetInfo().getTriple().isWindowsGNUEnvironment()) {
5954  Class->dropAttr<DLLExportAttr>();
5955  return;
5956  }
5957 
5958  // Force declaration of implicit members so they can inherit the attribute.
5959  ForceDeclarationOfImplicitMembers(Class);
5960 
5961  // FIXME: MSVC's docs say all bases must be exportable, but this doesn't
5962  // seem to be true in practice?
5963 
5964  for (Decl *Member : Class->decls()) {
5965  VarDecl *VD = dyn_cast<VarDecl>(Member);
5966  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Member);
5967 
5968  // Only methods and static fields inherit the attributes.
5969  if (!VD && !MD)
5970  continue;
5971 
5972  if (MD) {
5973  // Don't process deleted methods.
5974  if (MD->isDeleted())
5975  continue;
5976 
5977  if (MD->isInlined()) {
5978  // MinGW does not import or export inline methods. But do it for
5979  // template instantiations.
5980  if (!Context.getTargetInfo().getCXXABI().isMicrosoft() &&
5981  !Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment() &&
5984  continue;
5985 
5986  // MSVC versions before 2015 don't export the move assignment operators
5987  // and move constructor, so don't attempt to import/export them if
5988  // we have a definition.
5989  auto *Ctor = dyn_cast<CXXConstructorDecl>(MD);
5990  if ((MD->isMoveAssignmentOperator() ||
5991  (Ctor && Ctor->isMoveConstructor())) &&
5992  !getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015))
5993  continue;
5994 
5995  // MSVC2015 doesn't export trivial defaulted x-tor but copy assign
5996  // operator is exported anyway.
5997  if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
5998  (Ctor || isa<CXXDestructorDecl>(MD)) && MD->isTrivial())
5999  continue;
6000  }
6001  }
6002 
6003  // Don't apply dllimport attributes to static data members of class template
6004  // instantiations when the attribute is propagated from a derived class.
6005  if (VD && PropagatedImport)
6006  continue;
6007 
6008  if (!cast<NamedDecl>(Member)->isExternallyVisible())
6009  continue;
6010 
6011  if (!getDLLAttr(Member)) {
6012  InheritableAttr *NewAttr = nullptr;
6013 
6014  // Do not export/import inline function when -fno-dllexport-inlines is
6015  // passed. But add attribute for later local static var check.
6016  if (!getLangOpts().DllExportInlines && MD && MD->isInlined() &&
6019  if (ClassExported) {
6020  NewAttr = ::new (getASTContext())
6021  DLLExportStaticLocalAttr(getASTContext(), *ClassAttr);
6022  } else {
6023  NewAttr = ::new (getASTContext())
6024  DLLImportStaticLocalAttr(getASTContext(), *ClassAttr);
6025  }
6026  } else {
6027  NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
6028  }
6029 
6030  NewAttr->setInherited(true);
6031  Member->addAttr(NewAttr);
6032 
6033  if (MD) {
6034  // Propagate DLLAttr to friend re-declarations of MD that have already
6035  // been constructed.
6036  for (FunctionDecl *FD = MD->getMostRecentDecl(); FD;
6037  FD = FD->getPreviousDecl()) {
6038  if (FD->getFriendObjectKind() == Decl::FOK_None)
6039  continue;
6040  assert(!getDLLAttr(FD) &&
6041  "friend re-decl should not already have a DLLAttr");
6042  NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
6043  NewAttr->setInherited(true);
6044  FD->addAttr(NewAttr);
6045  }
6046  }
6047  }
6048  }
6049 
6050  if (ClassExported)
6051  DelayedDllExportClasses.push_back(Class);
6052 }
6053 
6054 /// Perform propagation of DLL attributes from a derived class to a
6055 /// templated base class for MS compatibility.
6057  CXXRecordDecl *Class, Attr *ClassAttr,
6058  ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc) {
6059  if (getDLLAttr(
6060  BaseTemplateSpec->getSpecializedTemplate()->getTemplatedDecl())) {
6061  // If the base class template has a DLL attribute, don't try to change it.
6062  return;
6063  }
6064 
6065  auto TSK = BaseTemplateSpec->getSpecializationKind();
6066  if (!getDLLAttr(BaseTemplateSpec) &&
6068  TSK == TSK_ImplicitInstantiation)) {
6069  // The template hasn't been instantiated yet (or it has, but only as an
6070  // explicit instantiation declaration or implicit instantiation, which means
6071  // we haven't codegenned any members yet), so propagate the attribute.
6072  auto *NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
6073  NewAttr->setInherited(true);
6074  BaseTemplateSpec->addAttr(NewAttr);
6075 
6076  // If this was an import, mark that we propagated it from a derived class to
6077  // a base class template specialization.
6078  if (auto *ImportAttr = dyn_cast<DLLImportAttr>(NewAttr))
6079  ImportAttr->setPropagatedToBaseTemplate();
6080 
6081  // If the template is already instantiated, checkDLLAttributeRedeclaration()
6082  // needs to be run again to work see the new attribute. Otherwise this will
6083  // get run whenever the template is instantiated.
6084  if (TSK != TSK_Undeclared)
6085  checkClassLevelDLLAttribute(BaseTemplateSpec);
6086 
6087  return;
6088  }
6089 
6090  if (getDLLAttr(BaseTemplateSpec)) {
6091  // The template has already been specialized or instantiated with an
6092  // attribute, explicitly or through propagation. We should not try to change
6093  // it.
6094  return;
6095  }
6096 
6097  // The template was previously instantiated or explicitly specialized without
6098  // a dll attribute, It's too late for us to add an attribute, so warn that
6099  // this is unsupported.
6100  Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)
6101  << BaseTemplateSpec->isExplicitSpecialization();
6102  Diag(ClassAttr->getLocation(), diag::note_attribute);
6103  if (BaseTemplateSpec->isExplicitSpecialization()) {
6104  Diag(BaseTemplateSpec->getLocation(),
6105  diag::note_template_class_explicit_specialization_was_here)
6106  << BaseTemplateSpec;
6107  } else {
6108  Diag(BaseTemplateSpec->getPointOfInstantiation(),
6109  diag::note_template_class_instantiation_was_here)
6110  << BaseTemplateSpec;
6111  }
6112 }
6113 
6114 /// Determine the kind of defaulting that would be done for a given function.
6115 ///
6116 /// If the function is both a default constructor and a copy / move constructor
6117 /// (due to having a default argument for the first parameter), this picks
6118 /// CXXDefaultConstructor.
6119 ///
6120 /// FIXME: Check that case is properly handled by all callers.
6123  if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
6124  if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
6125  if (Ctor->isDefaultConstructor())
6127 
6128  if (Ctor->isCopyConstructor())
6129  return Sema::CXXCopyConstructor;
6130 
6131  if (Ctor->isMoveConstructor())
6132  return Sema::CXXMoveConstructor;
6133  }
6134 
6135  if (MD->isCopyAssignmentOperator())
6136  return Sema::CXXCopyAssignment;
6137 
6138  if (MD->isMoveAssignmentOperator())
6139  return Sema::CXXMoveAssignment;
6140 
6141  if (isa<CXXDestructorDecl>(FD))
6142  return Sema::CXXDestructor;
6143  }
6144 
6145  switch (FD->getDeclName().getCXXOverloadedOperator()) {
6146  case OO_EqualEqual:
6148 
6149  case OO_ExclaimEqual:
6150  return DefaultedComparisonKind::NotEqual;
6151 
6152  case OO_Spaceship:
6153  // No point allowing this if <=> doesn't exist in the current language mode.
6154  if (!getLangOpts().CPlusPlus2a)
6155  break;
6156  return DefaultedComparisonKind::ThreeWay;
6157 
6158  case OO_Less:
6159  case OO_LessEqual:
6160  case OO_Greater:
6161  case OO_GreaterEqual:
6162  // No point allowing this if <=> doesn't exist in the current language mode.
6163  if (!getLangOpts().CPlusPlus2a)
6164  break;
6166 
6167  default:
6168  break;
6169  }
6170 
6171  // Not defaultable.
6172  return DefaultedFunctionKind();
6173 }
6174 
6176  SourceLocation DefaultLoc) {
6177  switch (S.getSpecialMember(MD)) {
6179  S.DefineImplicitDefaultConstructor(DefaultLoc,
6180  cast<CXXConstructorDecl>(MD));
6181  break;
6183  S.DefineImplicitCopyConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
6184  break;
6186  S.DefineImplicitCopyAssignment(DefaultLoc, MD);
6187  break;
6188  case Sema::CXXDestructor:
6189  S.DefineImplicitDestructor(DefaultLoc, cast<CXXDestructorDecl>(MD));
6190  break;
6192  S.DefineImplicitMoveConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
6193  break;
6195  S.DefineImplicitMoveAssignment(DefaultLoc, MD);
6196  break;
6197  case Sema::CXXInvalid:
6198  llvm_unreachable("Invalid special member.");
6199  }
6200 }
6201 
6202 /// Determine whether a type is permitted to be passed or returned in
6203 /// registers, per C++ [class.temporary]p3.
6206  if (D->isDependentType() || D->isInvalidDecl())
6207  return false;
6208 
6209  // Clang <= 4 used the pre-C++11 rule, which ignores move operations.
6210  // The PS4 platform ABI follows the behavior of Clang 3.2.
6211  if (CCK == TargetInfo::CCK_ClangABI4OrPS4)
6212  return !D->hasNonTrivialDestructorForCall() &&
6214 
6215  if (CCK == TargetInfo::CCK_MicrosoftWin64) {
6216  bool CopyCtorIsTrivial = false, CopyCtorIsTrivialForCall = false;
6217  bool DtorIsTrivialForCall = false;
6218 
6219  // If a class has at least one non-deleted, trivial copy constructor, it
6220  // is passed according to the C ABI. Otherwise, it is passed indirectly.
6221  //
6222  // Note: This permits classes with non-trivial copy or move ctors to be
6223  // passed in registers, so long as they *also* have a trivial copy ctor,
6224  // which is non-conforming.
6225  if (D->needsImplicitCopyConstructor()) {
6227  if (D->hasTrivialCopyConstructor())
6228  CopyCtorIsTrivial = true;
6230  CopyCtorIsTrivialForCall = true;
6231  }
6232  } else {
6233  for (const CXXConstructorDecl *CD : D->ctors()) {
6234  if (CD->isCopyConstructor() && !CD->isDeleted()) {
6235  if (CD->isTrivial())
6236  CopyCtorIsTrivial = true;
6237  if (CD->isTrivialForCall())
6238  CopyCtorIsTrivialForCall = true;
6239  }
6240  }
6241  }
6242 
6243  if (D->needsImplicitDestructor()) {
6244  if (!D->defaultedDestructorIsDeleted() &&
6246  DtorIsTrivialForCall = true;
6247  } else if (const auto *DD = D->getDestructor()) {
6248  if (!DD->isDeleted() && DD->isTrivialForCall())
6249  DtorIsTrivialForCall = true;
6250  }
6251 
6252  // If the copy ctor and dtor are both trivial-for-calls, pass direct.
6253  if (CopyCtorIsTrivialForCall && DtorIsTrivialForCall)
6254  return true;
6255 
6256  // If a class has a destructor, we'd really like to pass it indirectly
6257  // because it allows us to elide copies. Unfortunately, MSVC makes that
6258  // impossible for small types, which it will pass in a single register or
6259  // stack slot. Most objects with dtors are large-ish, so handle that early.
6260  // We can't call out all large objects as being indirect because there are
6261  // multiple x64 calling conventions and the C++ ABI code shouldn't dictate
6262  // how we pass large POD types.
6263 
6264  // Note: This permits small classes with nontrivial destructors to be
6265  // passed in registers, which is non-conforming.
6266  bool isAArch64 = S.Context.getTargetInfo().getTriple().isAArch64();
6267  uint64_t TypeSize = isAArch64 ? 128 : 64;
6268 
6269  if (CopyCtorIsTrivial &&
6270  S.getASTContext().getTypeSize(D->getTypeForDecl()) <= TypeSize)
6271  return true;
6272  return false;
6273  }
6274 
6275  // Per C++ [class.temporary]p3, the relevant condition is:
6276  // each copy constructor, move constructor, and destructor of X is
6277  // either trivial or deleted, and X has at least one non-deleted copy
6278  // or move constructor
6279  bool HasNonDeletedCopyOrMove = false;
6280 
6281  if (D->needsImplicitCopyConstructor() &&
6284  return false;
6285  HasNonDeletedCopyOrMove = true;
6286  }
6287 
6288  if (S.getLangOpts().CPlusPlus11 && D->needsImplicitMoveConstructor() &&
6291  return false;
6292  HasNonDeletedCopyOrMove = true;
6293  }
6294 
6297  return false;
6298 
6299  for (const CXXMethodDecl *MD : D->methods()) {
6300  if (MD->isDeleted())
6301  continue;
6302 
6303  auto *CD = dyn_cast<CXXConstructorDecl>(MD);
6304  if (CD && CD->isCopyOrMoveConstructor())
6305  HasNonDeletedCopyOrMove = true;
6306  else if (!isa<CXXDestructorDecl>(MD))
6307  continue;
6308 
6309  if (!MD->isTrivialForCall())
6310  return false;
6311  }
6312 
6313  return HasNonDeletedCopyOrMove;
6314 }
6315 
6316 /// Perform semantic checks on a class definition that has been
6317 /// completing, introducing implicitly-declared members, checking for
6318 /// abstract types, etc.
6319 ///
6320 /// \param S The scope in which the class was parsed. Null if we didn't just
6321 /// parse a class definition.
6322 /// \param Record The completed class.
6324  if (!Record)
6325  return;
6326 
6327  if (Record->isAbstract() && !Record->isInvalidDecl()) {
6328  AbstractUsageInfo Info(*this, Record);
6329  CheckAbstractClassUsage(Info, Record);
6330  }
6331 
6332  // If this is not an aggregate type and has no user-declared constructor,
6333  // complain about any non-static data members of reference or const scalar
6334  // type, since they will never get initializers.
6335  if (!Record->isInvalidDecl() && !Record->isDependentType() &&
6336  !Record->isAggregate() && !Record->hasUserDeclaredConstructor() &&
6337  !Record->isLambda()) {
6338  bool Complained = false;
6339  for (const auto *F : Record->fields()) {
6340  if (F->hasInClassInitializer() || F->isUnnamedBitfield())
6341  continue;
6342 
6343  if (F->getType()->isReferenceType() ||
6344  (F->getType().isConstQualified() && F->getType()->isScalarType())) {
6345  if (!Complained) {
6346  Diag(Record->getLocation(), diag::warn_no_constructor_for_refconst)
6347  << Record->getTagKind() << Record;
6348  Complained = true;
6349  }
6350 
6351  Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
6352  << F->getType()->isReferenceType()
6353  << F->getDeclName();
6354  }
6355  }
6356  }
6357 
6358  if (Record->getIdentifier()) {
6359  // C++ [class.mem]p13:
6360  // If T is the name of a class, then each of the following shall have a
6361  // name different from T:
6362  // - every member of every anonymous union that is a member of class T.
6363  //
6364  // C++ [class.mem]p14:
6365  // In addition, if class T has a user-declared constructor (12.1), every
6366  // non-static data member of class T shall have a name different from T.
6367  DeclContext::lookup_result R = Record->lookup(Record->getDeclName());
6368  for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
6369  ++I) {
6370  NamedDecl *D = (*I)->getUnderlyingDecl();
6371  if (((isa<FieldDecl>(D) || isa<UnresolvedUsingValueDecl>(D)) &&
6372  Record->hasUserDeclaredConstructor()) ||
6373  isa<IndirectFieldDecl>(D)) {
6374  Diag((*I)->getLocation(), diag::err_member_name_of_class)
6375  << D->getDeclName();
6376  break;
6377  }
6378  }
6379  }
6380 
6381  // Warn if the class has virtual methods but non-virtual public destructor.
6382  if (Record->isPolymorphic() && !Record->isDependentType()) {
6383  CXXDestructorDecl *dtor = Record->getDestructor();
6384  if ((!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public)) &&
6385  !Record->hasAttr<FinalAttr>())
6386  Diag(dtor ? dtor->getLocation() : Record->getLocation(),
6387  diag::warn_non_virtual_dtor) << Context.getRecordType(Record);
6388  }
6389 
6390  if (Record->isAbstract()) {
6391  if (FinalAttr *FA = Record->getAttr<FinalAttr>()) {
6392  Diag(Record->getLocation(), diag::warn_abstract_final_class)
6393  << FA->isSpelledAsSealed();
6394  DiagnoseAbstractType(Record);
6395  }
6396  }
6397 
6398  // Warn if the class has a final destructor but is not itself marked final.
6399  if (!Record->hasAttr<FinalAttr>()) {
6400  if (const CXXDestructorDecl *dtor = Record->getDestructor()) {
6401  if (const FinalAttr *FA = dtor->getAttr<FinalAttr>()) {
6402  Diag(FA->getLocation(), diag::warn_final_dtor_non_final_class)
6403  << FA->isSpelledAsSealed()
6405  getLocForEndOfToken(Record->getLocation()),
6406  (FA->isSpelledAsSealed() ? " sealed" : " final"));
6407  Diag(Record->getLocation(),
6408  diag::note_final_dtor_non_final_class_silence)
6409  << Context.getRecordType(Record) << FA->isSpelledAsSealed();
6410  }
6411  }
6412  }
6413 
6414  // See if trivial_abi has to be dropped.
6415  if (Record->hasAttr<TrivialABIAttr>())
6416  checkIllFormedTrivialABIStruct(*Record);
6417 
6418  // Set HasTrivialSpecialMemberForCall if the record has attribute
6419  // "trivial_abi".
6420  bool HasTrivialABI = Record->hasAttr<TrivialABIAttr>();
6421 
6422  if (HasTrivialABI)
6424 
6425  // Explicitly-defaulted secondary comparison functions (!=, <, <=, >, >=).
6426  // We check these last because they can depend on the properties of the
6427  // primary comparison functions (==, <=>).
6428  llvm::SmallVector<FunctionDecl*, 5> DefaultedSecondaryComparisons;
6429 
6430  auto CheckForDefaultedFunction = [&](FunctionDecl *FD) {
6431  if (!FD || FD->isInvalidDecl() || !FD->isExplicitlyDefaulted())
6432  return;
6433 
6434  DefaultedFunctionKind DFK = getDefaultedFunctionKind(FD);
6435  if (DFK.asComparison() == DefaultedComparisonKind::NotEqual ||
6437  DefaultedSecondaryComparisons.push_back(FD);
6438  else
6439  CheckExplicitlyDefaultedFunction(S, FD);
6440  };
6441 
6442  auto CompleteMemberFunction = [&](CXXMethodDecl *M) {
6443  // Check whether the explicitly-defaulted members are valid.
6444  CheckForDefaultedFunction(M);
6445 
6446  // Skip the rest of the checks for a member of a dependent class.
6447  if (Record->isDependentType())
6448  return;
6449 
6450  // For an explicitly defaulted or deleted special member, we defer
6451  // determining triviality until the class is complete. That time is now!
6452  CXXSpecialMember CSM = getSpecialMember(M);
6453  if (!M->isImplicit() && !M->isUserProvided()) {
6454  if (CSM != CXXInvalid) {
6455  M->setTrivial(SpecialMemberIsTrivial(M, CSM));
6456  // Inform the class that we've finished declaring this member.
6458  M->setTrivialForCall(
6459  HasTrivialABI ||
6460  SpecialMemberIsTrivial(M, CSM, TAH_ConsiderTrivialABI));
6461  Record->setTrivialForCallFlags(M);
6462  }
6463  }
6464 
6465  // Set triviality for the purpose of calls if this is a user-provided
6466  // copy/move constructor or destructor.
6467  if ((CSM == CXXCopyConstructor || CSM == CXXMoveConstructor ||
6468  CSM == CXXDestructor) && M->isUserProvided()) {
6469  M->setTrivialForCall(HasTrivialABI);
6470  Record->setTrivialForCallFlags(M);
6471  }
6472 
6473  if (!M->isInvalidDecl() && M->isExplicitlyDefaulted() &&
6474  M->hasAttr<DLLExportAttr>()) {
6475  if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
6476  M->isTrivial() &&
6477  (CSM == CXXDefaultConstructor || CSM == CXXCopyConstructor ||
6478  CSM == CXXDestructor))
6479  M->dropAttr<DLLExportAttr>();
6480 
6481  if (M->hasAttr<DLLExportAttr>()) {
6482  // Define after any fields with in-class initializers have been parsed.
6483  DelayedDllExportMemberFunctions.push_back(M);
6484  }
6485  }
6486 
6487  // Define defaulted constexpr virtual functions that override a base class
6488  // function right away.
6489  // FIXME: We can defer doing this until the vtable is marked as used.
6490  if (M->isDefaulted() && M->isConstexpr() && M->size_overridden_methods())
6491  DefineImplicitSpecialMember(*this, M, M->getLocation());
6492  };
6493 
6494  // Check the destructor before any other member function. We need to
6495  // determine whether it's trivial in order to determine whether the claas
6496  // type is a literal type, which is a prerequisite for determining whether
6497  // other special member functions are valid and whether they're implicitly
6498  // 'constexpr'.
6499  if (CXXDestructorDecl *Dtor = Record->getDestructor())
6500  CompleteMemberFunction(Dtor);
6501 
6502  bool HasMethodWithOverrideControl = false,
6503  HasOverridingMethodWithoutOverrideControl = false;
6504  for (auto *D : Record->decls()) {
6505  if (auto *M = dyn_cast<CXXMethodDecl>(D)) {
6506  // FIXME: We could do this check for dependent types with non-dependent
6507  // bases.
6508  if (!Record->isDependentType()) {
6509  // See if a method overloads virtual methods in a base
6510  // class without overriding any.
6511  if (!M->isStatic())
6512  DiagnoseHiddenVirtualMethods(M);
6513  if (M->hasAttr<OverrideAttr>())
6514  HasMethodWithOverrideControl = true;
6515  else if (M->size_overridden_methods() > 0)
6516  HasOverridingMethodWithoutOverrideControl = true;
6517  }
6518 
6519  if (!isa<CXXDestructorDecl>(M))
6520  CompleteMemberFunction(M);
6521  } else if (auto *F = dyn_cast<FriendDecl>(D)) {
6522  CheckForDefaultedFunction(
6523  dyn_cast_or_null<FunctionDecl>(F->getFriendDecl()));
6524  }
6525  }
6526 
6527  if (HasMethodWithOverrideControl &&
6528  HasOverridingMethodWithoutOverrideControl) {
6529  // At least one method has the 'override' control declared.
6530  // Diagnose all other overridden methods which do not have 'override'
6531  // specified on them.
6532  for (auto *M : Record->methods())
6533  DiagnoseAbsenceOfOverrideControl(M);
6534  }
6535 
6536  // Check the defaulted secondary comparisons after any other member functions.
6537  for (FunctionDecl *FD : DefaultedSecondaryComparisons)
6538  CheckExplicitlyDefaultedFunction(S, FD);
6539 
6540  // ms_struct is a request to use the same ABI rules as MSVC. Check
6541  // whether this class uses any C++ features that are implemented
6542  // completely differently in MSVC, and if so, emit a diagnostic.
6543  // That diagnostic defaults to an error, but we allow projects to
6544  // map it down to a warning (or ignore it). It's a fairly common
6545  // practice among users of the ms_struct pragma to mass-annotate
6546  // headers, sweeping up a bunch of types that the project doesn't
6547  // really rely on MSVC-compatible layout for. We must therefore
6548  // support "ms_struct except for C++ stuff" as a secondary ABI.
6549  if (Record->isMsStruct(Context) &&
6550  (Record->isPolymorphic() || Record->getNumBases())) {
6551  Diag(Record->getLocation(), diag::warn_cxx_ms_struct);
6552  }
6553 
6554  checkClassLevelDLLAttribute(Record);
6555  checkClassLevelCodeSegAttribute(Record);
6556 
6557  bool ClangABICompat4 =
6558  Context.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver4;
6560  Context.getTargetInfo().getCallingConvKind(ClangABICompat4);
6561  bool CanPass = canPassInRegisters(*this, Record, CCK);
6562 
6563  // Do not change ArgPassingRestrictions if it has already been set to
6564  // APK_CanNeverPassInRegs.
6566  Record->setArgPassingRestrictions(CanPass
6569 
6570  // If canPassInRegisters returns true despite the record having a non-trivial
6571  // destructor, the record is destructed in the callee. This happens only when
6572  // the record or one of its subobjects has a field annotated with trivial_abi
6573  // or a field qualified with ObjC __strong/__weak.
6575  Record->setParamDestroyedInCallee(true);
6576  else if (Record->hasNonTrivialDestructor())
6577  Record->setParamDestroyedInCallee(CanPass);
6578 
6579  if (getLangOpts().ForceEmitVTables) {
6580  // If we want to emit all the vtables, we need to mark it as used. This
6581  // is especially required for cases like vtable assumption loads.
6582  MarkVTableUsed(Record->getInnerLocStart(), Record);
6583  }
6584 }
6585 
6586 /// Look up the special member function that would be called by a special
6587 /// member function for a subobject of class type.
6588 ///
6589 /// \param Class The class type of the subobject.
6590 /// \param CSM The kind of special member function.
6591 /// \param FieldQuals If the subobject is a field, its cv-qualifiers.
6592 /// \param ConstRHS True if this is a copy operation with a const object
6593 /// on its RHS, that is, if the argument to the outer special member
6594 /// function is 'const' and this is not a field marked 'mutable'.
6596  Sema &S, CXXRecordDecl *Class, Sema::CXXSpecialMember CSM,
6597  unsigned FieldQuals, bool ConstRHS) {
6598  unsigned LHSQuals = 0;
6599  if (CSM == Sema::CXXCopyAssignment || CSM == Sema::CXXMoveAssignment)
6600  LHSQuals = FieldQuals;
6601 
6602  unsigned RHSQuals = FieldQuals;
6603  if (CSM == Sema::CXXDefaultConstructor || CSM == Sema::CXXDestructor)
6604  RHSQuals = 0;
6605  else if (ConstRHS)
6606  RHSQuals |= Qualifiers::Const;
6607 
6608  return S.LookupSpecialMember(Class, CSM,
6609  RHSQuals & Qualifiers::Const,
6610  RHSQuals & Qualifiers::Volatile,
6611  false,
6612  LHSQuals & Qualifiers::Const,
6613  LHSQuals & Qualifiers::Volatile);
6614 }
6615 
6617  Sema &S;
6618  SourceLocation UseLoc;
6619 
6620  /// A mapping from the base classes through which the constructor was
6621  /// inherited to the using shadow declaration in that base class (or a null
6622  /// pointer if the constructor was declared in that base class).
6623  llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
6624  InheritedFromBases;
6625 
6626 public:
6629  : S(S), UseLoc(UseLoc) {
6630  bool DiagnosedMultipleConstructedBases = false;
6631  CXXRecordDecl *ConstructedBase = nullptr;
6632  UsingDecl *ConstructedBaseUsing = nullptr;
6633 
6634  // Find the set of such base class subobjects and check that there's a
6635  // unique constructed subobject.
6636  for (auto *D : Shadow->redecls()) {
6637  auto *DShadow = cast<ConstructorUsingShadowDecl>(D);
6638  auto *DNominatedBase = DShadow->getNominatedBaseClass();
6639  auto *DConstructedBase = DShadow->getConstructedBaseClass();
6640 
6641  InheritedFromBases.insert(
6642  std::make_pair(DNominatedBase->getCanonicalDecl(),
6643  DShadow->getNominatedBaseClassShadowDecl()));
6644  if (DShadow->constructsVirtualBase())
6645  InheritedFromBases.insert(
6646  std::make_pair(DConstructedBase->getCanonicalDecl(),
6647  DShadow->getConstructedBaseClassShadowDecl()));
6648  else
6649  assert(DNominatedBase == DConstructedBase);
6650 
6651  // [class.inhctor.init]p2:
6652  // If the constructor was inherited from multiple base class subobjects
6653  // of type B, the program is ill-formed.
6654  if (!ConstructedBase) {
6655  ConstructedBase = DConstructedBase;
6656  ConstructedBaseUsing = D->getUsingDecl();
6657  } else if (ConstructedBase != DConstructedBase &&
6658  !Shadow->isInvalidDecl()) {
6659  if (!DiagnosedMultipleConstructedBases) {
6660  S.Diag(UseLoc, diag::err_ambiguous_inherited_constructor)
6661  << Shadow->getTargetDecl();
6662  S.Diag(ConstructedBaseUsing->getLocation(),
6663  diag::note_ambiguous_inherited_constructor_using)
6664  << ConstructedBase;
6665  DiagnosedMultipleConstructedBases = true;
6666  }
6667  S.Diag(D->getUsingDecl()->getLocation(),
6668  diag::note_ambiguous_inherited_constructor_using)
6669  << DConstructedBase;
6670  }
6671  }
6672 
6673  if (DiagnosedMultipleConstructedBases)
6674  Shadow->setInvalidDecl();
6675  }
6676 
6677  /// Find the constructor to use for inherited construction of a base class,
6678  /// and whether that base class constructor inherits the constructor from a
6679  /// virtual base class (in which case it won't actually invoke it).
6680  std::pair<CXXConstructorDecl *, bool>
6682  auto It = InheritedFromBases.find(Base->getCanonicalDecl());
6683  if (It == InheritedFromBases.end())
6684  return std::make_pair(nullptr, false);
6685 
6686  // This is an intermediary class.
6687  if (It->second)
6688  return std::make_pair(
6689  S.findInheritingConstructor(UseLoc, Ctor, It->second),
6690  It->second->constructsVirtualBase());
6691 
6692  // This is the base class from which the constructor was inherited.
6693  return std::make_pair(Ctor, false);
6694  }
6695 };
6696 
6697 /// Is the special member function which would be selected to perform the
6698 /// specified operation on the specified class type a constexpr constructor?
6699 static bool
6701  Sema::CXXSpecialMember CSM, unsigned Quals,
6702  bool ConstRHS,
6703  CXXConstructorDecl *InheritedCtor = nullptr,
6704  Sema::InheritedConstructorInfo *Inherited = nullptr) {
6705  // If we're inheriting a constructor, see if we need to call it for this base
6706  // class.
6707  if (InheritedCtor) {
6708  assert(CSM == Sema::CXXDefaultConstructor);
6709  auto BaseCtor =
6710  Inherited->findConstructorForBase(ClassDecl, InheritedCtor).first;
6711  if (BaseCtor)
6712  return BaseCtor->isConstexpr();
6713  }
6714 
6715  if (CSM == Sema::CXXDefaultConstructor)
6716  return ClassDecl->hasConstexprDefaultConstructor();
6717  if (CSM == Sema::CXXDestructor)
6718  return ClassDecl->hasConstexprDestructor();
6719 
6721  lookupCallFromSpecialMember(S, ClassDecl, CSM, Quals, ConstRHS);
6722  if (!SMOR.getMethod())
6723  // A constructor we wouldn't select can't be "involved in initializing"
6724  // anything.
6725  return true;
6726  return SMOR.getMethod()->isConstexpr();
6727 }
6728 
6729 /// Determine whether the specified special member function would be constexpr
6730 /// if it were implicitly defined.
6732  Sema &S, CXXRecordDecl *ClassDecl, Sema::CXXSpecialMember CSM,
6733  bool ConstArg, CXXConstructorDecl *InheritedCtor = nullptr,
6734  Sema::InheritedConstructorInfo *Inherited = nullptr) {
6735  if (!S.getLangOpts().CPlusPlus11)
6736  return false;
6737 
6738  // C++11 [dcl.constexpr]p4:
6739  // In the definition of a constexpr constructor [...]
6740  bool Ctor = true;
6741  switch (CSM) {
6743  if (Inherited)
6744  break;
6745  // Since default constructor lookup is essentially trivial (and cannot
6746  // involve, for instance, template instantiation), we compute whether a
6747  // defaulted default constructor is constexpr directly within CXXRecordDecl.
6748  //
6749  // This is important for performance; we need to know whether the default
6750  // constructor is constexpr to determine whether the type is a literal type.
6751  return ClassDecl->defaultedDefaultConstructorIsConstexpr();
6752 
6755  // For copy or move constructors, we need to perform overload resolution.
6756  break;
6757 
6760  if (!S.getLangOpts().CPlusPlus14)
6761  return false;
6762  // In C++1y, we need to perform overload resolution.
6763  Ctor = false;
6764  break;
6765 
6766  case Sema::CXXDestructor:
6767  return ClassDecl->defaultedDestructorIsConstexpr();
6768 
6769  case Sema::CXXInvalid:
6770  return false;
6771  }
6772 
6773  // -- if the class is a non-empty union, or for each non-empty anonymous
6774  // union member of a non-union class, exactly one non-static data member
6775  // shall be initialized; [DR1359]
6776  //
6777  // If we squint, this is guaranteed, since exactly one non-static data member
6778  // will be initialized (if the constructor isn't deleted), we just don't know
6779  // which one.
6780  if (Ctor && ClassDecl->isUnion())
6781  return CSM == Sema::CXXDefaultConstructor
6782  ? ClassDecl->hasInClassInitializer() ||
6783  !ClassDecl->hasVariantMembers()
6784  : true;
6785 
6786  // -- the class shall not have any virtual base classes;
6787  if (Ctor && ClassDecl->getNumVBases())
6788  return false;
6789 
6790  // C++1y [class.copy]p26:
6791  // -- [the class] is a literal type, and
6792  if (!Ctor && !ClassDecl->isLiteral())
6793  return false;
6794 
6795  // -- every constructor involved in initializing [...] base class
6796  // sub-objects shall be a constexpr constructor;
6797  // -- the assignment operator selected to copy/move each direct base
6798  // class is a constexpr function, and
6799  for (const auto &B : ClassDecl->bases()) {
6800  const RecordType *BaseType = B.getType()->getAs<RecordType>();
6801  if (!BaseType) continue;
6802 
6803  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
6804  if (!specialMemberIsConstexpr(S, BaseClassDecl, CSM, 0, ConstArg,
6805  InheritedCtor, Inherited))
6806  return false;
6807  }
6808 
6809  // -- every constructor involved in initializing non-static data members
6810  // [...] shall be a constexpr constructor;
6811  // -- every non-static data member and base class sub-object shall be
6812  // initialized
6813  // -- for each non-static data member of X that is of class type (or array
6814  // thereof), the assignment operator selected to copy/move that member is
6815  // a constexpr function
6816  for (const auto *F : ClassDecl->fields()) {
6817  if (F->isInvalidDecl())
6818  continue;
6819  if (CSM == Sema::CXXDefaultConstructor && F->hasInClassInitializer())
6820  continue;
6821  QualType BaseType = S.Context.getBaseElementType(F->getType());
6822  if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
6823  CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
6824  if (!specialMemberIsConstexpr(S, FieldRecDecl, CSM,
6825  BaseType.getCVRQualifiers(),
6826  ConstArg && !F->isMutable()))
6827  return false;
6828  } else if (CSM == Sema::CXXDefaultConstructor) {
6829  return false;
6830  }
6831  }
6832 
6833  // All OK, it's constexpr!
6834  return true;
6835 }
6836 
6837 namespace {
6838 /// RAII object to register a defaulted function as having its exception
6839 /// specification computed.
6840 struct ComputingExceptionSpec {
6841  Sema &S;
6842 
6843  ComputingExceptionSpec(Sema &S, FunctionDecl *FD, SourceLocation Loc)
6844  : S(S) {
6847  Ctx.PointOfInstantiation = Loc;
6848  Ctx.Entity = FD;
6849  S.pushCodeSynthesisContext(Ctx);
6850  }
6851  ~ComputingExceptionSpec() {
6853  }
6854 };
6855 }
6856 
6861 
6864  FunctionDecl *FD,
6866 
6869  auto DFK = S.getDefaultedFunctionKind(FD);
6870  if (DFK.isSpecialMember())
6872  S, Loc, cast<CXXMethodDecl>(FD), DFK.asSpecialMember(), nullptr);
6873  if (DFK.isComparison())
6874  return ComputeDefaultedComparisonExceptionSpec(S, Loc, FD,
6875  DFK.asComparison());
6876 
6877  auto *CD = cast<CXXConstructorDecl>(FD);
6878  assert(CD->getInheritedConstructor() &&
6879  "only defaulted functions and inherited constructors have implicit "
6880  "exception specs");
6882  S, Loc, CD->getInheritedConstructor().getShadowDecl());
6884  S, Loc, CD, Sema::CXXDefaultConstructor, &ICI);
6885 }
6886 
6888  CXXMethodDecl *MD) {
6890 
6891  // Build an exception specification pointing back at this member.
6893  EPI.ExceptionSpec.SourceDecl = MD;
6894 
6895  // Set the calling convention to the default for C++ instance methods.
6896  EPI.ExtInfo = EPI.ExtInfo.withCallingConv(
6897  S.Context.getDefaultCallingConvention(/*IsVariadic=*/false,
6898  /*IsCXXMethod=*/true));
6899  return EPI;
6900 }
6901 
6903  const FunctionProtoType *FPT = FD->getType()->castAs<FunctionProtoType>();
6904  if (FPT->getExceptionSpecType() != EST_Unevaluated)
6905  return;
6906 
6907  // Evaluate the exception specification.
6908  auto IES = computeImplicitExceptionSpec(*this, Loc, FD);
6909  auto ESI = IES.getExceptionSpec();
6910 
6911  // Update the type of the special member to use it.
6912  UpdateExceptionSpec(FD, ESI);
6913 }
6914 
6916  assert(FD->isExplicitlyDefaulted() && "not explicitly-defaulted");
6917 
6918  DefaultedFunctionKind DefKind = getDefaultedFunctionKind(FD);
6919  if (!DefKind) {
6920  assert(FD->getDeclContext()->isDependentContext());
6921  return;
6922  }
6923 
6924  if (DefKind.isSpecialMember()
6925  ? CheckExplicitlyDefaultedSpecialMember(cast<CXXMethodDecl>(FD),
6926  DefKind.asSpecialMember())
6927  : CheckExplicitlyDefaultedComparison(S, FD, DefKind.asComparison()))
6928  FD->setInvalidDecl();
6929 }
6930 
6932  CXXSpecialMember CSM) {
6933  CXXRecordDecl *RD = MD->getParent();
6934 
6935  assert(MD->isExplicitlyDefaulted() && CSM != CXXInvalid &&
6936  "not an explicitly-defaulted special member");
6937 
6938  // Defer all checking for special members of a dependent type.
6939  if (RD->isDependentType())
6940  return false;
6941 
6942  // Whether this was the first-declared instance of the constructor.
6943  // This affects whether we implicitly add an exception spec and constexpr.
6944  bool First = MD == MD->getCanonicalDecl();
6945 
6946  bool HadError = false;
6947 
6948  // C++11 [dcl.fct.def.default]p1:
6949  // A function that is explicitly defaulted shall
6950  // -- be a special member function [...] (checked elsewhere),
6951  // -- have the same type (except for ref-qualifiers, and except that a
6952  // copy operation can take a non-const reference) as an implicit
6953  // declaration, and
6954  // -- not have default arguments.
6955  // C++2a changes the second bullet to instead delete the function if it's
6956  // defaulted on its first declaration, unless it's "an assignment operator,
6957  // and its return type differs or its parameter type is not a reference".
6958  bool DeleteOnTypeMismatch = getLangOpts().CPlusPlus2a && First;
6959  bool ShouldDeleteForTypeMismatch = false;
6960  unsigned ExpectedParams = 1;
6961  if (CSM == CXXDefaultConstructor || CSM == CXXDestructor)
6962  ExpectedParams = 0;
6963  if (MD->getNumParams() != ExpectedParams) {
6964  // This checks for default arguments: a copy or move constructor with a
6965  // default argument is classified as a default constructor, and assignment
6966  // operations and destructors can't have default arguments.
6967  Diag(MD->getLocation(), diag::err_defaulted_special_member_params)
6968  << CSM << MD->getSourceRange();
6969  HadError = true;
6970  } else if (MD->isVariadic()) {
6971  if (DeleteOnTypeMismatch)
6972  ShouldDeleteForTypeMismatch = true;
6973  else {
6974  Diag(MD->getLocation(), diag::err_defaulted_special_member_variadic)
6975  << CSM << MD->getSourceRange();
6976  HadError = true;
6977  }
6978  }
6979 
6981 
6982  bool CanHaveConstParam = false;
6983  if (CSM == CXXCopyConstructor)
6984  CanHaveConstParam = RD->implicitCopyConstructorHasConstParam();
6985  else if (CSM == CXXCopyAssignment)
6986  CanHaveConstParam = RD->implicitCopyAssignmentHasConstParam();
6987 
6988  QualType ReturnType = Context.VoidTy;
6989  if (CSM == CXXCopyAssignment || CSM == CXXMoveAssignment) {
6990  // Check for return type matching.
6991  ReturnType = Type->getReturnType();
6992 
6993  QualType DeclType = Context.getTypeDeclType(RD);
6994  DeclType = Context.getAddrSpaceQualType(DeclType, MD->getMethodQualifiers().getAddressSpace());
6995  QualType ExpectedReturnType = Context.getLValueReferenceType(DeclType);
6996 
6997  if (!Context.hasSameType(ReturnType, ExpectedReturnType)) {
6998  Diag(MD->getLocation(), diag::err_defaulted_special_member_return_type)
6999  << (CSM == CXXMoveAssignment) << ExpectedReturnType;
7000  HadError = true;
7001  }
7002 
7003  // A defaulted special member cannot have cv-qualifiers.
7004  if (Type->getMethodQuals().hasConst() || Type->getMethodQuals().hasVolatile()) {
7005  if (DeleteOnTypeMismatch)
7006  ShouldDeleteForTypeMismatch = true;
7007  else {
7008  Diag(MD->getLocation(), diag::err_defaulted_special_member_quals)
7009  << (CSM == CXXMoveAssignment) << getLangOpts().CPlusPlus14;
7010  HadError = true;
7011  }
7012  }
7013  }
7014 
7015  // Check for parameter type matching.
7016  QualType ArgType = ExpectedParams ? Type->getParamType(0) : QualType();
7017  bool HasConstParam = false;
7018  if (ExpectedParams && ArgType->isReferenceType()) {
7019  // Argument must be reference to possibly-const T.
7020  QualType ReferentType = ArgType->getPointeeType();
7021  HasConstParam = ReferentType.isConstQualified();
7022 
7023  if (ReferentType.isVolatileQualified()) {
7024  if (DeleteOnTypeMismatch)
7025  ShouldDeleteForTypeMismatch = true;
7026  else {
7027  Diag(MD->getLocation(),
7028  diag::err_defaulted_special_member_volatile_param) << CSM;
7029  HadError = true;
7030  }
7031  }
7032 
7033  if (HasConstParam && !CanHaveConstParam) {
7034  if (DeleteOnTypeMismatch)
7035  ShouldDeleteForTypeMismatch = true;
7036  else if (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment) {
7037  Diag(MD->getLocation(),
7038  diag::err_defaulted_special_member_copy_const_param)
7039  << (CSM == CXXCopyAssignment);
7040  // FIXME: Explain why this special member can't be const.
7041  HadError = true;
7042  } else {
7043  Diag(MD->getLocation(),
7044  diag::err_defaulted_special_member_move_const_param)
7045  << (CSM == CXXMoveAssignment);
7046  HadError = true;
7047  }
7048  }
7049  } else if (ExpectedParams) {
7050  // A copy assignment operator can take its argument by value, but a
7051  // defaulted one cannot.
7052  assert(CSM == CXXCopyAssignment && "unexpected non-ref argument");
7053  Diag(MD->getLocation(), diag::err_defaulted_copy_assign_not_ref);
7054  HadError = true;
7055  }
7056 
7057  // C++11 [dcl.fct.def.default]p2:
7058  // An explicitly-defaulted function may be declared constexpr only if it
7059  // would have been implicitly declared as constexpr,
7060  // Do not apply this rule to members of class templates, since core issue 1358
7061  // makes such functions always instantiate to constexpr functions. For
7062  // functions which cannot be constexpr (for non-constructors in C++11 and for
7063  // destructors in C++14 and C++17), this is checked elsewhere.
7064  //
7065  // FIXME: This should not apply if the member is deleted.
7066  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
7067  HasConstParam);
7068  if ((getLangOpts().CPlusPlus2a ||
7069  (getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD)
7070  : isa<CXXConstructorDecl>(MD))) &&
7071  MD->isConstexpr() && !Constexpr &&
7073  Diag(MD->getBeginLoc(), MD->isConsteval()
7074  ? diag::err_incorrect_defaulted_consteval
7075  : diag::err_incorrect_defaulted_constexpr)
7076  << CSM;
7077  // FIXME: Explain why the special member can't be constexpr.
7078  HadError = true;
7079  }
7080 
7081  if (First) {
7082  // C++2a [dcl.fct.def.default]p3:
7083  // If a function is explicitly defaulted on its first declaration, it is
7084  // implicitly considered to be constexpr if the implicit declaration
7085  // would be.
7086  MD->setConstexprKind(Constexpr ? CSK_constexpr : CSK_unspecified);
7087 
7088  if (!Type->hasExceptionSpec()) {
7089  // C++2a [except.spec]p3:
7090  // If a declaration of a function does not have a noexcept-specifier
7091  // [and] is defaulted on its first declaration, [...] the exception
7092  // specification is as specified below
7095  EPI.ExceptionSpec.SourceDecl = MD;
7096  MD->setType(Context.getFunctionType(ReturnType,
7097  llvm::makeArrayRef(&ArgType,
7098  ExpectedParams),
7099  EPI));
7100  }
7101  }
7102 
7103  if (ShouldDeleteForTypeMismatch || ShouldDeleteSpecialMember(MD, CSM)) {
7104  if (First) {
7105  SetDeclDeleted(MD, MD->getLocation());
7106  if (!inTemplateInstantiation() && !HadError) {
7107  Diag(MD->getLocation(), diag::warn_defaulted_method_deleted) << CSM;
7108  if (ShouldDeleteForTypeMismatch) {
7109  Diag(MD->getLocation(), diag::note_deleted_type_mismatch) << CSM;
7110  } else {
7111  ShouldDeleteSpecialMember(MD, CSM, nullptr, /*Diagnose*/true);
7112  }
7113  }
7114  if (ShouldDeleteForTypeMismatch && !HadError) {
7115  Diag(MD->getLocation(),
7116  diag::warn_cxx17_compat_defaulted_method_type_mismatch) << CSM;
7117  }
7118  } else {
7119  // C++11 [dcl.fct.def.default]p4:
7120  // [For a] user-provided explicitly-defaulted function [...] if such a
7121  // function is implicitly defined as deleted, the program is ill-formed.
7122  Diag(MD->getLocation(), diag::err_out_of_line_default_deletes) << CSM;
7123  assert(!ShouldDeleteForTypeMismatch && "deleted non-first decl");
7124  ShouldDeleteSpecialMember(MD, CSM, nullptr, /*Diagnose*/true);
7125  HadError = true;
7126  }
7127  }
7128 
7129  return HadError;
7130 }
7131 
7132 namespace {
7133 /// Helper class for building and checking a defaulted comparison.
7134 ///
7135 /// Defaulted functions are built in two phases:
7136 ///
7137 /// * First, the set of operations that the function will perform are
7138 /// identified, and some of them are checked. If any of the checked
7139 /// operations is invalid in certain ways, the comparison function is
7140 /// defined as deleted and no body is built.
7141 /// * Then, if the function is not defined as deleted, the body is built.
7142 ///
7143 /// This is accomplished by performing two visitation steps over the eventual
7144 /// body of the function.
7145 template<typename Derived, typename ResultList, typename Result,
7146  typename Subobject>
7147 class DefaultedComparisonVisitor {
7148 public:
7150 
7151  DefaultedComparisonVisitor(Sema &S, CXXRecordDecl *RD, FunctionDecl *FD,
7153  : S(S), RD(RD), FD(FD), DCK(DCK) {
7154  if (auto *Info = FD->getDefaultedFunctionInfo()) {
7155  // FIXME: Change CreateOverloadedBinOp to take an ArrayRef instead of an
7156  // UnresolvedSet to avoid this copy.
7157  Fns.assign(Info->getUnqualifiedLookups().begin(),
7158  Info->getUnqualifiedLookups().end());
7159  }
7160  }
7161 
7162  ResultList visit() {
7163  // The type of an lvalue naming a parameter of this function.
7164  QualType ParamLvalType =
7166 
7167  ResultList Results;
7168 
7169  switch (DCK) {
7171  llvm_unreachable("not a defaulted comparison");
7172 
7174  case DefaultedComparisonKind::ThreeWay:
7175  getDerived().visitSubobjects(Results, RD, ParamLvalType.getQualifiers());
7176  return Results;
7177 
7178  case DefaultedComparisonKind::NotEqual:
7180  Results.add(getDerived().visitExpandedSubobject(
7181  ParamLvalType, getDerived().getCompleteObject()));
7182  return Results;
7183  }
7184  llvm_unreachable("");
7185  }
7186 
7187 protected:
7188  Derived &getDerived() { return static_cast<Derived&>(*this); }
7189 
7190  /// Visit the expanded list of subobjects of the given type, as specified in
7191  /// C++2a [class.compare.default].
7192  ///
7193  /// \return \c true if the ResultList object said we're done, \c false if not.
7194  bool visitSubobjects(ResultList &Results, CXXRecordDecl *Record,
7195  Qualifiers Quals) {
7196  // C++2a [class.compare.default]p4:
7197  // The direct base class subobjects of C
7198  for (CXXBaseSpecifier &Base : Record->bases())
7199  if (Results.add(getDerived().visitSubobject(
7200  S.Context.getQualifiedType(Base.getType(), Quals),
7201  getDerived().getBase(&Base))))
7202  return true;
7203 
7204  // followed by the non-static data members of C
7205  for (FieldDecl *Field : Record->fields()) {
7206  // Recursively expand anonymous structs.
7207  if (Field->isAnonymousStructOrUnion()) {
7208  if (visitSubobjects(Results, Field->getType()->getAsCXXRecordDecl(),
7209  Quals))
7210  return true;
7211  continue;
7212  }
7213 
7214  // Figure out the type of an lvalue denoting this field.
7215  Qualifiers FieldQuals = Quals;
7216  if (Field->isMutable())
7217  FieldQuals.removeConst();
7218  QualType FieldType =
7219  S.Context.getQualifiedType(Field->getType(), FieldQuals);
7220 
7221  if (Results.add(getDerived().visitSubobject(
7222  FieldType, getDerived().getField(Field))))
7223  return true;
7224  }
7225 
7226  // form a list of subobjects.
7227  return false;
7228  }
7229 
7230  Result visitSubobject(QualType Type, Subobject Subobj) {
7231  // In that list, any subobject of array type is recursively expanded
7232  const ArrayType *AT = S.Context.getAsArrayType(Type);
7233  if (auto *CAT = dyn_cast_or_null<ConstantArrayType>(AT))
7234  return getDerived().visitSubobjectArray(CAT->getElementType(),
7235  CAT->getSize(), Subobj);
7236  return getDerived().visitExpandedSubobject(Type, Subobj);
7237  }
7238 
7239  Result visitSubobjectArray(QualType Type, const llvm::APInt &Size,
7240  Subobject Subobj) {
7241  return getDerived().visitSubobject(Type, Subobj);
7242  }
7243 
7244 protected:
7245  Sema &S;
7246  CXXRecordDecl *RD;
7247  FunctionDecl *FD;
7249  UnresolvedSet<16> Fns;
7250 };
7251 
7252 /// Information about a defaulted comparison, as determined by
7253 /// DefaultedComparisonAnalyzer.
7254 struct DefaultedComparisonInfo {
7255  bool Deleted = false;
7256  bool Constexpr = true;
7258 
7259  static DefaultedComparisonInfo deleted() {
7260  DefaultedComparisonInfo Deleted;
7261  Deleted.Deleted = true;
7262  return Deleted;
7263  }
7264 
7265  bool add(const DefaultedComparisonInfo &R) {
7266  Deleted |= R.Deleted;
7267  Constexpr &= R.Constexpr;
7268  Category = commonComparisonType(Category, R.Category);
7269  return Deleted;
7270  }
7271 };
7272 
7273 /// An element in the expanded list of subobjects of a defaulted comparison, as
7274 /// specified in C++2a [class.compare.default]p4.
7275 struct DefaultedComparisonSubobject {
7276  enum { CompleteObject, Member, Base } Kind;
7277  NamedDecl *Decl;
7278  SourceLocation Loc;
7279 };
7280 
7281 /// A visitor over the notional body of a defaulted comparison that determines
7282 /// whether that body would be deleted or constexpr.
7283 class DefaultedComparisonAnalyzer
7284  : public DefaultedComparisonVisitor<DefaultedComparisonAnalyzer,
7285  DefaultedComparisonInfo,
7286  DefaultedComparisonInfo,
7287  DefaultedComparisonSubobject> {
7288 public:
7289  enum DiagnosticKind { NoDiagnostics, ExplainDeleted, ExplainConstexpr };
7290 
7291 private:
7292  DiagnosticKind Diagnose;
7293 
7294 public:
7295  using Base = DefaultedComparisonVisitor;
7296  using Result = DefaultedComparisonInfo;
7297  using Subobject = DefaultedComparisonSubobject;
7298 
7299  friend Base;
7300 
7301  DefaultedComparisonAnalyzer(Sema &S, CXXRecordDecl *RD, FunctionDecl *FD,
7303  DiagnosticKind Diagnose = NoDiagnostics)
7304  : Base(S, RD, FD, DCK), Diagnose(Diagnose) {}
7305 
7306  Result visit() {
7307  if ((DCK == DefaultedComparisonKind::Equal ||
7308  DCK == DefaultedComparisonKind::ThreeWay) &&
7309  RD->hasVariantMembers()) {
7310  // C++2a [class.compare.default]p2 [P2002R0]:
7311  // A defaulted comparison operator function for class C is defined as
7312  // deleted if [...] C has variant members.
7313  if (Diagnose == ExplainDeleted) {
7314  S.Diag(FD->getLocation(), diag::note_defaulted_comparison_union)
7315  << FD << RD->isUnion() << RD;
7316  }
7317  return Result::deleted();
7318  }
7319 
7320  return Base::visit();
7321  }
7322 
7323 private:
7324  Subobject getCompleteObject() {
7325  return Subobject{Subobject::CompleteObject, nullptr, FD->getLocation()};
7326  }
7327 
7328  Subobject getBase(CXXBaseSpecifier *Base) {
7329  return Subobject{Subobject::Base, Base->getType()->getAsCXXRecordDecl(),
7330  Base->getBaseTypeLoc()};
7331  }
7332 
7333  Subobject getField(FieldDecl *Field) {
7334  return Subobject{Subobject::Member, Field, Field->getLocation()};
7335  }
7336 
7337  Result visitExpandedSubobject(QualType Type, Subobject Subobj) {
7338  // C++2a [class.compare.default]p2 [P2002R0]:
7339  // A defaulted <=> or == operator function for class C is defined as
7340  // deleted if any non-static data member of C is of reference type
7341  if (Type->isReferenceType()) {
7342  if (Diagnose == ExplainDeleted) {
7343  S.Diag(Subobj.Loc, diag::note_defaulted_comparison_reference_member)
7344  << FD << RD;
7345  }
7346  return Result::deleted();
7347  }
7348 
7349  // [...] Let xi be an lvalue denoting the ith element [...]
7350  OpaqueValueExpr Xi(FD->getLocation(), Type, VK_LValue);
7351  Expr *Args[] = {&Xi, &Xi};
7352 
7353  // All operators start by trying to apply that same operator recursively.
7355  assert(OO != OO_None && "not an overloaded operator!");
7356  return visitBinaryOperator(OO, Args, Subobj);
7357  }
7358 
7359  Result
7360  visitBinaryOperator(OverloadedOperatorKind OO, ArrayRef<Expr *> Args,
7361  Subobject Subobj,
7362  OverloadCandidateSet *SpaceshipCandidates = nullptr) {
7363  // Note that there is no need to consider rewritten candidates here if
7364  // we've already found there is no viable 'operator<=>' candidate (and are
7365  // considering synthesizing a '<=>' from '==' and '<').
7366  OverloadCandidateSet CandidateSet(
7369  OO, /*AllowRewrittenCandidates=*/!SpaceshipCandidates));
7370 
7371  /// C++2a [class.compare.default]p1 [P2002R0]:
7372  /// [...] the defaulted function itself is never a candidate for overload
7373  /// resolution [...]
7374  CandidateSet.exclude(FD);
7375 
7376  if (Args[0]->getType()->isOverloadableType())
7377  S.LookupOverloadedBinOp(CandidateSet, OO, Fns, Args);
7378  else {
7379  // FIXME: We determine whether this is a valid expression by checking to
7380  // see if there's a viable builtin operator candidate for it. That isn't
7381  // really what the rules ask us to do, but should give the right results.
7382  S.AddBuiltinOperatorCandidates(OO, FD->getLocation(), Args, CandidateSet);
7383  }
7384 
7385  Result R;
7386 
7388  switch (CandidateSet.BestViableFunction(S, FD->getLocation(), Best)) {
7389  case OR_Success: {
7390  // C++2a [class.compare.secondary]p2 [P2002R0]:
7391  // The operator function [...] is defined as deleted if [...] the
7392  // candidate selected by overload resolution is not a rewritten
7393  // candidate.
7394  if ((DCK == DefaultedComparisonKind::NotEqual ||
7396  !Best->RewriteKind) {
7397  if (Diagnose == ExplainDeleted) {
7398  S.Diag(Best->Function->getLocation(),
7399  diag::note_defaulted_comparison_not_rewritten_callee)
7400  << FD;
7401  }
7402  return Result::deleted();
7403  }
7404 
7405  // Throughout C++2a [class.compare]: if overload resolution does not
7406  // result in a usable function, the candidate function is defined as
7407  // deleted. This requires that we selected an accessible function.
7408  //
7409  // Note that this only considers the access of the function when named
7410  // within the type of the subobject, and not the access path for any
7411  // derived-to-base conversion.
7412  CXXRecordDecl *ArgClass = Args[0]->getType()->getAsCXXRecordDecl();
7413  if (ArgClass && Best->FoundDecl.getDecl() &&
7414  Best->FoundDecl.getDecl()->isCXXClassMember()) {
7415  QualType ObjectType = Subobj.Kind == Subobject::Member
7416  ? Args[0]->getType()
7417  : S.Context.getRecordType(RD);
7419  ArgClass, Best->FoundDecl, ObjectType, Subobj.Loc,
7420  Diagnose == ExplainDeleted
7421  ? S.PDiag(diag::note_defaulted_comparison_inaccessible)
7422  << FD << Subobj.Kind << Subobj.Decl
7423  : S.PDiag()))
7424  return Result::deleted();
7425  }
7426 
7427  // C++2a [class.compare.default]p3 [P2002R0]:
7428  // A defaulted comparison function is constexpr-compatible if [...]
7429  // no overlod resolution performed [...] results in a non-constexpr
7430  // function.
7431  if (FunctionDecl *BestFD = Best->Function) {
7432  assert(!BestFD->isDeleted() && "wrong overload resolution result");
7433  // If it's not constexpr, explain why not.
7434  if (Diagnose == ExplainConstexpr && !BestFD->isConstexpr()) {
7435  if (Subobj.Kind != Subobject::CompleteObject)
7436  S.Diag(Subobj.Loc, diag::note_defaulted_comparison_not_constexpr)
7437  << Subobj.Kind << Subobj.Decl;
7438  S.Diag(BestFD->getLocation(),
7439  diag::note_defaulted_comparison_not_constexpr_here);
7440  // Bail out after explaining; we don't want any more notes.
7441  return Result::deleted();
7442  }
7443  R.Constexpr &= BestFD->isConstexpr();
7444  }
7445 
7446  if (OO == OO_Spaceship && FD->getReturnType()->isUndeducedAutoType()) {
7447  if (auto *BestFD = Best->Function) {
7448  // If any callee has an undeduced return type, deduce it now.
7449  // FIXME: It's not clear how a failure here should be handled. For
7450  // now, we produce an eager diagnostic, because that is forward
7451  // compatible with most (all?) other reasonable options.
7452  if (BestFD->getReturnType()->isUndeducedType() &&
7453  S.DeduceReturnType(BestFD, FD->getLocation(),
7454  /*Diagnose=*/false)) {
7455  // Don't produce a duplicate error when asked to explain why the
7456  // comparison is deleted: we diagnosed that when initially checking
7457  // the defaulted operator.
7458  if (Diagnose == NoDiagnostics) {
7459  S.Diag(
7460  FD->getLocation(),
7461  diag::err_defaulted_comparison_cannot_deduce_undeduced_auto)
7462  << Subobj.Kind << Subobj.Decl;
7463  S.Diag(
7464  Subobj.Loc,
7465  diag::note_defaulted_comparison_cannot_deduce_undeduced_auto)
7466  << Subobj.Kind << Subobj.Decl;
7467  S.Diag(BestFD->getLocation(),
7468  diag::note_defaulted_comparison_cannot_deduce_callee)
7469  << Subobj.Kind << Subobj.Decl;
7470  }
7471  return Result::deleted();
7472  }
7473  if (auto *Info = S.Context.CompCategories.lookupInfoForType(
7474  BestFD->getCallResultType())) {
7475  R.Category = Info->Kind;
7476  } else {
7477  if (Diagnose == ExplainDeleted) {
7478  S.Diag(Subobj.Loc, diag::note_defaulted_comparison_cannot_deduce)
7479  << Subobj.Kind << Subobj.Decl
7480  << BestFD->getCallResultType().withoutLocalFastQualifiers();
7481  S.Diag(BestFD->getLocation(),
7482  diag::note_defaulted_comparison_cannot_deduce_callee)
7483  << Subobj.Kind << Subobj.Decl;
7484  }
7485  return Result::deleted();
7486  }
7487  } else {
7489  getComparisonCategoryForBuiltinCmp(Args[0]->getType());
7490  assert(Cat && "no category for builtin comparison?");
7491  R.Category = *Cat;
7492  }
7493  }
7494 
7495  // Note that we might be rewriting to a different operator. That call is
7496  // not considered until we come to actually build the comparison function.
7497  break;
7498  }
7499 
7500  case OR_Ambiguous:
7501  if (Diagnose == ExplainDeleted) {
7502  unsigned Kind = 0;
7503  if (FD->getOverloadedOperator() == OO_Spaceship && OO != OO_Spaceship)
7504  Kind = OO == OO_EqualEqual ? 1 : 2;
7505  CandidateSet.NoteCandidates(
7507  Subobj.Loc, S.PDiag(diag::note_defaulted_comparison_ambiguous)
7508  << FD << Kind << Subobj.Kind << Subobj.Decl),
7509  S, OCD_AmbiguousCandidates, Args);
7510  }
7511  R = Result::deleted();
7512  break;
7513 
7514  case OR_Deleted:
7515  if (Diagnose == ExplainDeleted) {
7516  if ((DCK == DefaultedComparisonKind::NotEqual ||
7518  !Best->RewriteKind) {
7519  S.Diag(Best->Function->getLocation(),
7520  diag::note_defaulted_comparison_not_rewritten_callee)
7521  << FD;
7522  } else {
7523  S.Diag(Subobj.Loc,
7524  diag::note_defaulted_comparison_calls_deleted)
7525  << FD << Subobj.Kind << Subobj.Decl;
7526  S.NoteDeletedFunction(Best->Function);
7527  }
7528  }
7529  R = Result::deleted();
7530  break;
7531 
7532  case OR_No_Viable_Function:
7533  // If there's no usable candidate, we're done unless we can rewrite a
7534  // '<=>' in terms of '==' and '<'.
7535  if (OO == OO_Spaceship &&
7537  // For any kind of comparison category return type, we need a usable
7538  // '==' and a usable '<'.
7539  if (!R.add(visitBinaryOperator(OO_EqualEqual, Args, Subobj,
7540  &CandidateSet)))
7541  R.add(visitBinaryOperator(OO_Less, Args, Subobj, &CandidateSet));
7542  break;
7543  }
7544 
7545  if (Diagnose == ExplainDeleted) {
7546  S.Diag(Subobj.Loc, diag::note_defaulted_comparison_no_viable_function)
7547  << FD << Subobj.Kind << Subobj.Decl;
7548 
7549  // For a three-way comparison, list both the candidates for the
7550  // original operator and the candidates for the synthesized operator.
7551  if (SpaceshipCandidates) {
7552  SpaceshipCandidates->NoteCandidates(
7553  S, Args,
7554  SpaceshipCandidates->CompleteCandidates(S, OCD_AllCandidates,
7555  Args, FD->getLocation()));
7556  S.Diag(Subobj.Loc,
7557  diag::note_defaulted_comparison_no_viable_function_synthesized)
7558  << (OO == OO_EqualEqual ? 0 : 1);
7559  }
7560 
7561  CandidateSet.NoteCandidates(
7562  S, Args,
7563  CandidateSet.CompleteCandidates(S, OCD_AllCandidates, Args,
7564  FD->getLocation()));
7565  }
7566  R = Result::deleted();
7567  break;
7568  }
7569 
7570  return R;
7571  }
7572 };
7573 
7574 /// A list of statements.
7575 struct StmtListResult {
7576  bool IsInvalid = false;
7578 
7579  bool add(const StmtResult &S) {
7580  IsInvalid |= S.isInvalid();
7581  if (IsInvalid)
7582  return true;
7583  Stmts.push_back(S.get());
7584  return false;
7585  }
7586 };
7587 
7588 /// A visitor over the notional body of a defaulted comparison that synthesizes
7589 /// the actual body.
7590 class DefaultedComparisonSynthesizer
7591  : public DefaultedComparisonVisitor<DefaultedComparisonSynthesizer,
7592  StmtListResult, StmtResult,
7593  std::pair<ExprResult, ExprResult>> {
7594  SourceLocation Loc;
7595  unsigned ArrayDepth = 0;
7596 
7597 public:
7598  using Base = DefaultedComparisonVisitor;
7599  using ExprPair = std::pair<ExprResult, ExprResult>;
7600 
7601  friend Base;
7602 
7603  DefaultedComparisonSynthesizer(Sema &S, CXXRecordDecl *RD, FunctionDecl *FD,
7605  SourceLocation BodyLoc)
7606  : Base(S, RD, FD, DCK), Loc(BodyLoc) {}
7607 
7608  /// Build a suitable function body for this defaulted comparison operator.
7609  StmtResult build() {
7610  Sema::CompoundScopeRAII CompoundScope(S);
7611 
7612  StmtListResult Stmts = visit();
7613  if (Stmts.IsInvalid)
7614  return StmtError();
7615 
7616  ExprResult RetVal;
7617  switch (DCK) {
7619  llvm_unreachable("not a defaulted comparison");
7620 
7622  // C++2a [class.eq]p3:
7623  // [...] compar[e] the corresponding elements [...] until the first
7624  // index i where xi == yi yields [...] false. If no such index exists,
7625  // V is true. Otherwise, V is false.
7626  //
7627  // Join the comparisons with '&&'s and return the result. Use a right
7628  // fold (traversing the conditions right-to-left), because that
7629  // short-circuits more naturally.
7630  auto OldStmts = std::move(Stmts.Stmts);
7631  Stmts.Stmts.clear();
7632  ExprResult CmpSoFar;
7633  // Finish a particular comparison chain.
7634  auto FinishCmp = [&] {
7635  if (Expr *Prior = CmpSoFar.get()) {
7636  // Convert the last expression to 'return ...;'
7637  if (RetVal.isUnset() && Stmts.Stmts.empty())
7638  RetVal = CmpSoFar;
7639  // Convert any prior comparison to 'if (!(...)) return false;'
7640  else if (Stmts.add(buildIfNotCondReturnFalse(Prior)))
7641  return true;
7642  CmpSoFar = ExprResult();
7643  }
7644  return false;
7645  };
7646  for (Stmt *EAsStmt : llvm::reverse(OldStmts)) {
7647  Expr *E = dyn_cast<Expr>(EAsStmt);
7648  if (!E) {
7649  // Found an array comparison.
7650  if (FinishCmp() || Stmts.add(EAsStmt))
7651  return StmtError();
7652  continue;
7653  }
7654 
7655  if (CmpSoFar.isUnset()) {
7656  CmpSoFar = E;
7657  continue;
7658  }
7659  CmpSoFar = S.CreateBuiltinBinOp(Loc, BO_LAnd, E, CmpSoFar.get());
7660  if (CmpSoFar.isInvalid())
7661  return StmtError();
7662  }
7663  if (FinishCmp())
7664  return StmtError();
7665  std::reverse(Stmts.Stmts.begin(), Stmts.Stmts.end());
7666  // If no such index exists, V is true.
7667  if (RetVal.isUnset())
7668  RetVal = S.ActOnCXXBoolLiteral(Loc, tok::kw_true);
7669  break;
7670  }
7671 
7672  case DefaultedComparisonKind::ThreeWay: {
7673  // Per C++2a [class.spaceship]p3, as a fallback add:
7674  // return static_cast<R>(std::strong_ordering::equal);
7678  if (StrongOrdering.isNull())
7679  return StmtError();
7680  VarDecl *EqualVD = S.Context.CompCategories.getInfoForType(StrongOrdering)
7682  ->VD;
7683  RetVal = getDecl(EqualVD);
7684  if (RetVal.isInvalid())
7685  return StmtError();
7686  RetVal = buildStaticCastToR(RetVal.get());
7687  break;
7688  }
7689 
7690  case DefaultedComparisonKind::NotEqual:
7692  RetVal = cast<Expr>(Stmts.Stmts.pop_back_val());
7693  break;
7694  }
7695 
7696  // Build the final return statement.
7697  if (RetVal.isInvalid())
7698  return StmtError();
7699  StmtResult ReturnStmt = S.BuildReturnStmt(Loc, RetVal.get());
7700  if (ReturnStmt.isInvalid())
7701  return StmtError();
7702  Stmts.Stmts.push_back(ReturnStmt.get());
7703 
7704  return S.ActOnCompoundStmt(Loc, Loc, Stmts.Stmts, /*IsStmtExpr=*/false);
7705  }
7706 
7707 private:
7708  ExprResult getDecl(ValueDecl *VD) {
7709  return S.BuildDeclarationNameExpr(
7710  CXXScopeSpec(), DeclarationNameInfo(VD->getDeclName(), Loc), VD);
7711  }
7712 
7713  ExprResult getParam(unsigned I) {
7714  ParmVarDecl *PD = FD->getParamDecl(I);
7715  return getDecl(PD);
7716  }
7717 
7718  ExprPair getCompleteObject() {
7719  unsigned Param = 0;
7720  ExprResult LHS;
7721  if (isa<CXXMethodDecl>(FD)) {
7722  // LHS is '*this'.
7723  LHS = S.ActOnCXXThis(Loc);
7724  if (!LHS.isInvalid())
7725  LHS = S.CreateBuiltinUnaryOp(Loc, UO_Deref, LHS.get());
7726  } else {
7727  LHS = getParam(Param++);
7728  }
7729  ExprResult RHS = getParam(Param++);
7730  assert(Param == FD->getNumParams());
7731  return {LHS, RHS};
7732  }
7733 
7734  ExprPair getBase(CXXBaseSpecifier *Base) {
7735  ExprPair Obj = getCompleteObject();
7736  if (Obj.first.isInvalid() || Obj.second.isInvalid())
7737  return {ExprError(), ExprError()};
7738  CXXCastPath Path = {Base};
7739  return {S.ImpCastExprToType(Obj.first.get(), Base->getType(),
7740  CK_DerivedToBase, VK_LValue, &Path),
7741  S.ImpCastExprToType(Obj.second.get(), Base->getType(),
7742  CK_DerivedToBase, VK_LValue, &Path)};
7743  }
7744 
7745  ExprPair getField(FieldDecl *Field) {
7746  ExprPair Obj = getCompleteObject();
7747  if (Obj.first.isInvalid() || Obj.second.isInvalid())
7748  return {ExprError(), ExprError()};
7749 
7750  DeclAccessPair Found = DeclAccessPair::make(Field, Field->getAccess());
7751  DeclarationNameInfo NameInfo(Field->getDeclName(), Loc);
7752  return {S.BuildFieldReferenceExpr(Obj.first.get(), /*IsArrow=*/false, Loc,
7753  CXXScopeSpec(), Field, Found, NameInfo),
7754  S.BuildFieldReferenceExpr(Obj.second.get(), /*IsArrow=*/false, Loc,
7755  CXXScopeSpec(), Field, Found, NameInfo)};
7756  }
7757 
7758  // FIXME: When expanding a subobject, register a note in the code synthesis
7759  // stack to say which subobject we're comparing.
7760 
7761  StmtResult buildIfNotCondReturnFalse(ExprResult Cond) {
7762  if (Cond.isInvalid())
7763  return StmtError();
7764 
7765  ExprResult NotCond = S.CreateBuiltinUnaryOp(Loc, UO_LNot, Cond.get());
7766  if (NotCond.isInvalid())
7767  return StmtError();
7768 
7769  ExprResult False = S.ActOnCXXBoolLiteral(Loc, tok::kw_false);
7770  assert(!False.isInvalid() && "should never fail");
7771  StmtResult ReturnFalse = S.BuildReturnStmt(Loc, False.get());
7772  if (ReturnFalse.isInvalid())
7773  return StmtError();
7774 
7775  return S.ActOnIfStmt(Loc, false, nullptr,
7776  S.ActOnCondition(nullptr, Loc, NotCond.get(),
7778  ReturnFalse.get(), SourceLocation(), nullptr);
7779  }
7780 
7781  StmtResult visitSubobjectArray(QualType Type, llvm::APInt Size,
7782  ExprPair Subobj) {
7783  QualType SizeType = S.Context.getSizeType();
7784  Size = Size.zextOrTrunc(S.Context.getTypeSize(SizeType));
7785 
7786  // Build 'size_t i$n = 0'.
7787  IdentifierInfo *IterationVarName = nullptr;
7788  {
7789  SmallString<8> Str;
7790  llvm::raw_svector_ostream OS(Str);
7791  OS << "i" << ArrayDepth;
7792  IterationVarName = &S.Context.Idents.get(OS.str());
7793  }
7794  VarDecl *IterationVar = VarDecl::Create(
7795  S.Context, S.CurContext, Loc, Loc, IterationVarName, SizeType,
7796  S.Context.getTrivialTypeSourceInfo(SizeType, Loc), SC_None);
7797  llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
7798  IterationVar->setInit(
7799  IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
7800  Stmt *Init = new (S.Context) DeclStmt(DeclGroupRef(IterationVar), Loc, Loc);
7801 
7802  auto IterRef = [&] {
7804  CXXScopeSpec(), DeclarationNameInfo(IterationVarName, Loc),
7805  IterationVar);
7806  assert(!Ref.isInvalid() && "can't reference our own variable?");
7807  return Ref.get();
7808  };
7809 
7810  // Build 'i$n != Size'.
7811  ExprResult Cond = S.CreateBuiltinBinOp(
7812  Loc, BO_NE, IterRef(),
7813  IntegerLiteral::Create(S.Context, Size, SizeType, Loc));
7814  assert(!Cond.isInvalid() && "should never fail");
7815 
7816  // Build '++i$n'.
7817  ExprResult Inc = S.CreateBuiltinUnaryOp(Loc, UO_PreInc, IterRef());
7818  assert(!Inc.isInvalid() && "should never fail");
7819 
7820  // Build 'a[i$n]' and 'b[i$n]'.
7821  auto Index = [&](ExprResult E) {
7822  if (E.isInvalid())
7823  return ExprError();
7824  return S.CreateBuiltinArraySubscriptExpr(E.get(), Loc, IterRef(), Loc);
7825  };
7826  Subobj.first = Index(Subobj.first);
7827  Subobj.second = Index(Subobj.second);
7828 
7829  // Compare the array elements.
7830  ++ArrayDepth;
7831  StmtResult Substmt = visitSubobject(Type, Subobj);
7832  --ArrayDepth;
7833 
7834  if (Substmt.isInvalid())
7835  return StmtError();
7836 
7837  // For the inner level of an 'operator==', build 'if (!cmp) return false;'.
7838  // For outer levels or for an 'operator<=>' we already have a suitable
7839  // statement that returns as necessary.
7840  if (Expr *ElemCmp = dyn_cast<Expr>(Substmt.get())) {
7841  assert(DCK == DefaultedComparisonKind::Equal &&
7842  "should have non-expression statement");
7843  Substmt = buildIfNotCondReturnFalse(ElemCmp);
7844  if (Substmt.isInvalid())
7845  return StmtError();
7846  }
7847 
7848  // Build 'for (...) ...'
7849  return S.ActOnForStmt(Loc, Loc, Init,
7850  S.ActOnCondition(nullptr, Loc, Cond.get(),
7852  S.MakeFullDiscardedValueExpr(Inc.get()), Loc,
7853  Substmt.get());
7854  }
7855 
7856  StmtResult visitExpandedSubobject(QualType Type, ExprPair Obj) {
7857  if (Obj.first.isInvalid() || Obj.second.isInvalid())
7858  return StmtError();
7859 
7862  ExprResult Op;
7863  if (Type->isOverloadableType())
7864  Op = S.CreateOverloadedBinOp(Loc, Opc, Fns, Obj.first.get(),
7865  Obj.second.get(), /*PerformADL=*/true,
7866  /*AllowRewrittenCandidates=*/true, FD);
7867  else
7868  Op = S.CreateBuiltinBinOp(Loc, Opc, Obj.first.get(), Obj.second.get());
7869  if (Op.isInvalid())
7870  return StmtError();
7871 
7872  switch (DCK) {
7874  llvm_unreachable("not a defaulted comparison");
7875 
7877  // Per C++2a [class.eq]p2, each comparison is individually contextually
7878  // converted to bool.
7880  if (Op.isInvalid())
7881  return StmtError();
7882  return Op.get();
7883 
7884  case DefaultedComparisonKind::ThreeWay: {
7885  // Per C++2a [class.spaceship]p3, form:
7886  // if (R cmp = static_cast<R>(op); cmp != 0)
7887  // return cmp;
7888  QualType R = FD->getReturnType();
7889  Op = buildStaticCastToR(Op.get());
7890  if (Op.isInvalid())
7891  return StmtError();
7892 
7893  // R cmp = ...;
7894  IdentifierInfo *Name = &S.Context.Idents.get("cmp");
7895  VarDecl *VD =
7896  VarDecl::Create(S.Context, S.CurContext, Loc, Loc, Name, R,
7898  S.AddInitializerToDecl(VD, Op.get(), /*DirectInit=*/false);
7899  Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(VD), Loc, Loc);
7900 
7901  // cmp != 0
7902  ExprResult VDRef = getDecl(VD);
7903  if (VDRef.isInvalid())
7904  return StmtError();
7905  llvm::APInt ZeroVal(S.Context.getIntWidth(S.Context.IntTy), 0);
7906  Expr *Zero =
7907  IntegerLiteral::Create(S.Context, ZeroVal, S.Context.IntTy, Loc);
7908  ExprResult Comp;
7909  if (VDRef.get()->getType()->isOverloadableType())
7910  Comp = S.CreateOverloadedBinOp(Loc, BO_NE, Fns, VDRef.get(), Zero, true,
7911  true, FD);
7912  else
7913  Comp = S.CreateBuiltinBinOp(Loc, BO_NE, VDRef.get(), Zero);
7914  if (Comp.isInvalid())
7915  return StmtError();
7917  nullptr, Loc, Comp.get(), Sema::ConditionKind::Boolean);
7918  if (Cond.isInvalid())
7919  return StmtError();
7920 
7921  // return cmp;
7922  VDRef = getDecl(VD);
7923  if (VDRef.isInvalid())
7924  return StmtError();
7925  StmtResult ReturnStmt = S.BuildReturnStmt(Loc, VDRef.get());
7926  if (ReturnStmt.isInvalid())
7927  return StmtError();
7928 
7929  // if (...)
7930  return S.ActOnIfStmt(Loc, /*IsConstexpr=*/false, InitStmt, Cond,
7931  ReturnStmt.get(), /*ElseLoc=*/SourceLocation(),
7932  /*Else=*/nullptr);
7933  }
7934 
7935  case DefaultedComparisonKind::NotEqual:
7937  // C++2a [class.compare.secondary]p2:
7938  // Otherwise, the operator function yields x @ y.
7939  return Op.get();
7940  }
7941  llvm_unreachable("");
7942  }
7943 
7944  /// Build "static_cast<R>(E)".
7945  ExprResult buildStaticCastToR(Expr *E) {
7946  QualType R = FD->getReturnType();
7947  assert(!R->isUndeducedType() && "type should have been deduced already");
7948 
7949  // Don't bother forming a no-op cast in the common case.
7950  if (E->isRValue() && S.Context.hasSameType(E->getType(), R))
7951  return E;
7952  return S.BuildCXXNamedCast(Loc, tok::kw_static_cast,
7953  S.Context.getTrivialTypeSourceInfo(R, Loc), E,
7954  SourceRange(Loc, Loc), SourceRange(Loc, Loc));
7955  }
7956 };
7957 }
7958 
7959 /// Perform the unqualified lookups that might be needed to form a defaulted
7960 /// comparison function for the given operator.
7962  UnresolvedSetImpl &Operators,
7964  auto Lookup = [&](OverloadedOperatorKind OO) {
7965  Self.LookupOverloadedOperatorName(OO, S, QualType(), QualType(), Operators);
7966  };
7967 
7968  // Every defaulted operator looks up itself.
7969  Lookup(Op);
7970  // ... and the rewritten form of itself, if any.
7972  Lookup(ExtraOp);
7973 
7974  // For 'operator<=>', we also form a 'cmp != 0' expression, and might
7975  // synthesize a three-way comparison from '<' and '=='. In a dependent
7976  // context, we also need to look up '==' in case we implicitly declare a
7977  // defaulted 'operator=='.
7978  if (Op == OO_Spaceship) {
7979  Lookup(OO_ExclaimEqual);
7980  Lookup(OO_Less);
7981  Lookup(OO_EqualEqual);
7982  }
7983 }
7984 
7987  assert(DCK != DefaultedComparisonKind::None && "not a defaulted comparison");
7988 
7989  CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalDeclContext());
7990  assert(RD && "defaulted comparison is not defaulted in a class");
7991 
7992  // Perform any unqualified lookups we're going to need to default this
7993  // function.
7994  if (S) {
7995  UnresolvedSet<32> Operators;
7996  lookupOperatorsForDefaultedComparison(*this, S, Operators,
7997  FD->getOverloadedOperator());
7999  Context, Operators.pairs()));
8000  }
8001 
8002  // C++2a [class.compare.default]p1:
8003  // A defaulted comparison operator function for some class C shall be a
8004  // non-template function declared in the member-specification of C that is
8005  // -- a non-static const member of C having one parameter of type
8006  // const C&, or
8007  // -- a friend of C having two parameters of type const C& or two
8008  // parameters of type C.
8009  QualType ExpectedParmType1 = Context.getRecordType(RD);
8010  QualType ExpectedParmType2 =
8011  Context.getLValueReferenceType(ExpectedParmType1.withConst());
8012  if (isa<CXXMethodDecl>(FD))
8013  ExpectedParmType1 = ExpectedParmType2;
8014  for (const ParmVarDecl *Param : FD->parameters()) {
8015  if (!Param->getType()->isDependentType() &&
8016  !Context.hasSameType(Param->getType(), ExpectedParmType1) &&
8017  !Context.hasSameType(Param->getType(), ExpectedParmType2)) {
8018  // Don't diagnose an implicit 'operator=='; we will have diagnosed the
8019  // corresponding defaulted 'operator<=>' already.
8020  if (!FD->isImplicit()) {
8021  Diag(FD->getLocation(), diag::err_defaulted_comparison_param)
8022  << (int)DCK << Param->getType() << ExpectedParmType1
8023  << !isa<CXXMethodDecl>(FD)
8024  << ExpectedParmType2 << Param->getSourceRange();
8025  }
8026  return true;
8027  }
8028  }
8029  if (FD->getNumParams() == 2 &&
8030  !Context.hasSameType(FD->getParamDecl(0)->getType(),
8031  FD->getParamDecl(1)->getType())) {
8032  if (!FD->isImplicit()) {
8033  Diag(FD->getLocation(), diag::err_defaulted_comparison_param_mismatch)
8034  << (int)DCK
8035  << FD->getParamDecl(0)->getType()
8036  << FD->getParamDecl(0)->getSourceRange()
8037  << FD->getParamDecl(1)->getType()
8038  << FD->getParamDecl(1)->getSourceRange();
8039  }
8040  return true;
8041  }
8042 
8043  // ... non-static const member ...
8044  if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
8045  assert(!MD->isStatic() && "comparison function cannot be a static member");
8046  if (!MD->isConst()) {
8047  SourceLocation InsertLoc;
8048  if (FunctionTypeLoc Loc = MD->getFunctionTypeLoc())
8049  InsertLoc = getLocForEndOfToken(Loc.getRParenLoc());
8050  // Don't diagnose an implicit 'operator=='; we will have diagnosed the
8051  // corresponding defaulted 'operator<=>' already.
8052  if (!MD->isImplicit()) {
8053  Diag(MD->getLocation(), diag::err_defaulted_comparison_non_const)
8054  << (int)DCK << FixItHint::CreateInsertion(InsertLoc, " const");
8055  }
8056 
8057  // Add the 'const' to the type to recover.
8058  const auto *FPT = MD->getType()->castAs<FunctionProtoType>();
8059  FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8060  EPI.TypeQuals.addConst();
8061  MD->setType(Context.getFunctionType(FPT->getReturnType(),
8062  FPT->getParamTypes(), EPI));
8063  }
8064  } else {
8065  // A non-member function declared in a class must be a friend.
8066  assert(FD->getFriendObjectKind() && "expected a friend declaration");
8067  }
8068 
8069  // C++2a [class.eq]p1, [class.rel]p1:
8070  // A [defaulted comparison other than <=>] shall have a declared return
8071  // type bool.
8072  if (DCK != DefaultedComparisonKind::ThreeWay &&
8074  !Context.hasSameType(FD->getDeclaredReturnType(), Context.BoolTy)) {
8075  Diag(FD->getLocation(), diag::err_defaulted_comparison_return_type_not_bool)
8076  << (int)DCK << FD->getDeclaredReturnType() << Context.BoolTy
8077  << FD->getReturnTypeSourceRange();
8078  return true;
8079  }
8080  // C++2a [class.spaceship]p2 [P2002R0]:
8081  // Let R be the declared return type [...]. If R is auto, [...]. Otherwise,
8082  // R shall not contain a placeholder type.
8083  if (DCK == DefaultedComparisonKind::ThreeWay &&
8085  !Context.hasSameType(FD->getDeclaredReturnType(),
8086  Context.getAutoDeductType())) {
8087  Diag(FD->getLocation(),
8088  diag::err_defaulted_comparison_deduced_return_type_not_auto)
8089  << (int)DCK << FD->getDeclaredReturnType() << Context.AutoDeductTy
8090  << FD->getReturnTypeSourceRange();
8091  return true;
8092  }
8093 
8094  // For a defaulted function in a dependent class, defer all remaining checks
8095  // until instantiation.
8096  if (RD->isDependentType())
8097  return false;
8098 
8099  // Determine whether the function should be defined as deleted.
8100  DefaultedComparisonInfo Info =
8101  DefaultedComparisonAnalyzer(*this, RD, FD, DCK).visit();
8102 
8103  bool First = FD == FD->getCanonicalDecl();
8104 
8105  // If we want to delete the function, then do so; there's nothing else to
8106  // check in that case.
8107  if (Info.Deleted) {
8108  if (!First) {
8109  // C++11 [dcl.fct.def.default]p4:
8110  // [For a] user-provided explicitly-defaulted function [...] if such a
8111  // function is implicitly defined as deleted, the program is ill-formed.
8112  //
8113  // This is really just a consequence of the general rule that you can
8114  // only delete a function on its first declaration.
8115  Diag(FD->getLocation(), diag::err_non_first_default_compare_deletes)
8116  << FD->isImplicit() << (int)DCK;
8117  DefaultedComparisonAnalyzer(*this, RD, FD, DCK,
8118  DefaultedComparisonAnalyzer::ExplainDeleted)
8119  .visit();
8120  return true;
8121  }
8122 
8123  SetDeclDeleted(FD, FD->getLocation());
8124  if (!inTemplateInstantiation() && !FD->isImplicit()) {
8125  Diag(FD->getLocation(), diag::warn_defaulted_comparison_deleted)
8126  << (int)DCK;
8127  DefaultedComparisonAnalyzer(*this, RD, FD, DCK,
8128  DefaultedComparisonAnalyzer::ExplainDeleted)
8129  .visit();
8130  }
8131  return false;
8132  }
8133 
8134  // C++2a [class.spaceship]p2:
8135  // The return type is deduced as the common comparison type of R0, R1, ...
8136  if (DCK == DefaultedComparisonKind::ThreeWay &&
8139  if (RetLoc.isInvalid())
8140  RetLoc = FD->getBeginLoc();
8141  // FIXME: Should we really care whether we have the complete type and the
8142  // 'enumerator' constants here? A forward declaration seems sufficient.
8143  QualType Cat = CheckComparisonCategoryType(
8144  Info.Category, RetLoc, ComparisonCategoryUsage::DefaultedOperator);
8145  if (Cat.isNull())
8146  return true;
8148  FD, SubstAutoType(FD->getDeclaredReturnType(), Cat));
8149  }
8150 
8151  // C++2a [dcl.fct.def.default]p3 [P2002R0]:
8152  // An explicitly-defaulted function that is not defined as deleted may be
8153  // declared constexpr or consteval only if it is constexpr-compatible.
8154  // C++2a [class.compare.default]p3 [P2002R0]:
8155  // A defaulted comparison function is constexpr-compatible if it satisfies
8156  // the requirements for a constexpr function [...]
8157  // The only relevant requirements are that the parameter and return types are
8158  // literal types. The remaining conditions are checked by the analyzer.
8159  if (FD->isConstexpr()) {
8160  if (CheckConstexprReturnType(*this, FD, CheckConstexprKind::Diagnose) &&
8161  CheckConstexprParameterTypes(*this, FD, CheckConstexprKind::Diagnose) &&
8162  !Info.Constexpr) {
8163  Diag(FD->getBeginLoc(),
8164  diag::err_incorrect_defaulted_comparison_constexpr)
8165  << FD->isImplicit() << (int)DCK << FD->isConsteval();
8166  DefaultedComparisonAnalyzer(*this, RD, FD, DCK,
8167  DefaultedComparisonAnalyzer::ExplainConstexpr)
8168  .visit();
8169  }
8170  }
8171 
8172  // C++2a [dcl.fct.def.default]p3 [P2002R0]:
8173  // If a constexpr-compatible function is explicitly defaulted on its first
8174  // declaration, it is implicitly considered to be constexpr.
8175  // FIXME: Only applying this to the first declaration seems problematic, as
8176  // simple reorderings can affect the meaning of the program.
8177  if (First && !FD->isConstexpr() && Info.Constexpr)
8179 
8180  // C++2a [except.spec]p3:
8181  // If a declaration of a function does not have a noexcept-specifier
8182  // [and] is defaulted on its first declaration, [...] the exception
8183  // specification is as specified below
8184  if (FD->getExceptionSpecType() == EST_None) {
8185  auto *FPT = FD->getType()->castAs<FunctionProtoType>();
8186  FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8188  EPI.ExceptionSpec.SourceDecl = FD;
8189  FD->setType(Context.getFunctionType(FPT->getReturnType(),
8190  FPT->getParamTypes(), EPI));
8191  }
8192 
8193  return false;
8194 }
8195 
8200  Ctx.PointOfInstantiation = Spaceship->getEndLoc();
8201  Ctx.Entity = Spaceship;
8202  pushCodeSynthesisContext(Ctx);
8203 
8204  if (FunctionDecl *EqualEqual = SubstSpaceshipAsEqualEqual(RD, Spaceship))
8205  EqualEqual->setImplicit();
8206 
8207  popCodeSynthesisContext();
8208 }
8209 
8212  assert(FD->isDefaulted() && !FD->isDeleted() &&
8214  if (FD->willHaveBody() || FD->isInvalidDecl())
8215  return;
8216 
8217  SynthesizedFunctionScope Scope(*this, FD);
8218 
8219  // Add a context note for diagnostics produced after this point.
8220  Scope.addContextNote(UseLoc);
8221 
8222  {
8223  // Build and set up the function body.
8224  CXXRecordDecl *RD = cast<CXXRecordDecl>(FD->getLexicalParent());
8225  SourceLocation BodyLoc =
8226  FD->getEndLoc().isValid() ? FD->getEndLoc() : FD->getLocation();
8227  StmtResult Body =
8228  DefaultedComparisonSynthesizer(*this, RD, FD, DCK, BodyLoc).build();
8229  if (Body.isInvalid()) {
8230  FD->setInvalidDecl();
8231  return;
8232  }
8233  FD->setBody(Body.get());
8234  FD->markUsed(Context);
8235  }
8236 
8237  // The exception specification is needed because we are defining the
8238  // function. Note that this will reuse the body we just built.
8239  ResolveExceptionSpec(UseLoc, FD->getType()->castAs<FunctionProtoType>());
8240 
8241  if (ASTMutationListener *L = getASTMutationListener())
8242  L->CompletedImplicitDefinition(FD);
8243 }
8244 
8247  FunctionDecl *FD,
8249  ComputingExceptionSpec CES(S, FD, Loc);
8251 
8252  if (FD->isInvalidDecl())
8253  return ExceptSpec;
8254 
8255  // The common case is that we just defined the comparison function. In that
8256  // case, just look at whether the body can throw.
8257  if (FD->hasBody()) {
8258  ExceptSpec.CalledStmt(FD->getBody());
8259  } else {
8260  // Otherwise, build a body so we can check it. This should ideally only
8261  // happen when we're not actually marking the function referenced. (This is
8262  // only really important for efficiency: we don't want to build and throw
8263  // away bodies for comparison functions more than we strictly need to.)
8264 
8265  // Pretend to synthesize the function body in an unevaluated context.
8266  // Note that we can't actually just go ahead and define the function here:
8267  // we are not permitted to mark its callees as referenced.
8271 
8272  CXXRecordDecl *RD = cast<CXXRecordDecl>(FD->getLexicalParent());
8273  SourceLocation BodyLoc =
8274  FD->getEndLoc().isValid() ? FD->getEndLoc() : FD->getLocation();
8275  StmtResult Body =
8276  DefaultedComparisonSynthesizer(S, RD, FD, DCK, BodyLoc).build();
8277  if (!Body.isInvalid())
8278  ExceptSpec.CalledStmt(Body.get());
8279 
8280  // FIXME: Can we hold onto this body and just transform it to potentially
8281  // evaluated when we're asked to define the function rather than rebuilding
8282  // it? Either that, or we should only build the bits of the body that we
8283  // need (the expressions, not the statements).
8284  }
8285 
8286  return ExceptSpec;
8287 }
8288 
8290  decltype(DelayedOverridingExceptionSpecChecks) Overriding;
8291  decltype(DelayedEquivalentExceptionSpecChecks) Equivalent;
8292 
8293  std::swap(Overriding, DelayedOverridingExceptionSpecChecks);
8294  std::swap(Equivalent, DelayedEquivalentExceptionSpecChecks);
8295 
8296  // Perform any deferred checking of exception specifications for virtual
8297  // destructors.
8298  for (auto &Check : Overriding)
8299  CheckOverridingFunctionExceptionSpec(Check.first, Check.second);
8300 
8301  // Perform any deferred checking of exception specifications for befriended
8302  // special members.
8303  for (auto &Check : Equivalent)
8304  CheckEquivalentExceptionSpec(Check.second, Check.first);
8305 }
8306 
8307 namespace {
8308 /// CRTP base class for visiting operations performed by a special member
8309 /// function (or inherited constructor).
8310 template<typename Derived>
8311 struct SpecialMemberVisitor {
8312  Sema &S;
8313  CXXMethodDecl *MD;
8316 
8317  // Properties of the special member, computed for convenience.
8318  bool IsConstructor = false, IsAssignment = false, ConstArg = false;
8319 
8320  SpecialMemberVisitor(Sema &S, CXXMethodDecl *MD, Sema::CXXSpecialMember CSM,
8322  : S(S), MD(MD), CSM(CSM), ICI(ICI) {
8323  switch (CSM) {
8327  IsConstructor = true;
8328  break;
8331  IsAssignment = true;
8332  break;
8333  case Sema::CXXDestructor:
8334  break;
8335  case Sema::CXXInvalid:
8336  llvm_unreachable("invalid special member kind");
8337  }
8338 
8339  if (MD->getNumParams()) {
8340  if (const ReferenceType *RT =
8341  MD->getParamDecl(0)->getType()->getAs<ReferenceType>())
8342  ConstArg = RT->getPointeeType().isConstQualified();
8343  }
8344  }
8345 
8346  Derived &getDerived() { return static_cast<Derived&>(*this); }
8347 
8348  /// Is this a "move" special member?
8349  bool isMove() const {
8350  return CSM == Sema::CXXMoveConstructor || CSM == Sema::CXXMoveAssignment;
8351  }
8352 
8353  /// Look up the corresponding special member in the given class.
8355  unsigned Quals, bool IsMutable) {
8356  return lookupCallFromSpecialMember(S, Class, CSM, Quals,
8357  ConstArg && !IsMutable);
8358  }
8359 
8360  /// Look up the constructor for the specified base class to see if it's
8361  /// overridden due to this being an inherited constructor.
8362  Sema::SpecialMemberOverloadResult lookupInheritedCtor(CXXRecordDecl *Class) {
8363  if (!ICI)
8364  return {};
8365  assert(CSM == Sema::CXXDefaultConstructor);
8366  auto *BaseCtor =
8367  cast<CXXConstructorDecl>(MD)->getInheritedConstructor().getConstructor();
8368  if (auto *MD = ICI->findConstructorForBase(Class, BaseCtor).first)
8369  return MD;
8370  return {};
8371  }
8372 
8373  /// A base or member subobject.
8374  typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
8375 
8376  /// Get the location to use for a subobject in diagnostics.
8377  static SourceLocation getSubobjectLoc(Subobject Subobj) {
8378  // FIXME: For an indirect virtual base, the direct base leading to
8379  // the indirect virtual base would be a more useful choice.
8380  if (auto *B = Subobj.dyn_cast<CXXBaseSpecifier*>())
8381  return B->getBaseTypeLoc();
8382  else
8383  return Subobj.get<FieldDecl*>()->getLocation();
8384  }
8385 
8386  enum BasesToVisit {
8387  /// Visit all non-virtual (direct) bases.
8388  VisitNonVirtualBases,
8389  /// Visit all direct bases, virtual or not.
8390  VisitDirectBases,
8391  /// Visit all non-virtual bases, and all virtual bases if the class
8392  /// is not abstract.
8393  VisitPotentiallyConstructedBases,
8394  /// Visit all direct or virtual bases.
8395  VisitAllBases
8396  };
8397 
8398  // Visit the bases and members of the class.
8399  bool visit(BasesToVisit Bases) {
8400  CXXRecordDecl *RD = MD->getParent();
8401 
8402  if (Bases == VisitPotentiallyConstructedBases)
8403  Bases = RD->isAbstract() ? VisitNonVirtualBases : VisitAllBases;
8404 
8405  for (auto &B : RD->bases())
8406  if ((Bases == VisitDirectBases || !B.isVirtual()) &&
8407  getDerived().visitBase(&B))
8408  return true;
8409 
8410  if (Bases == VisitAllBases)
8411  for (auto &B : RD->vbases())
8412  if (getDerived().visitBase(&B))
8413  return true;
8414 
8415  for (auto *F : RD->fields())
8416  if (!F->isInvalidDecl() && !F->isUnnamedBitfield() &&
8417  getDerived().visitField(F))
8418  return true;
8419 
8420  return false;
8421  }
8422 };
8423 }
8424 
8425 namespace {
8426 struct SpecialMemberDeletionInfo
8427  : SpecialMemberVisitor<SpecialMemberDeletionInfo> {
8428  bool Diagnose;
8429 
8430  SourceLocation Loc;
8431 
8432  bool AllFieldsAreConst;
8433 
8434  SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD,
8436  Sema::InheritedConstructorInfo *ICI, bool Diagnose)
8437  : SpecialMemberVisitor(S, MD, CSM, ICI), Diagnose(Diagnose),
8438  Loc(MD->getLocation()), AllFieldsAreConst(true) {}
8439 
8440  bool inUnion() const { return MD->getParent()->isUnion(); }
8441 
8442  Sema::CXXSpecialMember getEffectiveCSM() {
8443  return ICI ? Sema::CXXInvalid : CSM;
8444  }
8445 
8446  bool shouldDeleteForVariantObjCPtrMember(FieldDecl *FD, QualType FieldType);
8447 
8448  bool visitBase(CXXBaseSpecifier *Base) { return shouldDeleteForBase(Base); }
8449  bool visitField(FieldDecl *Field) { return shouldDeleteForField(Field); }
8450 
8451  bool shouldDeleteForBase(CXXBaseSpecifier *Base);
8452  bool shouldDeleteForField(FieldDecl *FD);
8453  bool shouldDeleteForAllConstMembers();
8454 
8455  bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
8456  unsigned Quals);
8457  bool shouldDeleteForSubobjectCall(Subobject Subobj,
8459  bool IsDtorCallInCtor);
8460 
8461  bool isAccessible(Subobject Subobj, CXXMethodDecl *D);
8462 };
8463 }
8464 
8465 /// Is the given special member inaccessible when used on the given
8466 /// sub-object.
8467 bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
8468  CXXMethodDecl *target) {
8469  /// If we're operating on a base class, the object type is the
8470  /// type of this special member.
8471  QualType objectTy;
8472  AccessSpecifier access = target->getAccess();
8473  if (CXXBaseSpecifier *base = Subobj.dyn_cast<CXXBaseSpecifier*>()) {
8474  objectTy = S.Context.getTypeDeclType(MD->getParent());
8475  access = CXXRecordDecl::MergeAccess(base->getAccessSpecifier(), access);
8476 
8477  // If we're operating on a field, the object type is the type of the field.
8478  } else {
8479  objectTy = S.Context.getTypeDeclType(target->getParent());
8480  }
8481 
8483  target->getParent(), DeclAccessPair::make(target, access), objectTy);
8484 }
8485 
8486 /// Check whether we should delete a special member due to the implicit
8487 /// definition containing a call to a special member of a subobject.
8488 bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
8489  Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR,
8490  bool IsDtorCallInCtor) {
8491  CXXMethodDecl *Decl = SMOR.getMethod();
8492  FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
8493 
8494  int DiagKind = -1;
8495 
8497  DiagKind = !Decl ? 0 : 1;
8499  DiagKind = 2;
8500  else if (!isAccessible(Subobj, Decl))
8501  DiagKind = 3;
8502  else if (!IsDtorCallInCtor && Field && Field->getParent()->isUnion() &&
8503  !Decl->isTrivial()) {
8504  // A member of a union must have a trivial corresponding special member.
8505  // As a weird special case, a destructor call from a union's constructor
8506  // must be accessible and non-deleted, but need not be trivial. Such a
8507  // destructor is never actually called, but is semantically checked as
8508  // if it were.
8509  DiagKind = 4;
8510  }
8511 
8512  if (DiagKind == -1)
8513  return false;
8514 
8515  if (Diagnose) {
8516  if (Field) {
8517  S.Diag(Field->getLocation(),
8518  diag::note_deleted_special_member_class_subobject)
8519  << getEffectiveCSM() << MD->getParent() << /*IsField*/true
8520  << Field << DiagKind << IsDtorCallInCtor << /*IsObjCPtr*/false;
8521  } else {
8522  CXXBaseSpecifier *Base = Subobj.get<CXXBaseSpecifier*>();
8523  S.Diag(Base->getBeginLoc(),
8524  diag::note_deleted_special_member_class_subobject)
8525  << getEffectiveCSM() << MD->getParent() << /*IsField*/ false
8526  << Base->getType() << DiagKind << IsDtorCallInCtor
8527  << /*IsObjCPtr*/false;
8528  }
8529 
8530  if (DiagKind == 1)
8531  S.NoteDeletedFunction(Decl);
8532  // FIXME: Explain inaccessibility if DiagKind == 3.
8533  }
8534 
8535  return true;
8536 }
8537 
8538 /// Check whether we should delete a special member function due to having a
8539 /// direct or virtual base class or non-static data member of class type M.
8540 bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
8541  CXXRecordDecl *Class, Subobject Subobj, unsigned Quals) {
8542  FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
8543  bool IsMutable = Field && Field->isMutable();
8544 
8545  // C++11 [class.ctor]p5:
8546  // -- any direct or virtual base class, or non-static data member with no
8547  // brace-or-equal-initializer, has class type M (or array thereof) and
8548  // either M has no default constructor or overload resolution as applied
8549  // to M's default constructor results in an ambiguity or in a function
8550  // that is deleted or inaccessible
8551  // C++11 [class.copy]p11, C++11 [class.copy]p23:
8552  // -- a direct or virtual base class B that cannot be copied/moved because
8553  // overload resolution, as applied to B's corresponding special member,
8554  // results in an ambiguity or a function that is deleted or inaccessible
8555  // from the defaulted special member
8556  // C++11 [class.dtor]p5:
8557  // -- any direct or virtual base class [...] has a type with a destructor
8558  // that is deleted or inaccessible
8559  if (!(CSM == Sema::CXXDefaultConstructor &&
8560  Field && Field->hasInClassInitializer()) &&
8561  shouldDeleteForSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable),
8562  false))
8563  return true;
8564 
8565  // C++11 [class.ctor]p5, C++11 [class.copy]p11:
8566  // -- any direct or virtual base class or non-static data member has a
8567  // type with a destructor that is deleted or inaccessible
8568  if (IsConstructor) {
8571  false, false, false, false, false);
8572  if (shouldDeleteForSubobjectCall(Subobj, SMOR, true))
8573  return true;
8574  }
8575 
8576  return false;
8577 }
8578 
8579 bool SpecialMemberDeletionInfo::shouldDeleteForVariantObjCPtrMember(
8580  FieldDecl *FD, QualType FieldType) {
8581  // The defaulted special functions are defined as deleted if this is a variant
8582  // member with a non-trivial ownership type, e.g., ObjC __strong or __weak
8583  // type under ARC.
8584  if (!FieldType.hasNonTrivialObjCLifetime())
8585  return false;
8586 
8587  // Don't make the defaulted default constructor defined as deleted if the
8588  // member has an in-class initializer.
8590  return false;
8591 
8592  if (Diagnose) {
8593  auto *ParentClass = cast<CXXRecordDecl>(FD->getParent());
8594  S.Diag(FD->getLocation(),
8595  diag::note_deleted_special_member_class_subobject)
8596  << getEffectiveCSM() << ParentClass << /*IsField*/true
8597  << FD << 4 << /*IsDtorCallInCtor*/false << /*IsObjCPtr*/true;
8598  }
8599 
8600  return true;
8601 }
8602 
8603 /// Check whether we should delete a special member function due to the class
8604 /// having a particular direct or virtual base class.
8605 bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
8606  CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
8607  // If program is correct, BaseClass cannot be null, but if it is, the error
8608  // must be reported elsewhere.
8609  if (!BaseClass)
8610  return false;
8611  // If we have an inheriting constructor, check whether we're calling an
8612  // inherited constructor instead of a default constructor.
8613  Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
8614  if (auto *BaseCtor = SMOR.getMethod()) {
8615  // Note that we do not check access along this path; other than that,
8616  // this is the same as shouldDeleteForSubobjectCall(Base, BaseCtor, false);
8617  // FIXME: Check that the base has a usable destructor! Sink this into
8618  // shouldDeleteForClassSubobject.
8619  if (BaseCtor->isDeleted() && Diagnose) {
8620  S.Diag(Base->getBeginLoc(),
8621  diag::note_deleted_special_member_class_subobject)
8622  << getEffectiveCSM() << MD->getParent() << /*IsField*/ false
8623  << Base->getType() << /*Deleted*/ 1 << /*IsDtorCallInCtor*/ false
8624  << /*IsObjCPtr*/false;
8625  S.NoteDeletedFunction(BaseCtor);
8626  }
8627  return BaseCtor->isDeleted();
8628  }
8629  return shouldDeleteForClassSubobject(BaseClass, Base, 0);
8630 }
8631 
8632 /// Check whether we should delete a special member function due to the class
8633 /// having a particular non-static data member.
8634 bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) {
8635  QualType FieldType = S.Context.getBaseElementType(FD->getType());
8636  CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl();
8637 
8638  if (inUnion() && shouldDeleteForVariantObjCPtrMember(FD, FieldType))
8639  return true;
8640 
8641  if (CSM == Sema::CXXDefaultConstructor) {
8642  // For a default constructor, all references must be initialized in-class
8643  // and, if a union, it must have a non-const member.
8644  if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) {
8645  if (Diagnose)
8646  S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
8647  << !!ICI << MD->getParent() << FD << FieldType << /*Reference*/0;
8648  return true;
8649  }
8650  // C++11 [class.ctor]p5: any non-variant non-static data member of
8651  // const-qualified type (or array thereof) with no
8652  // brace-or-equal-initializer does not have a user-provided default
8653  // constructor.
8654  if (!inUnion() && FieldType.isConstQualified() &&
8655  !FD->hasInClassInitializer() &&
8656  (!FieldRecord || !FieldRecord->hasUserProvidedDefaultConstructor())) {
8657  if (Diagnose)
8658  S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
8659  << !!ICI << MD->getParent() << FD << FD->getType() << /*Const*/1;
8660  return true;
8661  }
8662 
8663  if (inUnion() && !FieldType.isConstQualified())
8664  AllFieldsAreConst = false;
8665  } else if (CSM == Sema::CXXCopyConstructor) {
8666  // For a copy constructor, data members must not be of rvalue reference
8667  // type.
8668  if (FieldType->isRValueReferenceType()) {
8669  if (Diagnose)
8670  S.Diag(FD->getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
8671  << MD->getParent() << FD << FieldType;
8672  return true;
8673  }
8674  } else if (IsAssignment) {
8675  // For an assignment operator, data members must not be of reference type.
8676  if (FieldType->isReferenceType()) {
8677  if (Diagnose)
8678  S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
8679  << isMove() << MD->getParent() << FD << FieldType << /*Reference*/0;
8680  return true;
8681  }
8682  if (!FieldRecord && FieldType.isConstQualified()) {
8683  // C++11 [class.copy]p23:
8684  // -- a non-static data member of const non-class type (or array thereof)
8685  if (Diagnose)
8686  S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
8687  << isMove() << MD->getParent() << FD << FD->getType() << /*Const*/1;
8688  return true;
8689  }
8690  }
8691 
8692  if (FieldRecord) {
8693  // Some additional restrictions exist on the variant members.
8694  if (!inUnion() && FieldRecord->isUnion() &&
8695  FieldRecord->isAnonymousStructOrUnion()) {
8696  bool AllVariantFieldsAreConst = true;
8697 
8698  // FIXME: Handle anonymous unions declared within anonymous unions.
8699  for (auto *UI : FieldRecord->fields()) {
8700  QualType UnionFieldType = S.Context.getBaseElementType(UI->getType());
8701 
8702  if (shouldDeleteForVariantObjCPtrMember(&*UI, UnionFieldType))
8703  return true;
8704 
8705  if (!UnionFieldType.isConstQualified())
8706  AllVariantFieldsAreConst = false;
8707 
8708  CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl();
8709  if (UnionFieldRecord &&
8710  shouldDeleteForClassSubobject(UnionFieldRecord, UI,
8711  UnionFieldType.getCVRQualifiers()))
8712  return true;
8713  }
8714 
8715  // At least one member in each anonymous union must be non-const
8716  if (CSM == Sema::CXXDefaultConstructor && AllVariantFieldsAreConst &&
8717  !FieldRecord->field_empty()) {
8718  if (Diagnose)
8719  S.Diag(FieldRecord->getLocation(),
8720  diag::note_deleted_default_ctor_all_const)
8721  << !!ICI << MD->getParent() << /*anonymous union*/1;
8722  return true;
8723  }
8724 
8725  // Don't check the implicit member of the anonymous union type.
8726  // This is technically non-conformant, but sanity demands it.
8727  return false;
8728  }
8729 
8730  if (shouldDeleteForClassSubobject(FieldRecord, FD,
8731  FieldType.getCVRQualifiers()))
8732  return true;
8733  }
8734 
8735  return false;
8736 }
8737 
8738 /// C++11 [class.ctor] p5:
8739 /// A defaulted default constructor for a class X is defined as deleted if
8740 /// X is a union and all of its variant members are of const-qualified type.
8741 bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
8742  // This is a silly definition, because it gives an empty union a deleted
8743  // default constructor. Don't do that.
8744  if (CSM == Sema::CXXDefaultConstructor && inUnion() && AllFieldsAreConst) {
8745  bool AnyFields = false;
8746  for (auto *F : MD->getParent()->fields())
8747  if ((AnyFields = !F->isUnnamedBitfield()))
8748  break;
8749  if (!AnyFields)
8750  return false;
8751  if (Diagnose)
8752  S.Diag(MD->getParent()->getLocation(),
8753  diag::note_deleted_default_ctor_all_const)
8754  << !!ICI << MD->getParent() << /*not anonymous union*/0;
8755  return true;
8756  }
8757  return false;
8758 }
8759 
8760 /// Determine whether a defaulted special member function should be defined as
8761 /// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11,
8762 /// C++11 [class.copy]p23, and C++11 [class.dtor]p5.
8765  bool Diagnose) {
8766  if (MD->isInvalidDecl())
8767  return false;
8768  CXXRecordDecl *RD = MD->getParent();
8769  assert(!RD->isDependentType() && "do deletion after instantiation");
8770  if (!LangOpts.CPlusPlus11 || RD->isInvalidDecl())
8771  return false;
8772 
8773  // C++11 [expr.lambda.prim]p19:
8774  // The closure type associated with a lambda-expression has a
8775  // deleted (8.4.3) default constructor and a deleted copy
8776  // assignment operator.
8777  // C++2a adds back these operators if the lambda has no lambda-capture.
8779  (CSM == CXXDefaultConstructor || CSM == CXXCopyAssignment)) {
8780  if (Diagnose)
8781  Diag(RD->getLocation(), diag::note_lambda_decl);
8782  return true;
8783  }
8784 
8785  // For an anonymous struct or union, the copy and assignment special members
8786  // will never be used, so skip the check. For an anonymous union declared at
8787  // namespace scope, the constructor and destructor are used.
8788  if (CSM != CXXDefaultConstructor && CSM != CXXDestructor &&
8790  return false;
8791 
8792  // C++11 [class.copy]p7, p18:
8793  // If the class definition declares a move constructor or move assignment
8794  // operator, an implicitly declared copy constructor or copy assignment
8795  // operator is defined as deleted.
8796  if (MD->isImplicit() &&
8797  (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment)) {
8798  CXXMethodDecl *UserDeclaredMove = nullptr;
8799 
8800  // In Microsoft mode up to MSVC 2013, a user-declared move only causes the
8801  // deletion of the corresponding copy operation, not both copy operations.
8802  // MSVC 2015 has adopted the standards conforming behavior.
8803  bool DeletesOnlyMatchingCopy =
8804  getLangOpts().MSVCCompat &&
8805  !getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015);
8806 
8807  if (RD->hasUserDeclaredMoveConstructor() &&
8808  (!DeletesOnlyMatchingCopy || CSM == CXXCopyConstructor)) {
8809  if (!Diagnose) return true;
8810 
8811  // Find any user-declared move constructor.
8812  for (auto *I : RD->ctors()) {
8813  if (I->isMoveConstructor()) {
8814  UserDeclaredMove = I;
8815  break;
8816  }
8817  }
8818  assert(UserDeclaredMove);
8819  } else if (RD->hasUserDeclaredMoveAssignment() &&
8820  (!DeletesOnlyMatchingCopy || CSM == CXXCopyAssignment)) {
8821  if (!Diagnose) return true;
8822 
8823  // Find any user-declared move assignment operator.
8824  for (auto *I : RD->methods()) {
8825  if (I->isMoveAssignmentOperator()) {
8826  UserDeclaredMove = I;
8827  break;
8828  }
8829  }
8830  assert(UserDeclaredMove);
8831  }
8832 
8833  if (UserDeclaredMove) {
8834  Diag(UserDeclaredMove->getLocation(),
8835  diag::note_deleted_copy_user_declared_move)
8836  << (CSM == CXXCopyAssignment) << RD
8837  << UserDeclaredMove->isMoveAssignmentOperator();
8838  return true;
8839  }
8840  }
8841 
8842  // Do access control from the special member function
8843  ContextRAII MethodContext(*this, MD);
8844 
8845  // C++11 [class.dtor]p5:
8846  // -- for a virtual destructor, lookup of the non-array deallocation function
8847  // results in an ambiguity or in a function that is deleted or inaccessible
8848  if (CSM == CXXDestructor && MD->isVirtual()) {
8849  FunctionDecl *OperatorDelete = nullptr;
8850  DeclarationName Name =
8851  Context.DeclarationNames.getCXXOperatorName(OO_Delete);
8852  if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name,
8853  OperatorDelete, /*Diagnose*/false)) {
8854  if (Diagnose)
8855  Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete);
8856  return true;
8857  }
8858  }
8859 
8860  SpecialMemberDeletionInfo SMI(*this, MD, CSM, ICI, Diagnose);
8861 
8862  // Per DR1611, do not consider virtual bases of constructors of abstract
8863  // classes, since we are not going to construct them.
8864  // Per DR1658, do not consider virtual bases of destructors of abstract
8865  // classes either.
8866  // Per DR2180, for assignment operators we only assign (and thus only
8867  // consider) direct bases.
8868  if (SMI.visit(SMI.IsAssignment ? SMI.VisitDirectBases
8869  : SMI.VisitPotentiallyConstructedBases))
8870  return true;
8871 
8872  if (SMI.shouldDeleteForAllConstMembers())
8873  return true;
8874 
8875  if (getLangOpts().CUDA) {
8876  // We should delete the special member in CUDA mode if target inference
8877  // failed.
8878  // For inherited constructors (non-null ICI), CSM may be passed so that MD
8879  // is treated as certain special member, which may not reflect what special
8880  // member MD really is. However inferCUDATargetForImplicitSpecialMember
8881  // expects CSM to match MD, therefore recalculate CSM.
8882  assert(ICI || CSM == getSpecialMember(MD));
8883  auto RealCSM = CSM;
8884  if (ICI)
8885  RealCSM = getSpecialMember(MD);
8886 
8887  return inferCUDATargetForImplicitSpecialMember(RD, RealCSM, MD,
8888  SMI.ConstArg, Diagnose);
8889  }
8890 
8891  return false;
8892 }
8893 
8895  DefaultedFunctionKind DFK = getDefaultedFunctionKind(FD);
8896  assert(DFK && "not a defaultable function");
8897  assert(FD->isDefaulted() && FD->isDeleted() && "not defaulted and deleted");
8898 
8899  if (DFK.isSpecialMember()) {
8900  ShouldDeleteSpecialMember(cast<CXXMethodDecl>(FD), DFK.asSpecialMember(),
8901  nullptr, /*Diagnose=*/true);
8902  } else {
8903  DefaultedComparisonAnalyzer(
8904  *this, cast<CXXRecordDecl>(FD->getLexicalDeclContext()), FD,
8905  DFK.asComparison(), DefaultedComparisonAnalyzer::ExplainDeleted)
8906  .visit();
8907  }
8908 }
8909 
8910 /// Perform lookup for a special member of the specified kind, and determine
8911 /// whether it is trivial. If the triviality can be determined without the
8912 /// lookup, skip it. This is intended for use when determining whether a
8913 /// special member of a containing object is trivial, and thus does not ever
8914 /// perform overload resolution for default constructors.
8915 ///
8916 /// If \p Selected is not \c NULL, \c *Selected will be filled in with the
8917 /// member that was most likely to be intended to be trivial, if any.
8918 ///
8919 /// If \p ForCall is true, look at CXXRecord::HasTrivialSpecialMembersForCall to
8920 /// determine whether the special member is trivial.
8922  Sema::CXXSpecialMember CSM, unsigned Quals,
8923  bool ConstRHS,
8925  CXXMethodDecl **Selected) {
8926  if (Selected)
8927  *Selected = nullptr;
8928 
8929  switch (CSM) {
8930  case Sema::CXXInvalid:
8931  llvm_unreachable("not a special member");
8932 
8934  // C++11 [class.ctor]p5:
8935  // A default constructor is trivial if:
8936  // - all the [direct subobjects] have trivial default constructors
8937  //
8938  // Note, no overload resolution is performed in this case.
8939  if (RD->hasTrivialDefaultConstructor())
8940  return true;
8941 
8942  if (Selected) {
8943  // If there's a default constructor which could have been trivial, dig it
8944  // out. Otherwise, if there's any user-provided default constructor, point
8945  // to that as an example of why there's not a trivial one.
8946  CXXConstructorDecl *DefCtor = nullptr;
8949  for (auto *CI : RD->ctors()) {
8950  if (!CI->isDefaultConstructor())
8951  continue;
8952  DefCtor = CI;
8953  if (!DefCtor->isUserProvided())
8954  break;
8955  }
8956 
8957  *Selected = DefCtor;
8958  }
8959 
8960  return false;
8961 
8962  case Sema::CXXDestructor:
8963  // C++11 [class.dtor]p5:
8964  // A destructor is trivial if:
8965  // - all the direct [subobjects] have trivial destructors
8966  if (RD->hasTrivialDestructor() ||
8967  (TAH == Sema::TAH_ConsiderTrivialABI &&
8969  return true;
8970 
8971  if (Selected) {
8972  if (RD->needsImplicitDestructor())
8974  *Selected = RD->getDestructor();
8975  }
8976 
8977  return false;
8978 
8980  // C++11 [class.copy]p12:
8981  // A copy constructor is trivial if:
8982  // - the constructor selected to copy each direct [subobject] is trivial
8983  if (RD->hasTrivialCopyConstructor() ||
8984  (TAH == Sema::TAH_ConsiderTrivialABI &&
8986  if (Quals == Qualifiers::Const)
8987  // We must either select the trivial copy constructor or reach an
8988  // ambiguity; no need to actually perform overload resolution.
8989  return true;
8990  } else if (!Selected) {
8991  return false;
8992  }
8993  // In C++98, we are not supposed to perform overload resolution here, but we
8994  // treat that as a language defect, as suggested on cxx-abi-dev, to treat
8995  // cases like B as having a non-trivial copy constructor:
8996  // struct A { template<typename T> A(T&); };
8997  // struct B { mutable A a; };
8998  goto NeedOverloadResolution;
8999 
9001  // C++11 [class.copy]p25:
9002  // A copy assignment operator is trivial if:
9003  // - the assignment operator selected to copy each direct [subobject] is
9004  // trivial
9005  if (RD->hasTrivialCopyAssignment()) {
9006  if (Quals == Qualifiers::Const)
9007  return true;
9008  } else if (!Selected) {
9009  return false;
9010  }
9011  // In C++98, we are not supposed to perform overload resolution here, but we
9012  // treat that as a language defect.
9013  goto NeedOverloadResolution;
9014 
9017  NeedOverloadResolution:
9019  lookupCallFromSpecialMember(S, RD, CSM, Quals, ConstRHS);
9020 
9021  // The standard doesn't describe how to behave if the lookup is ambiguous.
9022  // We treat it as not making the member non-trivial, just like the standard
9023  // mandates for the default constructor. This should rarely matter, because
9024  // the member will also be deleted.
9026  return true;
9027 
9028  if (!SMOR.getMethod()) {
9029  assert(SMOR.getKind() ==
9031  return false;
9032  }
9033 
9034  // We deliberately don't check if we found a deleted special member. We're
9035  // not supposed to!
9036  if (Selected)
9037  *Selected = SMOR.getMethod();
9038 
9039  if (TAH == Sema::TAH_ConsiderTrivialABI &&
9041  return SMOR.getMethod()->isTrivialForCall();
9042  return SMOR.getMethod()->isTrivial();
9043  }
9044 
9045  llvm_unreachable("unknown special method kind");
9046 }
9047 
9049  for (auto *CI : RD->ctors())
9050  if (!CI->isImplicit())
9051  return CI;
9052 
9053  // Look for constructor templates.
9054  typedef CXXRecordDecl::specific_decl_iterator<FunctionTemplateDecl> tmpl_iter;
9055  for (tmpl_iter TI(RD->decls_begin()), TE(RD->decls_end()); TI != TE; ++TI) {
9056  if (CXXConstructorDecl *CD =
9057  dyn_cast<CXXConstructorDecl>(TI->getTemplatedDecl()))
9058  return CD;
9059  }
9060 
9061  return nullptr;
9062 }
9063 
9064 /// The kind of subobject we are checking for triviality. The values of this
9065 /// enumeration are used in diagnostics.
9067  /// The subobject is a base class.
9069  /// The subobject is a non-static data member.
9071  /// The object is actually the complete object.
9073 };
9074 
9075 /// Check whether the special member selected for a given type would be trivial.
9077  QualType SubType, bool ConstRHS,
9079  TrivialSubobjectKind Kind,
9080  Sema::TrivialABIHandling TAH, bool Diagnose) {
9081  CXXRecordDecl *SubRD = SubType->getAsCXXRecordDecl();
9082  if (!SubRD)
9083  return true;
9084 
9085  CXXMethodDecl *Selected;
9086  if (findTrivialSpecialMember(S, SubRD, CSM, SubType.getCVRQualifiers(),
9087  ConstRHS, TAH, Diagnose ? &Selected : nullptr))
9088  return true;
9089 
9090  if (Diagnose) {
9091  if (ConstRHS)
9092  SubType.addConst();
9093 
9094  if (!Selected && CSM == Sema::CXXDefaultConstructor) {
9095  S.Diag(SubobjLoc, diag::note_nontrivial_no_def_ctor)
9096  << Kind << SubType.getUnqualifiedType();
9097  if (CXXConstructorDecl *CD = findUserDeclaredCtor(SubRD))
9098  S.Diag(CD->getLocation(), diag::note_user_declared_ctor);
9099  } else if (!Selected)
9100  S.Diag(SubobjLoc, diag::note_nontrivial_no_copy)
9101  << Kind << SubType.getUnqualifiedType() << CSM << SubType;
9102  else if (Selected->isUserProvided()) {
9103  if (Kind == TSK_CompleteObject)
9104  S.Diag(Selected->getLocation(), diag::note_nontrivial_user_provided)
9105  << Kind << SubType.getUnqualifiedType() << CSM;
9106  else {
9107  S.Diag(SubobjLoc, diag::note_nontrivial_user_provided)
9108  << Kind << SubType.getUnqualifiedType() << CSM;
9109  S.Diag(Selected->getLocation(), diag::note_declared_at);
9110  }
9111  } else {
9112  if (Kind != TSK_CompleteObject)
9113  S.Diag(SubobjLoc, diag::note_nontrivial_subobject)
9114  << Kind << SubType.getUnqualifiedType() << CSM;
9115 
9116  // Explain why the defaulted or deleted special member isn't trivial.
9118  Diagnose);
9119  }
9120  }
9121 
9122  return false;
9123 }
9124 
9125 /// Check whether the members of a class type allow a special member to be
9126 /// trivial.
9129  bool ConstArg,
9131  bool Diagnose) {
9132  for (const auto *FI : RD->fields()) {
9133  if (FI->isInvalidDecl() || FI->isUnnamedBitfield())
9134  continue;
9135 
9136  QualType FieldType = S.Context.getBaseElementType(FI->getType());
9137 
9138  // Pretend anonymous struct or union members are members of this class.
9139  if (FI->isAnonymousStructOrUnion()) {
9140  if (!checkTrivialClassMembers(S, FieldType->getAsCXXRecordDecl(),
9141  CSM, ConstArg, TAH, Diagnose))
9142  return false;
9143  continue;
9144  }
9145 
9146  // C++11 [class.ctor]p5:
9147  // A default constructor is trivial if [...]
9148  // -- no non-static data member of its class has a
9149  // brace-or-equal-initializer
9150  if (CSM == Sema::CXXDefaultConstructor && FI->hasInClassInitializer()) {
9151  if (Diagnose)
9152  S.Diag(FI->getLocation(), diag::note_nontrivial_in_class_init) << FI;
9153  return false;
9154  }
9155 
9156  // Objective C ARC 4.3.5:
9157  // [...] nontrivally ownership-qualified types are [...] not trivially
9158  // default constructible, copy constructible, move constructible, copy
9159  // assignable, move assignable, or destructible [...]
9160  if (FieldType.hasNonTrivialObjCLifetime()) {
9161  if (Diagnose)
9162  S.Diag(FI->getLocation(), diag::note_nontrivial_objc_ownership)
9163  << RD << FieldType.getObjCLifetime();
9164  return false;
9165  }
9166 
9167  bool ConstRHS = ConstArg && !FI->isMutable();
9168  if (!checkTrivialSubobjectCall(S, FI->getLocation(), FieldType, ConstRHS,
9169  CSM, TSK_Field, TAH, Diagnose))
9170  return false;
9171  }
9172 
9173  return true;
9174 }
9175 
9176 /// Diagnose why the specified class does not have a trivial special member of
9177 /// the given kind.
9179  QualType Ty = Context.getRecordType(RD);
9180 
9181  bool ConstArg = (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment);
9182  checkTrivialSubobjectCall(*this, RD->getLocation(), Ty, ConstArg, CSM,
9183  TSK_CompleteObject, TAH_IgnoreTrivialABI,
9184  /*Diagnose*/true);
9185 }
9186 
9187 /// Determine whether a defaulted or deleted special member function is trivial,
9188 /// as specified in C++11 [class.ctor]p5, C++11 [class.copy]p12,
9189 /// C++11 [class.copy]p25, and C++11 [class.dtor]p5.
9191  TrivialABIHandling TAH, bool Diagnose) {
9192  assert(!MD->isUserProvided() && CSM != CXXInvalid && "not special enough");
9193 
9194  CXXRecordDecl *RD = MD->getParent();
9195 
9196  bool ConstArg = false;
9197 
9198  // C++11 [class.copy]p12, p25: [DR1593]
9199  // A [special member] is trivial if [...] its parameter-type-list is
9200  // equivalent to the parameter-type-list of an implicit declaration [...]
9201  switch (CSM) {
9202  case CXXDefaultConstructor:
9203  case CXXDestructor:
9204  // Trivial default constructors and destructors cannot have parameters.
9205  break;
9206 
9207  case CXXCopyConstructor:
9208  case CXXCopyAssignment: {
9209  // Trivial copy operations always have const, non-volatile parameter types.
9210  ConstArg = true;
9211  const ParmVarDecl *Param0 = MD->getParamDecl(0);
9212  const ReferenceType *RT = Param0->getType()->getAs<ReferenceType>();
9213  if (!RT || RT->getPointeeType().getCVRQualifiers() != Qualifiers::Const) {
9214  if (Diagnose)
9215  Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
9216  << Param0->getSourceRange() << Param0->getType()
9217  << Context.getLValueReferenceType(
9218  Context.getRecordType(RD).withConst());
9219  return false;
9220  }
9221  break;
9222  }
9223 
9224  case CXXMoveConstructor:
9225  case CXXMoveAssignment: {
9226  // Trivial move operations always have non-cv-qualified parameters.
9227  const ParmVarDecl *Param0 = MD->getParamDecl(0);
9228  const RValueReferenceType *RT =
9229  Param0->getType()->getAs<RValueReferenceType>();
9230  if (!RT || RT->getPointeeType().getCVRQualifiers()) {
9231  if (Diagnose)
9232  Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
9233  << Param0->getSourceRange() << Param0->getType()
9234  << Context.getRValueReferenceType(Context.getRecordType(RD));
9235  return false;
9236  }
9237  break;
9238  }
9239 
9240  case CXXInvalid:
9241  llvm_unreachable("not a special member");
9242  }
9243 
9244  if (MD->getMinRequiredArguments() < MD->getNumParams()) {
9245  if (Diagnose)
9246  Diag(MD->getParamDecl(MD->getMinRequiredArguments())->getLocation(),
9247  diag::note_nontrivial_default_arg)
9249  return false;
9250  }
9251  if (MD->isVariadic()) {
9252  if (Diagnose)
9253  Diag(MD->getLocation(), diag::note_nontrivial_variadic);
9254  return false;
9255  }
9256 
9257  // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
9258  // A copy/move [constructor or assignment operator] is trivial if
9259  // -- the [member] selected to copy/move each direct base class subobject
9260  // is trivial
9261  //
9262  // C++11 [class.copy]p12, C++11 [class.copy]p25:
9263  // A [default constructor or destructor] is trivial if
9264  // -- all the direct base classes have trivial [default constructors or
9265  // destructors]
9266  for (const auto &BI : RD->bases())
9267  if (!checkTrivialSubobjectCall(*this, BI.getBeginLoc(), BI.getType(),
9268  ConstArg, CSM, TSK_BaseClass, TAH, Diagnose))
9269  return false;
9270 
9271  // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
9272  // A copy/move [constructor or assignment operator] for a class X is
9273  // trivial if
9274  // -- for each non-static data member of X that is of class type (or array
9275  // thereof), the constructor selected to copy/move that member is
9276  // trivial
9277  //
9278  // C++11 [class.copy]p12, C++11 [class.copy]p25:
9279  // A [default constructor or destructor] is trivial if
9280  // -- for all of the non-static data members of its class that are of class
9281  // type (or array thereof), each such class has a trivial [default
9282  // constructor or destructor]
9283  if (!checkTrivialClassMembers(*this, RD, CSM, ConstArg, TAH, Diagnose))
9284  return false;
9285 
9286  // C++11 [class.dtor]p5:
9287  // A destructor is trivial if [...]
9288  // -- the destructor is not virtual
9289  if (CSM == CXXDestructor && MD->isVirtual()) {
9290  if (Diagnose)
9291  Diag(MD->getLocation(), diag::note_nontrivial_virtual_dtor) << RD;
9292  return false;
9293  }
9294 
9295  // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
9296  // A [special member] for class X is trivial if [...]
9297  // -- class X has no virtual functions and no virtual base classes
9298  if (CSM != CXXDestructor && MD->getParent()->isDynamicClass()) {
9299  if (!Diagnose)
9300  return false;
9301 
9302  if (RD->getNumVBases()) {
9303  // Check for virtual bases. We already know that the corresponding
9304  // member in all bases is trivial, so vbases must all be direct.
9305  CXXBaseSpecifier &BS = *RD->vbases_begin();
9306  assert(BS.isVirtual());
9307  Diag(BS.getBeginLoc(), diag::note_nontrivial_has_virtual) << RD << 1;
9308  return false;
9309  }
9310 
9311  // Must have a virtual method.
9312  for (const auto *MI : RD->methods()) {
9313  if (MI->isVirtual()) {
9314  SourceLocation MLoc = MI->getBeginLoc();
9315  Diag(MLoc, diag::note_nontrivial_has_virtual) << RD << 0;
9316  return false;
9317  }
9318  }
9319 
9320  llvm_unreachable("dynamic class with no vbases and no virtual functions");
9321  }
9322 
9323  // Looks like it's trivial!
9324  return true;
9325 }
9326 
9327 namespace {
9328 struct FindHiddenVirtualMethod {
9329  Sema *S;
9330  CXXMethodDecl *Method;
9331  llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
9332  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
9333 
9334 private:
9335  /// Check whether any most overridden method from MD in Methods
9336  static bool CheckMostOverridenMethods(
9337  const CXXMethodDecl *MD,
9338  const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
9339  if (MD->size_overridden_methods() == 0)
9340  return Methods.count(MD->getCanonicalDecl());
9341  for (const CXXMethodDecl *O : MD->overridden_methods())
9342  if (CheckMostOverridenMethods(O, Methods))
9343  return true;
9344  return false;
9345  }
9346 
9347 public:
9348  /// Member lookup function that determines whether a given C++
9349  /// method overloads virtual methods in a base class without overriding any,
9350  /// to be used with CXXRecordDecl::lookupInBases().
9351  bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
9352  RecordDecl *BaseRecord =
9353  Specifier->getType()->castAs<RecordType>()->getDecl();
9354 
9355  DeclarationName Name = Method->getDeclName();
9356  assert(Name.getNameKind() == DeclarationName::Identifier);
9357 
9358  bool foundSameNameMethod = false;
9359  SmallVector<CXXMethodDecl *, 8> overloadedMethods;
9360  for (Path.Decls = BaseRecord->lookup(Name); !Path.Decls.empty();
9361  Path.Decls = Path.Decls.slice(1)) {
9362  NamedDecl *D = Path.Decls.front();
9363  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
9364  MD = MD->getCanonicalDecl();
9365  foundSameNameMethod = true;
9366  // Interested only in hidden virtual methods.
9367  if (!MD->isVirtual())
9368  continue;
9369  // If the method we are checking overrides a method from its base
9370  // don't warn about the other overloaded methods. Clang deviates from
9371  // GCC by only diagnosing overloads of inherited virtual functions that
9372  // do not override any other virtual functions in the base. GCC's
9373  // -Woverloaded-virtual diagnoses any derived function hiding a virtual
9374  // function from a base class. These cases may be better served by a
9375  // warning (not specific to virtual functions) on call sites when the
9376  // call would select a different function from the base class, were it
9377  // visible.
9378  // See FIXME in test/SemaCXX/warn-overload-virtual.cpp for an example.
9379  if (!S->IsOverload(Method, MD, false))
9380  return true;
9381  // Collect the overload only if its hidden.
9382  if (!CheckMostOverridenMethods(MD, OverridenAndUsingBaseMethods))
9383  overloadedMethods.push_back(MD);
9384  }
9385  }
9386 
9387  if (foundSameNameMethod)
9388  OverloadedMethods.append(overloadedMethods.begin(),
9389  overloadedMethods.end());
9390  return foundSameNameMethod;
9391  }
9392 };
9393 } // end anonymous namespace
9394 
9395 /// Add the most overriden methods from MD to Methods
9397  llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
9398  if (MD->size_overridden_methods() == 0)
9399  Methods.insert(MD->getCanonicalDecl());
9400  else
9401  for (const CXXMethodDecl *O : MD->overridden_methods())
9402  AddMostOverridenMethods(O, Methods);
9403 }
9404 
9405 /// Check if a method overloads virtual methods in a base class without
9406 /// overriding any.
9408  SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
9409  if (!MD->getDeclName().isIdentifier())
9410  return;
9411 
9412  CXXBasePaths Paths(/*FindAmbiguities=*/true, // true to look in all bases.
9413  /*bool RecordPaths=*/false,
9414  /*bool DetectVirtual=*/false);
9415  FindHiddenVirtualMethod FHVM;
9416  FHVM.Method = MD;
9417  FHVM.S = this;
9418 
9419  // Keep the base methods that were overridden or introduced in the subclass
9420  // by 'using' in a set. A base method not in this set is hidden.
9421  CXXRecordDecl *DC = MD->getParent();
9423  for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
9424  NamedDecl *ND = *I;
9425  if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*I))
9426  ND = shad->getTargetDecl();
9427  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND))
9428  AddMostOverridenMethods(MD, FHVM.OverridenAndUsingBaseMethods);
9429  }
9430 
9431  if (DC->lookupInBases(FHVM, Paths))
9432  OverloadedMethods = FHVM.OverloadedMethods;
9433 }
9434 
9436  SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
9437  for (unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) {
9438  CXXMethodDecl *overloadedMD = OverloadedMethods[i];
9439  PartialDiagnostic PD = PDiag(
9440  diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
9441  HandleFunctionTypeMismatch(PD, MD->getType(), overloadedMD->getType());
9442  Diag(overloadedMD->getLocation(), PD);
9443  }
9444 }
9445 
9446 /// Diagnose methods which overload virtual methods in a base class
9447 /// without overriding any.
9449  if (MD->isInvalidDecl())
9450  return;
9451 
9452  if (Diags.isIgnored(diag::warn_overloaded_virtual, MD->getLocation()))
9453  return;
9454 
9455  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
9456  FindHiddenVirtualMethods(MD, OverloadedMethods);
9457  if (!OverloadedMethods.empty()) {
9458  Diag(MD->getLocation(), diag::warn_overloaded_virtual)
9459  << MD << (OverloadedMethods.size() > 1);
9460 
9461  NoteHiddenVirtualMethods(MD, OverloadedMethods);
9462  }
9463 }
9464 
9466  auto PrintDiagAndRemoveAttr = [&]() {
9467  // No diagnostics if this is a template instantiation.
9469  Diag(RD.getAttr<TrivialABIAttr>()->getLocation(),
9470  diag::ext_cannot_use_trivial_abi) << &RD;
9471  RD.dropAttr<TrivialABIAttr>();
9472  };
9473 
9474  // Ill-formed if the struct has virtual functions.
9475  if (RD.isPolymorphic()) {
9476  PrintDiagAndRemoveAttr();
9477  return;
9478  }
9479 
9480  for (const auto &B : RD.bases()) {
9481  // Ill-formed if the base class is non-trivial for the purpose of calls or a
9482  // virtual base.
9483  if ((!B.getType()->isDependentType() &&
9484  !B.getType()->getAsCXXRecordDecl()->canPassInRegisters()) ||
9485  B.isVirtual()) {
9486  PrintDiagAndRemoveAttr();
9487  return;
9488  }
9489  }
9490 
9491  for (const auto *FD : RD.fields()) {
9492  // Ill-formed if the field is an ObjectiveC pointer or of a type that is
9493  // non-trivial for the purpose of calls.
9494  QualType FT = FD->getType();
9495  if (FT.getObjCLifetime() == Qualifiers::OCL_Weak) {
9496  PrintDiagAndRemoveAttr();
9497  return;
9498  }
9499 
9500  if (const auto *RT = FT->getBaseElementTypeUnsafe()->getAs<RecordType>())
9501  if (!RT->isDependentType() &&
9502  !cast<CXXRecordDecl>(RT->getDecl())->canPassInRegisters()) {
9503  PrintDiagAndRemoveAttr();
9504  return;
9505  }
9506  }
9507 }
9508 
9510  Scope *S, SourceLocation RLoc, Decl *TagDecl, SourceLocation LBrac,
9511  SourceLocation RBrac, const ParsedAttributesView &AttrList) {
9512  if (!TagDecl)
9513  return;
9514 
9515  AdjustDeclIfTemplate(TagDecl);
9516 
9517  for (const ParsedAttr &AL : AttrList) {
9518  if (AL.getKind() != ParsedAttr::AT_Visibility)
9519  continue;
9520  AL.setInvalid();
9521  Diag(AL.getLoc(), diag::warn_attribute_after_definition_ignored) << AL;
9522  }
9523 
9524  ActOnFields(S, RLoc, TagDecl, llvm::makeArrayRef(
9525  // strict aliasing violation!
9526  reinterpret_cast<Decl**>(FieldCollector->getCurFields()),
9527  FieldCollector->getCurNumFields()), LBrac, RBrac, AttrList);
9528 
9529  CheckCompletedCXXClass(S, cast<CXXRecordDecl>(TagDecl));
9530 }
9531 
9532 /// Find the equality comparison functions that should be implicitly declared
9533 /// in a given class definition, per C++2a [class.compare.default]p3.
9535  ASTContext &Ctx, CXXRecordDecl *RD,
9537  DeclarationName EqEq = Ctx.DeclarationNames.getCXXOperatorName(OO_EqualEqual);
9538  if (!RD->lookup(EqEq).empty())
9539  // Member operator== explicitly declared: no implicit operator==s.
9540  return;
9541 
9542  // Traverse friends looking for an '==' or a '<=>'.
9543  for (FriendDecl *Friend : RD->friends()) {
9544  FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Friend->getFriendDecl());
9545  if (!FD) continue;
9546 
9547  if (FD->getOverloadedOperator() == OO_EqualEqual) {
9548  // Friend operator== explicitly declared: no implicit operator==s.
9549  Spaceships.clear();
9550  return;
9551  }
9552 
9553  if (FD->getOverloadedOperator() == OO_Spaceship &&
9554  FD->isExplicitlyDefaulted())
9555  Spaceships.push_back(FD);
9556  }
9557 
9558  // Look for members named 'operator<=>'.
9559  DeclarationName Cmp = Ctx.DeclarationNames.getCXXOperatorName(OO_Spaceship);
9560  for (NamedDecl *ND : RD->lookup(Cmp)) {
9561  // Note that we could find a non-function here (either a function template
9562  // or a using-declaration). Neither case results in an implicit
9563  // 'operator=='.
9564  if (auto *FD = dyn_cast<FunctionDecl>(ND))
9565  if (FD->isExplicitlyDefaulted())
9566  Spaceships.push_back(FD);
9567  }
9568 }
9569 
9570 /// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
9571 /// special functions, such as the default constructor, copy
9572 /// constructor, or destructor, to the given C++ class (C++
9573 /// [special]p1). This routine can only be executed just before the
9574 /// definition of the class is complete.
9576  if (ClassDecl->needsImplicitDefaultConstructor()) {
9577  ++getASTContext().NumImplicitDefaultConstructors;
9578 
9579  if (ClassDecl->hasInheritedConstructor())
9580  DeclareImplicitDefaultConstructor(ClassDecl);
9581  }
9582 
9583  if (ClassDecl->needsImplicitCopyConstructor()) {
9584  ++getASTContext().NumImplicitCopyConstructors;
9585 
9586  // If the properties or semantics of the copy constructor couldn't be
9587  // determined while the class was being declared, force a declaration
9588  // of it now.
9589  if (ClassDecl->needsOverloadResolutionForCopyConstructor() ||
9590  ClassDecl->hasInheritedConstructor())
9591  DeclareImplicitCopyConstructor(ClassDecl);
9592  // For the MS ABI we need to know whether the copy ctor is deleted. A
9593  // prerequisite for deleting the implicit copy ctor is that the class has a
9594  // move ctor or move assignment that is either user-declared or whose
9595  // semantics are inherited from a subobject. FIXME: We should provide a more
9596  // direct way for CodeGen to ask whether the constructor was deleted.
9597  else if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
9598  (ClassDecl->hasUserDeclaredMoveConstructor() ||
9600  ClassDecl->hasUserDeclaredMoveAssignment() ||
9602  DeclareImplicitCopyConstructor(ClassDecl);
9603  }
9604 
9605  if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveConstructor()) {
9606  ++getASTContext().NumImplicitMoveConstructors;
9607 
9608  if (ClassDecl->needsOverloadResolutionForMoveConstructor() ||
9609  ClassDecl->hasInheritedConstructor())
9610  DeclareImplicitMoveConstructor(ClassDecl);
9611  }
9612 
9613  if (ClassDecl->needsImplicitCopyAssignment()) {
9614  ++getASTContext().NumImplicitCopyAssignmentOperators;
9615 
9616  // If we have a dynamic class, then the copy assignment operator may be
9617  // virtual, so we have to declare it immediately. This ensures that, e.g.,
9618  // it shows up in the right place in the vtable and that we diagnose
9619  // problems with the implicit exception specification.
9620  if (ClassDecl->isDynamicClass() ||
9622  ClassDecl->hasInheritedAssignment())
9623  DeclareImplicitCopyAssignment(ClassDecl);
9624  }
9625 
9626  if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveAssignment()) {
9627  ++getASTContext().NumImplicitMoveAssignmentOperators;
9628 
9629  // Likewise for the move assignment operator.
9630  if (ClassDecl->isDynamicClass() ||
9632  ClassDecl->hasInheritedAssignment())
9633  DeclareImplicitMoveAssignment(ClassDecl);
9634  }
9635 
9636  if (ClassDecl->needsImplicitDestructor()) {
9637  ++getASTContext().NumImplicitDestructors;
9638 
9639  // If we have a dynamic class, then the destructor may be virtual, so we
9640  // have to declare the destructor immediately. This ensures that, e.g., it
9641  // shows up in the right place in the vtable and that we diagnose problems
9642  // with the implicit exception specification.
9643  if (ClassDecl->isDynamicClass() ||
9645  DeclareImplicitDestructor(ClassDecl);
9646  }
9647 
9648  // C++2a [class.compare.default]p3:
9649  // If the member-specification does not explicitly declare any member or
9650  // friend named operator==, an == operator function is declared implicitly
9651  // for each defaulted three-way comparison operator function defined in the
9652  // member-specification
9653  // FIXME: Consider doing this lazily.
9654  if (getLangOpts().CPlusPlus2a) {
9655  llvm::SmallVector<FunctionDecl*, 4> DefaultedSpaceships;
9656  findImplicitlyDeclaredEqualityComparisons(Context, ClassDecl,
9657  DefaultedSpaceships);
9658  for (auto *FD : DefaultedSpaceships)
9659  DeclareImplicitEqualityComparison(ClassDecl, FD);
9660  }
9661 }
9662 
9664  if (!D)
9665  return 0;
9666 
9667  // The order of template parameters is not important here. All names
9668  // get added to the same scope.
9670 
9671  if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
9672  D = TD->getTemplatedDecl();
9673 
9674  if (auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
9675  ParameterLists.push_back(PSD->getTemplateParameters());
9676 
9677  if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
9678  for (unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
9679  ParameterLists.push_back(DD->getTemplateParameterList(i));
9680 
9681  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
9682  if (FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
9683  ParameterLists.push_back(FTD->getTemplateParameters());
9684  }
9685  }
9686 
9687  if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
9688  for (unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
9689  ParameterLists.push_back(TD->getTemplateParameterList(i));
9690 
9691  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD)) {
9693  ParameterLists.push_back(CTD->getTemplateParameters());
9694  }
9695  }
9696 
9697  unsigned Count = 0;
9698  for (TemplateParameterList *Params : ParameterLists) {
9699  if (Params->size() > 0)
9700  // Ignore explicit specializations; they don't contribute to the template
9701  // depth.
9702  ++Count;
9703  for (NamedDecl *Param : *Params) {
9704  if (Param->getDeclName()) {
9705  S->AddDecl(Param);
9706  IdResolver.AddDecl(Param);
9707  }
9708  }
9709  }
9710 
9711  return Count;
9712 }
9713 
9715  if (!RecordD) return;
9716  AdjustDeclIfTemplate(RecordD);
9717  CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD);
9718  PushDeclContext(S, Record);
9719 }
9720 
9722  if (!RecordD) return;
9723  PopDeclContext();
9724 }
9725 
9726 /// This is used to implement the constant expression evaluation part of the
9727 /// attribute enable_if extension. There is nothing in standard C++ which would
9728 /// require reentering parameters.
9730  if (!Param)
9731  return;
9732 
9733  S->AddDecl(Param);
9734  if (Param->getDeclName())
9735  IdResolver.AddDecl(Param);
9736 }
9737 
9738 /// ActOnStartDelayedCXXMethodDeclaration - We have completed
9739 /// parsing a top-level (non-nested) C++ class, and we are now
9740 /// parsing those parts of the given Method declaration that could
9741 /// not be parsed earlier (C++ [class.mem]p2), such as default
9742 /// arguments. This action should enter the scope of the given
9743 /// Method declaration as if we had just parsed the qualified method
9744 /// name. However, it should not bring the parameters into scope;
9745 /// that will be performed by ActOnDelayedCXXMethodParameter.
9747 }
9748 
9749 /// ActOnDelayedCXXMethodParameter - We've already started a delayed
9750 /// C++ method declaration. We're (re-)introducing the given
9751 /// function parameter into scope for use in parsing later parts of
9752 /// the method declaration. For example, we could see an
9753 /// ActOnParamDefaultArgument event for this parameter.
9755  if (!ParamD)
9756  return;
9757 
9758  ParmVarDecl *Param = cast<ParmVarDecl>(ParamD);
9759 
9760  // If this parameter has an unparsed default argument, clear it out
9761  // to make way for the parsed default argument.
9762  if (Param->hasUnparsedDefaultArg())
9763  Param->setDefaultArg(nullptr);
9764 
9765  S->AddDecl(Param);
9766  if (Param->getDeclName())
9767  IdResolver.AddDecl(Param);
9768 }
9769 
9770 /// ActOnFinishDelayedCXXMethodDeclaration - We have finished
9771 /// processing the delayed method declaration for Method. The method
9772 /// declaration is now considered finished. There may be a separate
9773 /// ActOnStartOfFunctionDef action later (not necessarily
9774 /// immediately!) for this method, if it was also defined inside the
9775 /// class body.
9777  if (!MethodD)
9778  return;
9779 
9780  AdjustDeclIfTemplate(MethodD);
9781 
9782  FunctionDecl *Method = cast<FunctionDecl>(MethodD);
9783 
9784  // Now that we have our default arguments, check the constructor
9785  // again. It could produce additional diagnostics or affect whether
9786  // the class has implicitly-declared destructors, among other
9787  // things.
9788  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
9789  CheckConstructor(Constructor);
9790 
9791  // Check the default arguments, which we may have added.
9792  if (!Method->isInvalidDecl())
9793  CheckCXXDefaultArguments(Method);
9794 }
9795 
9796 // Emit the given diagnostic for each non-address-space qualifier.
9797 // Common part of CheckConstructorDeclarator and CheckDestructorDeclarator.
9798 static void checkMethodTypeQualifiers(Sema &S, Declarator &D, unsigned DiagID) {
9800  if (FTI.hasMethodTypeQualifiers() && !D.isInvalidType()) {
9801  bool DiagOccured = false;
9803  [DiagID, &S, &DiagOccured](DeclSpec::TQ, StringRef QualName,
9804  SourceLocation SL) {
9805  // This diagnostic should be emitted on any qualifier except an addr
9806  // space qualifier. However, forEachQualifier currently doesn't visit
9807  // addr space qualifiers, so there's no way to write this condition
9808  // right now; we just diagnose on everything.
9809  S.Diag(SL, DiagID) << QualName << SourceRange(SL);
9810  DiagOccured = true;
9811  });
9812  if (DiagOccured)
9813  D.setInvalidType();
9814  }
9815 }
9816 
9817 /// CheckConstructorDeclarator - Called by ActOnDeclarator to check
9818 /// the well-formedness of the constructor declarator @p D with type @p
9819 /// R. If there are any errors in the declarator, this routine will
9820 /// emit diagnostics and set the invalid bit to true. In any case, the type
9821 /// will be updated to reflect a well-formed type for the constructor and
9822 /// returned.
9824  StorageClass &SC) {
9825  bool isVirtual = D.getDeclSpec().isVirtualSpecified();
9826 
9827  // C++ [class.ctor]p3:
9828  // A constructor shall not be virtual (10.3) or static (9.4). A
9829  // constructor can be invoked for a const, volatile or const
9830  // volatile object. A constructor shall not be declared const,
9831  // volatile, or const volatile (9.3.2).
9832  if (isVirtual) {
9833  if (!D.isInvalidType())
9834  Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
9835  << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
9836  << SourceRange(D.getIdentifierLoc());
9837  D.setInvalidType();
9838  }
9839  if (SC == SC_Static) {
9840  if (!D.isInvalidType())
9841  Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
9842  << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
9843  << SourceRange(D.getIdentifierLoc());
9844  D.setInvalidType();
9845  SC = SC_None;
9846  }
9847 
9848  if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
9849  diagnoseIgnoredQualifiers(
9850  diag::err_constructor_return_type, TypeQuals, SourceLocation(),
9854  D.setInvalidType();
9855  }
9856 
9857  checkMethodTypeQualifiers(*this, D, diag::err_invalid_qualified_constructor);
9858 
9859  // C++0x [class.ctor]p4:
9860  // A constructor shall not be declared with a ref-qualifier.
9862  if (FTI.hasRefQualifier()) {
9863  Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_constructor)
9866  D.setInvalidType();
9867  }
9868 
9869  // Rebuild the function type "R" without any type qualifiers (in
9870  // case any of the errors above fired) and with "void" as the
9871  // return type, since constructors don't have return types.
9872  const FunctionProtoType *Proto = R->castAs<FunctionProtoType>();
9873  if (Proto->getReturnType() == Context.VoidTy && !D.isInvalidType())
9874  return R;
9875 
9877  EPI.TypeQuals = Qualifiers();
9878  EPI.RefQualifier = RQ_None;
9879 
9880  return Context.getFunctionType(Context.VoidTy, Proto->getParamTypes(), EPI);
9881 }
9882 
9883 /// CheckConstructor - Checks a fully-formed constructor for
9884 /// well-formedness, issuing any diagnostics required. Returns true if
9885 /// the constructor declarator is invalid.
9887  CXXRecordDecl *ClassDecl
9888  = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
9889  if (!ClassDecl)
9890  return Constructor->setInvalidDecl();
9891 
9892  // C++ [class.copy]p3:
9893  // A declaration of a constructor for a class X is ill-formed if
9894  // its first parameter is of type (optionally cv-qualified) X and
9895  // either there are no other parameters or else all other
9896  // parameters have default arguments.
9897  if (!Constructor->isInvalidDecl() &&
9898  ((Constructor->getNumParams() == 1) ||
9899  (Constructor->getNumParams() > 1 &&
9900  Constructor->getParamDecl(1)->hasDefaultArg())) &&
9901  Constructor->getTemplateSpecializationKind()
9903  QualType ParamType = Constructor->getParamDecl(0)->getType();
9904  QualType ClassTy = Context.getTagDeclType(ClassDecl);
9905  if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
9906  SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
9907  const char *ConstRef
9908  = Constructor->getParamDecl(0)->getIdentifier() ? "const &"
9909  : " const &";
9910  Diag(ParamLoc, diag::err_constructor_byvalue_arg)
9911  << FixItHint::CreateInsertion(ParamLoc, ConstRef);
9912 
9913  // FIXME: Rather that making the constructor invalid, we should endeavor
9914  // to fix the type.
9915  Constructor->setInvalidDecl();
9916  }
9917  }
9918 }
9919 
9920 /// CheckDestructor - Checks a fully-formed destructor definition for
9921 /// well-formedness, issuing any diagnostics required. Returns true
9922 /// on error.
9924  CXXRecordDecl *RD = Destructor->getParent();
9925 
9926  if (!Destructor->getOperatorDelete() && Destructor->isVirtual()) {
9927  SourceLocation Loc;
9928 
9929  if (!Destructor->isImplicit())
9930  Loc = Destructor->getLocation();
9931  else
9932  Loc = RD->getLocation();
9933 
9934  // If we have a virtual destructor, look up the deallocation function
9935  if (FunctionDecl *OperatorDelete =
9936  FindDeallocationFunctionForDestructor(Loc, RD)) {
9937  Expr *ThisArg = nullptr;
9938 
9939  // If the notional 'delete this' expression requires a non-trivial
9940  // conversion from 'this' to the type of a destroying operator delete's
9941  // first parameter, perform that conversion now.
9942  if (OperatorDelete->isDestroyingOperatorDelete()) {
9943  QualType ParamType = OperatorDelete->getParamDecl(0)->getType();
9944  if (!declaresSameEntity(ParamType->getAsCXXRecordDecl(), RD)) {
9945  // C++ [class.dtor]p13:
9946  // ... as if for the expression 'delete this' appearing in a
9947  // non-virtual destructor of the destructor's class.
9948  ContextRAII SwitchContext(*this, Destructor);
9949  ExprResult This =
9950  ActOnCXXThis(OperatorDelete->getParamDecl(0)->getLocation());
9951  assert(!This.isInvalid() && "couldn't form 'this' expr in dtor?");
9952  This = PerformImplicitConversion(This.get(), ParamType, AA_Passing);
9953  if (This.isInvalid()) {
9954  // FIXME: Register this as a context note so that it comes out
9955  // in the right order.
9956  Diag(Loc, diag::note_implicit_delete_this_in_destructor_here);
9957  return true;
9958  }
9959  ThisArg = This.get();
9960  }
9961  }
9962 
9963  DiagnoseUseOfDecl(OperatorDelete, Loc);
9964  MarkFunctionReferenced(Loc, OperatorDelete);
9965  Destructor->setOperatorDelete(OperatorDelete, ThisArg);
9966  }
9967  }
9968 
9969  return false;
9970 }
9971 
9972 /// CheckDestructorDeclarator - Called by ActOnDeclarator to check
9973 /// the well-formednes of the destructor declarator @p D with type @p
9974 /// R. If there are any errors in the declarator, this routine will
9975 /// emit diagnostics and set the declarator to invalid. Even if this happens,
9976 /// will be updated to reflect a well-formed type for the destructor and
9977 /// returned.
9979  StorageClass& SC) {
9980  // C++ [class.dtor]p1:
9981  // [...] A typedef-name that names a class is a class-name
9982  // (7.1.3); however, a typedef-name that names a class shall not
9983  // be used as the identifier in the declarator for a destructor
9984  // declaration.
9985  QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
9986  if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
9987  Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
9988  << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
9989  else if (const TemplateSpecializationType *TST =
9990  DeclaratorType->getAs<TemplateSpecializationType>())
9991  if (TST->isTypeAlias())
9992  Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
9993  << DeclaratorType << 1;
9994 
9995  // C++ [class.dtor]p2:
9996  // A destructor is used to destroy objects of its class type. A
9997  // destructor takes no parameters, and no return type can be
9998  // specified for it (not even void). The address of a destructor
9999  // shall not be taken. A destructor shall not be static. A
10000  // destructor can be invoked for a const, volatile or const
10001  // volatile object. A destructor shall not be declared const,
10002  // volatile or const volatile (9.3.2).
10003  if (SC == SC_Static) {
10004  if (!D.isInvalidType())
10005  Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
10006  << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
10009 
10010  SC = SC_None;
10011  }
10012  if (!D.isInvalidType()) {
10013  // Destructors don't have return types, but the parser will
10014  // happily parse something like:
10015  //
10016  // class X {
10017  // float ~X();
10018  // };
10019  //
10020  // The return type will be eliminated later.
10021  if (D.getDeclSpec().hasTypeSpecifier())
10022  Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
10024  << SourceRange(D.getIdentifierLoc());
10025  else if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
10026  diagnoseIgnoredQualifiers(diag::err_destructor_return_type, TypeQuals,
10027  SourceLocation(),
10032  D.setInvalidType();
10033  }
10034  }
10035 
10036  checkMethodTypeQualifiers(*this, D, diag::err_invalid_qualified_destructor);
10037 
10038  // C++0x [class.dtor]p2:
10039  // A destructor shall not be declared with a ref-qualifier.
10041  if (FTI.hasRefQualifier()) {
10042  Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_destructor)
10045  D.setInvalidType();
10046  }
10047 
10048  // Make sure we don't have any parameters.
10049  if (FTIHasNonVoidParameters(FTI)) {
10050  Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
10051 
10052  // Delete the parameters.
10053  FTI.freeParams();
10054  D.setInvalidType();
10055  }
10056 
10057  // Make sure the destructor isn't variadic.
10058  if (FTI.isVariadic) {
10059  Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
10060  D.setInvalidType();
10061  }
10062 
10063  // Rebuild the function type "R" without any type qualifiers or
10064  // parameters (in case any of the errors above fired) and with
10065  // "void" as the return type, since destructors don't have return
10066  // types.
10067  if (!D.isInvalidType())
10068  return R;
10069 
10070  const FunctionProtoType *Proto = R->castAs<FunctionProtoType>();
10072  EPI.Variadic = false;
10073  EPI.TypeQuals = Qualifiers();
10074  EPI.RefQualifier = RQ_None;
10075  return Context.getFunctionType(Context.VoidTy, None, EPI);
10076 }
10077 
10078 static void extendLeft(SourceRange &R, SourceRange Before) {
10079  if (Before.isInvalid())
10080  return;
10081  R.setBegin(Before.getBegin());
10082  if (R.getEnd().isInvalid())
10083  R.setEnd(Before.getEnd());
10084 }
10085 
10087  if (After.isInvalid())
10088  return;
10089  if (R.getBegin().isInvalid())
10090  R.setBegin(After.getBegin());
10091  R.setEnd(After.getEnd());
10092 }
10093 
10094 /// CheckConversionDeclarator - Called by ActOnDeclarator to check the
10095 /// well-formednes of the conversion function declarator @p D with
10096 /// type @p R. If there are any errors in the declarator, this routine
10097 /// will emit diagnostics and return true. Otherwise, it will return
10098 /// false. Either way, the type @p R will be updated to reflect a
10099 /// well-formed type for the conversion operator.
10101  StorageClass& SC) {
10102  // C++ [class.conv.fct]p1:
10103  // Neither parameter types nor return type can be specified. The
10104  // type of a conversion function (8.3.5) is "function taking no
10105  // parameter returning conversion-type-id."
10106  if (SC == SC_Static) {
10107  if (!D.isInvalidType())
10108  Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
10110  << D.getName().getSourceRange();
10111  D.setInvalidType();
10112  SC = SC_None;
10113  }
10114 
10115  TypeSourceInfo *ConvTSI = nullptr;
10116  QualType ConvType =
10117  GetTypeFromParser(D.getName().ConversionFunctionId, &ConvTSI);
10118 
10119  const DeclSpec &DS = D.getDeclSpec();
10120  if (DS.hasTypeSpecifier() && !D.isInvalidType()) {
10121  // Conversion functions don't have return types, but the parser will
10122  // happily parse something like:
10123  //
10124  // class X {
10125  // float operator bool();
10126  // };
10127  //
10128  // The return type will be changed later anyway.
10129  Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
10130  << SourceRange(DS.getTypeSpecTypeLoc())
10131  << SourceRange(D.getIdentifierLoc());
10132  D.setInvalidType();
10133  } else if (DS.getTypeQualifiers() && !D.isInvalidType()) {
10134  // It's also plausible that the user writes type qualifiers in the wrong
10135  // place, such as:
10136  // struct S { const operator int(); };
10137  // FIXME: we could provide a fixit to move the qualifiers onto the
10138  // conversion type.
10139  Diag(D.getIdentifierLoc(), diag::err_conv_function_with_complex_decl)
10140  << SourceRange(D.getIdentifierLoc()) << 0;
10141  D.setInvalidType();
10142  }
10143 
10144  const auto *Proto = R->castAs<FunctionProtoType>();
10145 
10146  // Make sure we don't have any parameters.
10147  if (Proto->getNumParams() > 0) {
10148  Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
10149 
10150  // Delete the parameters.
10152  D.setInvalidType();
10153  } else if (Proto->isVariadic()) {
10154  Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
10155  D.setInvalidType();
10156  }
10157 
10158  // Diagnose "&operator bool()" and other such nonsense. This
10159  // is actually a gcc extension which we don't support.
10160  if (Proto->getReturnType() != ConvType) {
10161  bool NeedsTypedef = false;
10162  SourceRange Before, After;
10163 
10164  // Walk the chunks and extract information on them for our diagnostic.
10165  bool PastFunctionChunk = false;
10166  for (auto &Chunk : D.type_objects()) {
10167  switch (Chunk.Kind) {
10169  if (!PastFunctionChunk) {
10170  if (Chunk.Fun.HasTrailingReturnType) {
10171  TypeSourceInfo *TRT = nullptr;
10172  GetTypeFromParser(Chunk.Fun.getTrailingReturnType(), &TRT);
10173  if (TRT) extendRight(After, TRT->getTypeLoc().getSourceRange());
10174  }
10175  PastFunctionChunk = true;
10176  break;
10177  }
10178  LLVM_FALLTHROUGH;
10180  NeedsTypedef = true;
10181  extendRight(After, Chunk.getSourceRange());
10182  break;
10183 
10188  case DeclaratorChunk::Pipe:
10189  extendLeft(Before, Chunk.getSourceRange());
10190  break;
10191 
10193  extendLeft(Before, Chunk.Loc);
10194  extendRight(After, Chunk.EndLoc);
10195  break;
10196  }
10197  }
10198 
10199  SourceLocation Loc = Before.isValid() ? Before.getBegin() :
10200  After.isValid() ? After.getBegin() :
10201  D.getIdentifierLoc();
10202  auto &&DB = Diag(Loc, diag::err_conv_function_with_complex_decl);
10203  DB << Before << After;
10204 
10205  if (!NeedsTypedef) {
10206  DB << /*don't need a typedef*/0;
10207 
10208  // If we can provide a correct fix-it hint, do so.
10209  if (After.isInvalid() && ConvTSI) {
10210  SourceLocation InsertLoc =
10211  getLocForEndOfToken(ConvTSI->getTypeLoc().getEndLoc());
10212  DB << FixItHint::CreateInsertion(InsertLoc, " ")
10214  InsertLoc, CharSourceRange::getTokenRange(Before))
10215  << FixItHint::CreateRemoval(Before);
10216  }
10217  } else if (!Proto->getReturnType()->isDependentType()) {
10218  DB << /*typedef*/1 << Proto->getReturnType();
10219  } else if (getLangOpts().CPlusPlus11) {
10220  DB << /*alias template*/2 << Proto->getReturnType();
10221  } else {
10222  DB << /*might not be fixable*/3;
10223  }
10224 
10225  // Recover by incorporating the other type chunks into the result type.
10226  // Note, this does *not* change the name of the function. This is compatible
10227  // with the GCC extension:
10228  // struct S { &operator int(); } s;
10229  // int &r = s.operator int(); // ok in GCC
10230  // S::operator int&() {} // error in GCC, function name is 'operator int'.
10231  ConvType = Proto->getReturnType();
10232  }
10233 
10234  // C++ [class.conv.fct]p4:
10235  // The conversion-type-id shall not represent a function type nor
10236  // an array type.
10237  if (ConvType->isArrayType()) {
10238  Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
10239  ConvType = Context.getPointerType(ConvType);
10240  D.setInvalidType();
10241  } else if (ConvType->isFunctionType()) {
10242  Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
10243  ConvType = Context.getPointerType(ConvType);
10244  D.setInvalidType();
10245  }
10246 
10247  // Rebuild the function type "R" without any parameters (in case any
10248  // of the errors above fired) and with the conversion type as the
10249  // return type.
10250  if (D.isInvalidType())
10251  R = Context.getFunctionType(ConvType, None, Proto->getExtProtoInfo());
10252 
10253  // C++0x explicit conversion operators.
10254  if (DS.hasExplicitSpecifier() && !getLangOpts().CPlusPlus2a)
10255  Diag(DS.getExplicitSpecLoc(),
10256  getLangOpts().CPlusPlus11
10257  ? diag::warn_cxx98_compat_explicit_conversion_functions
10258  : diag::ext_explicit_conversion_functions)
10259  << SourceRange(DS.getExplicitSpecRange());
10260 }
10261 
10262 /// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
10263 /// the declaration of the given C++ conversion function. This routine
10264 /// is responsible for recording the conversion function in the C++
10265 /// class, if possible.
10267  assert(Conversion && "Expected to receive a conversion function declaration");
10268 
10269  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
10270 
10271  // Make sure we aren't redeclaring the conversion function.
10272  QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
10273 
10274  // C++ [class.conv.fct]p1:
10275  // [...] A conversion function is never used to convert a
10276  // (possibly cv-qualified) object to the (possibly cv-qualified)
10277  // same object type (or a reference to it), to a (possibly
10278  // cv-qualified) base class of that type (or a reference to it),
10279  // or to (possibly cv-qualified) void.
10280  // FIXME: Suppress this warning if the conversion function ends up being a
10281  // virtual function that overrides a virtual function in a base class.
10282  QualType ClassType
10283  = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
10284  if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
10285  ConvType = ConvTypeRef->getPointeeType();
10286  if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared &&
10288  /* Suppress diagnostics for instantiations. */;
10289  else if (ConvType->isRecordType()) {
10290  ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
10291  if (ConvType == ClassType)
10292  Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
10293  << ClassType;
10294  else if (IsDerivedFrom(Conversion->getLocation(), ClassType, ConvType))
10295  Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
10296  << ClassType << ConvType;
10297  } else if (ConvType->isVoidType()) {
10298  Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
10299  << ClassType << ConvType;
10300  }
10301 
10302  if (FunctionTemplateDecl *ConversionTemplate
10303  = Conversion->getDescribedFunctionTemplate())
10304  return ConversionTemplate;
10305 
10306  return Conversion;
10307 }
10308 
10309 namespace {
10310 /// Utility class to accumulate and print a diagnostic listing the invalid
10311 /// specifier(s) on a declaration.
10312 struct BadSpecifierDiagnoser {
10313  BadSpecifierDiagnoser(Sema &S, SourceLocation Loc, unsigned DiagID)
10314  : S(S), Diagnostic(S.Diag(Loc, DiagID)) {}
10315  ~BadSpecifierDiagnoser() {
10316  Diagnostic << Specifiers;
10317  }
10318 
10319  template<typename T> void check(SourceLocation SpecLoc, T Spec) {
10320  return check(SpecLoc, DeclSpec::getSpecifierName(Spec));
10321  }
10322  void check(SourceLocation SpecLoc, DeclSpec::TST Spec) {
10323  return check(SpecLoc,
10325  }
10326  void check(SourceLocation SpecLoc, const char *Spec) {
10327  if (SpecLoc.isInvalid()) return;
10328  Diagnostic << SourceRange(SpecLoc, SpecLoc);
10329  if (!Specifiers.empty()) Specifiers += " ";
10330  Specifiers += Spec;
10331  }
10332 
10333  Sema &S;
10335  std::string Specifiers;
10336 };
10337 }
10338 
10339 /// Check the validity of a declarator that we parsed for a deduction-guide.
10340 /// These aren't actually declarators in the grammar, so we need to check that
10341 /// the user didn't specify any pieces that are not part of the deduction-guide
10342 /// grammar.
10344  StorageClass &SC) {
10345  TemplateName GuidedTemplate = D.getName().TemplateName.get().get();
10346  TemplateDecl *GuidedTemplateDecl = GuidedTemplate.getAsTemplateDecl();
10347  assert(GuidedTemplateDecl && "missing template decl for deduction guide");
10348 
10349  // C++ [temp.deduct.guide]p3:
10350  // A deduction-gide shall be declared in the same scope as the
10351  // corresponding class template.
10352  if (!CurContext->getRedeclContext()->Equals(
10353  GuidedTemplateDecl->getDeclContext()->getRedeclContext())) {
10354  Diag(D.getIdentifierLoc(), diag::err_deduction_guide_wrong_scope)
10355  << GuidedTemplateDecl;
10356  Diag(GuidedTemplateDecl->getLocation(), diag::note_template_decl_here);
10357  }
10358 
10359  auto &DS = D.getMutableDeclSpec();
10360  // We leave 'friend' and 'virtual' to be rejected in the normal way.
10361  if (DS.hasTypeSpecifier() || DS.getTypeQualifiers() ||
10362  DS.getStorageClassSpecLoc().isValid() || DS.isInlineSpecified() ||
10363  DS.isNoreturnSpecified() || DS.hasConstexprSpecifier()) {
10364  BadSpecifierDiagnoser Diagnoser(
10365  *this, D.getIdentifierLoc(),
10366  diag::err_deduction_guide_invalid_specifier);
10367 
10368  Diagnoser.check(DS.getStorageClassSpecLoc(), DS.getStorageClassSpec());
10370  SC = SC_None;
10371 
10372  // 'explicit' is permitted.
10373  Diagnoser.check(DS.getInlineSpecLoc(), "inline");
10374  Diagnoser.check(DS.getNoreturnSpecLoc(), "_Noreturn");
10375  Diagnoser.check(DS.getConstexprSpecLoc(), "constexpr");
10376  DS.ClearConstexprSpec();
10377 
10378  Diagnoser.check(DS.getConstSpecLoc(), "const");
10379  Diagnoser.check(DS.getRestrictSpecLoc(), "__restrict");
10380  Diagnoser.check(DS.getVolatileSpecLoc(), "volatile");
10381  Diagnoser.check(DS.getAtomicSpecLoc(), "_Atomic");
10382  Diagnoser.check(DS.getUnalignedSpecLoc(), "__unaligned");
10383  DS.ClearTypeQualifiers();
10384 
10385  Diagnoser.check(DS.getTypeSpecComplexLoc(), DS.getTypeSpecComplex());
10386  Diagnoser.check(DS.getTypeSpecSignLoc(), DS.getTypeSpecSign());
10387  Diagnoser.check(DS.getTypeSpecWidthLoc(), DS.getTypeSpecWidth());
10388  Diagnoser.check(DS.getTypeSpecTypeLoc(), DS.getTypeSpecType());
10389  DS.ClearTypeSpecType();
10390  }
10391 
10392  if (D.isInvalidType())
10393  return;
10394 
10395  // Check the declarator is simple enough.
10396  bool FoundFunction = false;
10397  for (const DeclaratorChunk &Chunk : llvm::reverse(D.type_objects())) {
10398  if (Chunk.Kind == DeclaratorChunk::Paren)
10399  continue;
10400  if (Chunk.Kind != DeclaratorChunk::Function || FoundFunction) {
10402  diag::err_deduction_guide_with_complex_decl)
10403  << D.getSourceRange();
10404  break;
10405  }
10406  if (!Chunk.Fun.hasTrailingReturnType()) {
10407  Diag(D.getName().getBeginLoc(),
10408  diag::err_deduction_guide_no_trailing_return_type);
10409  break;
10410  }
10411 
10412  // Check that the return type is written as a specialization of
10413  // the template specified as the deduction-guide's name.
10414  ParsedType TrailingReturnType = Chunk.Fun.getTrailingReturnType();
10415  TypeSourceInfo *TSI = nullptr;
10416  QualType RetTy = GetTypeFromParser(TrailingReturnType, &TSI);
10417  assert(TSI && "deduction guide has valid type but invalid return type?");
10418  bool AcceptableReturnType = false;
10419  bool MightInstantiateToSpecialization = false;
10420  if (auto RetTST =
10422  TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
10423  bool TemplateMatches =
10424  Context.hasSameTemplateName(SpecifiedName, GuidedTemplate);
10425  if (SpecifiedName.getKind() == TemplateName::Template && TemplateMatches)
10426  AcceptableReturnType = true;
10427  else {
10428  // This could still instantiate to the right type, unless we know it
10429  // names the wrong class template.
10430  auto *TD = SpecifiedName.getAsTemplateDecl();
10431  MightInstantiateToSpecialization = !(TD && isa<ClassTemplateDecl>(TD) &&
10432  !TemplateMatches);
10433  }
10434  } else if (!RetTy.hasQualifiers() && RetTy->isDependentType()) {
10435  MightInstantiateToSpecialization = true;
10436  }
10437 
10438  if (!AcceptableReturnType) {
10439  Diag(TSI->getTypeLoc().getBeginLoc(),
10440  diag::err_deduction_guide_bad_trailing_return_type)
10441  << GuidedTemplate << TSI->getType()
10442  << MightInstantiateToSpecialization
10443  << TSI->getTypeLoc().getSourceRange();
10444  }
10445 
10446  // Keep going to check that we don't have any inner declarator pieces (we
10447  // could still have a function returning a pointer to a function).
10448  FoundFunction = true;
10449  }
10450 
10451  if (D.isFunctionDefinition())
10452  Diag(D.getIdentifierLoc(), diag::err_deduction_guide_defines_function);
10453 }
10454 
10455 //===----------------------------------------------------------------------===//
10456 // Namespace Handling
10457 //===----------------------------------------------------------------------===//
10458 
10459 /// Diagnose a mismatch in 'inline' qualifiers when a namespace is
10460 /// reopened.
10462  SourceLocation Loc,
10463  IdentifierInfo *II, bool *IsInline,
10464  NamespaceDecl *PrevNS) {
10465  assert(*IsInline != PrevNS->isInline());
10466 
10467  // HACK: Work around a bug in libstdc++4.6's <atomic>, where
10468  // std::__atomic[0,1,2] are defined as non-inline namespaces, then reopened as
10469  // inline namespaces, with the intention of bringing names into namespace std.
10470  //
10471  // We support this just well enough to get that case working; this is not
10472  // sufficient to support reopening namespaces as inline in general.
10473  if (*IsInline && II && II->getName().startswith("__atomic") &&
10475  // Mark all prior declarations of the namespace as inline.
10476  for (NamespaceDecl *NS = PrevNS->getMostRecentDecl(); NS;
10477  NS = NS->getPreviousDecl())
10478  NS->setInline(*IsInline);
10479  // Patch up the lookup table for the containing namespace. This isn't really
10480  // correct, but it's good enough for this particular case.
10481  for (auto *I : PrevNS->decls())
10482  if (auto *ND = dyn_cast<NamedDecl>(I))
10483  PrevNS->getParent()->makeDeclVisibleInContext(ND);
10484  return;
10485  }
10486 
10487  if (PrevNS->isInline())
10488  // The user probably just forgot the 'inline', so suggest that it
10489  // be added back.
10490  S.Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
10491  << FixItHint::CreateInsertion(KeywordLoc, "inline ");
10492  else
10493  S.Diag(Loc, diag::err_inline_namespace_mismatch);
10494 
10495  S.Diag(PrevNS->getLocation(), diag::note_previous_definition);
10496  *IsInline = PrevNS->isInline();
10497 }
10498 
10499 /// ActOnStartNamespaceDef - This is called at the start of a namespace
10500 /// definition.
10502  Scope *NamespcScope, SourceLocation InlineLoc, SourceLocation NamespaceLoc,
10503  SourceLocation IdentLoc, IdentifierInfo *II, SourceLocation LBrace,
10504  const ParsedAttributesView &AttrList, UsingDirectiveDecl *&UD) {
10505  SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc;
10506  // For anonymous namespace, take the location of the left brace.
10507  SourceLocation Loc = II ? IdentLoc : LBrace;
10508  bool IsInline = InlineLoc.isValid();
10509  bool IsInvalid = false;
10510  bool IsStd = false;
10511  bool AddToKnown = false;
10512  Scope *DeclRegionScope = NamespcScope->getParent();
10513 
10514  NamespaceDecl *PrevNS = nullptr;
10515  if (II) {
10516  // C++ [namespace.def]p2:
10517  // The identifier in an original-namespace-definition shall not
10518  // have been previously defined in the declarative region in
10519  // which the original-namespace-definition appears. The
10520  // identifier in an original-namespace-definition is the name of
10521  // the namespace. Subsequently in that declarative region, it is
10522  // treated as an original-namespace-name.
10523  //
10524  // Since namespace names are unique in their scope, and we don't
10525  // look through using directives, just look for any ordinary names
10526  // as if by qualified name lookup.
10527  LookupResult R(*this, II, IdentLoc, LookupOrdinaryName,
10528  ForExternalRedeclaration);
10529  LookupQualifiedName(R, CurContext->getRedeclContext());
10530  NamedDecl *PrevDecl =
10531  R.isSingleResult() ? R.getRepresentativeDecl() : nullptr;
10532  PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
10533 
10534  if (PrevNS) {
10535  // This is an extended namespace definition.
10536  if (IsInline != PrevNS->isInline())
10537  DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, Loc, II,
10538  &IsInline, PrevNS);
10539  } else if (PrevDecl) {
10540  // This is an invalid name redefinition.
10541  Diag(Loc, diag::err_redefinition_different_kind)
10542  << II;
10543  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
10544  IsInvalid = true;
10545  // Continue on to push Namespc as current DeclContext and return it.
10546  } else if (II->isStr("std") &&
10547  CurContext->getRedeclContext()->isTranslationUnit()) {
10548  // This is the first "real" definition of the namespace "std", so update
10549  // our cache of the "std" namespace to point at this definition.
10550  PrevNS = getStdNamespace();
10551  IsStd = true;
10552  AddToKnown = !IsInline;
10553  } else {
10554  // We've seen this namespace for the first time.
10555  AddToKnown = !IsInline;
10556  }
10557  } else {
10558  // Anonymous namespaces.
10559 
10560  // Determine whether the parent already has an anonymous namespace.
10561  DeclContext *Parent = CurContext->getRedeclContext();
10562  if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
10563  PrevNS = TU->getAnonymousNamespace();
10564  } else {
10565  NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
10566  PrevNS = ND->getAnonymousNamespace();
10567  }
10568 
10569  if (PrevNS && IsInline != PrevNS->isInline())
10570  DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, NamespaceLoc, II,
10571  &IsInline, PrevNS);
10572  }
10573 
10574  NamespaceDecl *Namespc = NamespaceDecl::Create(Context, CurContext, IsInline,
10575  StartLoc, Loc, II, PrevNS);
10576  if (IsInvalid)
10577  Namespc->setInvalidDecl();
10578 
10579  ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
10580  AddPragmaAttributes(DeclRegionScope, Namespc);
10581 
10582  // FIXME: Should we be merging attributes?
10583  if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
10584  PushNamespaceVisibilityAttr(Attr, Loc);
10585 
10586  if (IsStd)
10587  StdNamespace = Namespc;
10588  if (AddToKnown)
10589  KnownNamespaces[Namespc] = false;
10590 
10591  if (II) {
10592  PushOnScopeChains(Namespc, DeclRegionScope);
10593  } else {
10594  // Link the anonymous namespace into its parent.
10595  DeclContext *Parent = CurContext->getRedeclContext();
10596  if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
10597  TU->setAnonymousNamespace(Namespc);
10598  } else {
10599  cast<NamespaceDecl>(Parent)->setAnonymousNamespace(Namespc);
10600  }
10601 
10602  CurContext->addDecl(Namespc);
10603 
10604  // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
10605  // behaves as if it were replaced by
10606  // namespace unique { /* empty body */ }
10607  // using namespace unique;
10608  // namespace unique { namespace-body }
10609  // where all occurrences of 'unique' in a translation unit are
10610  // replaced by the same identifier and this identifier differs
10611  // from all other identifiers in the entire program.
10612 
10613  // We just create the namespace with an empty name and then add an
10614  // implicit using declaration, just like the standard suggests.
10615  //
10616  // CodeGen enforces the "universally unique" aspect by giving all
10617  // declarations semantically contained within an anonymous
10618  // namespace internal linkage.
10619 
10620  if (!PrevNS) {
10621  UD = UsingDirectiveDecl::Create(Context, Parent,
10622  /* 'using' */ LBrace,
10623  /* 'namespace' */ SourceLocation(),
10624  /* qualifier */ NestedNameSpecifierLoc(),
10625  /* identifier */ SourceLocation(),
10626  Namespc,
10627  /* Ancestor */ Parent);
10628  UD->setImplicit();
10629  Parent->addDecl(UD);
10630  }
10631  }
10632 
10633  ActOnDocumentableDecl(Namespc);
10634 
10635  // Although we could have an invalid decl (i.e. the namespace name is a
10636  // redefinition), push it as current DeclContext and try to continue parsing.
10637  // FIXME: We should be able to push Namespc here, so that the each DeclContext
10638  // for the namespace has the declarations that showed up in that particular
10639  // namespace definition.
10640  PushDeclContext(NamespcScope, Namespc);
10641  return Namespc;
10642 }
10643 
10644 /// getNamespaceDecl - Returns the namespace a decl represents. If the decl
10645 /// is a namespace alias, returns the namespace it points to.
10647  if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
10648  return AD->getNamespace();
10649  return dyn_cast_or_null<NamespaceDecl>(D);
10650 }
10651 
10652 /// ActOnFinishNamespaceDef - This callback is called after a namespace is
10653 /// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
10655  NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
10656  assert(Namespc && "Invalid parameter, expected NamespaceDecl");
10657  Namespc->setRBraceLoc(RBrace);
10658  PopDeclContext();
10659  if (Namespc->hasAttr<VisibilityAttr>())
10660  PopPragmaVisibility(true, RBrace);
10661  // If this namespace contains an export-declaration, export it now.
10662  if (DeferredExportedNamespaces.erase(Namespc))
10664 }
10665 
10667  return cast_or_null<CXXRecordDecl>(
10668  StdBadAlloc.get(Context.getExternalSource()));
10669 }
10670 
10672  return cast_or_null<EnumDecl>(StdAlignValT.get(Context.getExternalSource()));
10673 }
10674 
10676  return cast_or_null<NamespaceDecl>(
10677  StdNamespace.get(Context.getExternalSource()));
10678 }
10679 
10681  if (!StdExperimentalNamespaceCache) {
10682  if (auto Std = getStdNamespace()) {
10683  LookupResult Result(*this, &PP.getIdentifierTable().get("experimental"),
10684  SourceLocation(), LookupNamespaceName);
10685  if (!LookupQualifiedName(Result, Std) ||
10686  !(StdExperimentalNamespaceCache =
10687  Result.getAsSingle<NamespaceDecl>()))
10688  Result.suppressDiagnostics();
10689  }
10690  }
10691  return StdExperimentalNamespaceCache;
10692 }
10693 
10694 namespace {
10695 
10697  USS_InvalidMember,
10698  USS_MissingMember,
10699  USS_NonTrivial,
10700  USS_Other
10701 };
10702 
10703 struct InvalidSTLDiagnoser {
10704  Sema &S;
10705  SourceLocation Loc;
10706  QualType TyForDiags;
10707 
10708  QualType operator()(UnsupportedSTLSelect Sel = USS_Other, StringRef Name = "",
10709  const VarDecl *VD = nullptr) {
10710  {
10711  auto D = S.Diag(Loc, diag::err_std_compare_type_not_supported)
10712  << TyForDiags << ((int)Sel);
10713  if (Sel == USS_InvalidMember || Sel == USS_MissingMember) {
10714  assert(!Name.empty());
10715  D << Name;
10716  }
10717  }
10718  if (Sel == USS_InvalidMember) {
10719  S.Diag(VD->getLocation(), diag::note_var_declared_here)
10720  << VD << VD->getSourceRange();
10721  }
10722  return QualType();
10723  }
10724 };
10725 } // namespace
10726 
10728  SourceLocation Loc,
10729  ComparisonCategoryUsage Usage) {
10730  assert(getLangOpts().CPlusPlus &&
10731  "Looking for comparison category type outside of C++.");
10732 
10733  // Use an elaborated type for diagnostics which has a name containing the
10734  // prepended 'std' namespace but not any inline namespace names.
10735  auto TyForDiags = [&](ComparisonCategoryInfo *Info) {
10736  auto *NNS =
10737  NestedNameSpecifier::Create(Context, nullptr, getStdNamespace());
10738  return Context.getElaboratedType(ETK_None, NNS, Info->getType());
10739  };
10740 
10741  // Check if we've already successfully checked the comparison category type
10742  // before. If so, skip checking it again.
10743  ComparisonCategoryInfo *Info = Context.CompCategories.lookupInfo(Kind);
10744  if (Info && FullyCheckedComparisonCategories[static_cast<unsigned>(Kind)]) {
10745  // The only thing we need to check is that the type has a reachable
10746  // definition in the current context.
10747  if (RequireCompleteType(Loc, TyForDiags(Info), diag::err_incomplete_type))
10748  return QualType();
10749 
10750  return Info->getType();
10751  }
10752 
10753  // If lookup failed
10754  if (!Info) {
10755  std::string NameForDiags = "std::";
10756  NameForDiags += ComparisonCategories::getCategoryString(Kind);
10757  Diag(Loc, diag::err_implied_comparison_category_type_not_found)
10758  << NameForDiags << (int)Usage;
10759  return QualType();
10760  }
10761 
10762  assert(Info->Kind == Kind);
10763  assert(Info->Record);
10764 
10765  // Update the Record decl in case we encountered a forward declaration on our
10766  // first pass. FIXME: This is a bit of a hack.
10767  if (Info->Record->hasDefinition())
10768  Info->Record = Info->Record->getDefinition();
10769 
10770  if (RequireCompleteType(Loc, TyForDiags(Info), diag::err_incomplete_type))
10771  return QualType();
10772 
10773  InvalidSTLDiagnoser UnsupportedSTLError{*this, Loc, TyForDiags(Info)};
10774 
10775  if (!Info->Record->isTriviallyCopyable())
10776  return UnsupportedSTLError(USS_NonTrivial);
10777 
10778  for (const CXXBaseSpecifier &BaseSpec : Info->Record->bases()) {
10779  CXXRecordDecl *Base = BaseSpec.getType()->getAsCXXRecordDecl();
10780  // Tolerate empty base classes.
10781  if (Base->isEmpty())
10782  continue;
10783  // Reject STL implementations which have at least one non-empty base.
10784  return UnsupportedSTLError();
10785  }
10786 
10787  // Check that the STL has implemented the types using a single integer field.
10788  // This expectation allows better codegen for builtin operators. We require:
10789  // (1) The class has exactly one field.
10790  // (2) The field is an integral or enumeration type.
10791  auto FIt = Info->Record->field_begin(), FEnd = Info->Record->field_end();
10792  if (std::distance(FIt, FEnd) != 1 ||
10793  !FIt->getType()->isIntegralOrEnumerationType()) {
10794  return UnsupportedSTLError();
10795  }
10796 
10797  // Build each of the require values and store them in Info.
10798  for (ComparisonCategoryResult CCR :
10800  StringRef MemName = ComparisonCategories::getResultString(CCR);
10801  ComparisonCategoryInfo::ValueInfo *ValInfo = Info->lookupValueInfo(CCR);
10802 
10803  if (!ValInfo)
10804  return UnsupportedSTLError(USS_MissingMember, MemName);
10805 
10806  VarDecl *VD = ValInfo->VD;
10807  assert(VD && "should not be null!");
10808 
10809  // Attempt to diagnose reasons why the STL definition of this type
10810  // might be foobar, including it failing to be a constant expression.
10811  // TODO Handle more ways the lookup or result can be invalid.
10812  if (!VD->isStaticDataMember() || !VD->isConstexpr() || !VD->hasInit() ||
10813  !VD->checkInitIsICE())
10814  return UnsupportedSTLError(USS_InvalidMember, MemName, VD);
10815 
10816  // Attempt to evaluate the var decl as a constant expression and extract
10817  // the value of its first field as a ICE. If this fails, the STL
10818  // implementation is not supported.
10819  if (!ValInfo->hasValidIntValue())
10820  return UnsupportedSTLError();
10821 
10822  MarkVariableReferenced(Loc, VD);
10823  }
10824 
10825  // We've successfully built the required types and expressions. Update
10826  // the cache and return the newly cached value.
10827  FullyCheckedComparisonCategories[static_cast<unsigned>(Kind)] = true;
10828  return Info->getType();
10829 }
10830 
10831 /// Retrieve the special "std" namespace, which may require us to
10832 /// implicitly define the namespace.
10834  if (!StdNamespace) {
10835  // The "std" namespace has not yet been defined, so build one implicitly.
10836  StdNamespace = NamespaceDecl::Create(Context,
10837  Context.getTranslationUnitDecl(),
10838  /*Inline=*/false,
10840  &PP.getIdentifierTable().get("std"),
10841  /*PrevDecl=*/nullptr);
10842  getStdNamespace()->setImplicit(true);
10843  }
10844 
10845  return getStdNamespace();
10846 }
10847 
10849  assert(getLangOpts().CPlusPlus &&
10850  "Looking for std::initializer_list outside of C++.");
10851 
10852  // We're looking for implicit instantiations of
10853  // template <typename E> class std::initializer_list.
10854 
10855  if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it.
10856  return false;
10857 
10858  ClassTemplateDecl *Template = nullptr;
10859  const TemplateArgument *Arguments = nullptr;
10860 
10861  if (const RecordType *RT = Ty->getAs<RecordType>()) {
10862 
10863  ClassTemplateSpecializationDecl *Specialization =
10864  dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
10865  if (!Specialization)
10866  return false;
10867 
10868  Template = Specialization->getSpecializedTemplate();
10869  Arguments = Specialization->getTemplateArgs().data();
10870  } else if (const TemplateSpecializationType *TST =
10872  Template = dyn_cast_or_null<ClassTemplateDecl>(
10873  TST->getTemplateName().getAsTemplateDecl());
10874  Arguments = TST->getArgs();
10875  }
10876  if (!Template)
10877  return false;
10878 
10879  if (!StdInitializerList) {
10880  // Haven't recognized std::initializer_list yet, maybe this is it.
10881  CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
10882  if (TemplateClass->getIdentifier() !=
10883  &PP.getIdentifierTable().get("initializer_list") ||
10884  !getStdNamespace()->InEnclosingNamespaceSetOf(
10885  TemplateClass->getDeclContext()))
10886  return false;
10887  // This is a template called std::initializer_list, but is it the right
10888  // template?
10889  TemplateParameterList *Params = Template->getTemplateParameters();
10890  if (Params->getMinRequiredArguments() != 1)
10891  return false;
10892  if (!isa<TemplateTypeParmDecl>(Params->getParam(0)))
10893  return false;
10894 
10895  // It's the right template.
10896  StdInitializerList = Template;
10897  }
10898 
10899  if (Template->getCanonicalDecl() != StdInitializerList->getCanonicalDecl())
10900  return false;
10901 
10902  // This is an instance of std::initializer_list. Find the argument type.
10903  if (Element)
10904  *Element = Arguments[0].getAsType();
10905  return true;
10906 }
10907 
10910  if (!Std) {
10911  S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
10912  return nullptr;
10913  }
10914 
10915  LookupResult Result(S, &S.PP.getIdentifierTable().get("initializer_list"),
10917  if (!S.LookupQualifiedName(Result, Std)) {
10918  S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
10919  return nullptr;
10920  }
10921  ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>();
10922  if (!Template) {
10923  Result.suppressDiagnostics();
10924  // We found something weird. Complain about the first thing we found.
10925  NamedDecl *Found = *Result.begin();
10926  S.Diag(Found->getLocation(), diag::err_malformed_std_initializer_list);
10927  return nullptr;
10928  }
10929 
10930  // We found some template called std::initializer_list. Now verify that it's
10931  // correct.
10932  TemplateParameterList *Params = Template->getTemplateParameters();
10933  if (Params->getMinRequiredArguments() != 1 ||
10934  !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
10935  S.Diag(Template->getLocation(), diag::err_malformed_std_initializer_list);
10936  return nullptr;
10937  }
10938 
10939  return Template;
10940 }
10941 
10943  if (!StdInitializerList) {
10944  StdInitializerList = LookupStdInitializerList(*this, Loc);
10945  if (!StdInitializerList)
10946  return QualType();
10947  }
10948 
10949  TemplateArgumentListInfo Args(Loc, Loc);
10951  Context.getTrivialTypeSourceInfo(Element,
10952  Loc)));
10953  return Context.getCanonicalType(
10954  CheckTemplateIdType(TemplateName(StdInitializerList), Loc, Args));
10955 }
10956 
10958  // C++ [dcl.init.list]p2:
10959  // A constructor is an initializer-list constructor if its first parameter
10960  // is of type std::initializer_list<E> or reference to possibly cv-qualified
10961  // std::initializer_list<E> for some type E, and either there are no other
10962  // parameters or else all other parameters have default arguments.
10963  if (Ctor->getNumParams() < 1 ||
10964  (Ctor->getNumParams() > 1 && !Ctor->getParamDecl(1)->hasDefaultArg()))
10965  return false;
10966 
10967  QualType ArgType = Ctor->getParamDecl(0)->getType();
10968  if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
10969  ArgType = RT->getPointeeType().getUnqualifiedType();
10970 
10971  return isStdInitializerList(ArgType, nullptr);
10972 }
10973 
10974 /// Determine whether a using statement is in a context where it will be
10975 /// apply in all contexts.
10977  switch (CurContext->getDeclKind()) {
10978  case Decl::TranslationUnit:
10979  return true;
10980  case Decl::LinkageSpec:
10981  return IsUsingDirectiveInToplevelContext(CurContext->getParent());
10982  default:
10983  return false;
10984  }
10985 }
10986 
10987 namespace {
10988 
10989 // Callback to only accept typo corrections that are namespaces.
10990 class NamespaceValidatorCCC final : public CorrectionCandidateCallback {
10991 public:
10992  bool ValidateCandidate(const TypoCorrection &candidate) override {
10993  if (NamedDecl *ND = candidate.getCorrectionDecl())
10994  return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
10995  return false;
10996  }
10997 
10998  std::unique_ptr<CorrectionCandidateCallback> clone() override {
10999  return std::make_unique<NamespaceValidatorCCC>(*this);
11000  }
11001 };
11002 
11003 }
11004 
11006  CXXScopeSpec &SS,
11007  SourceLocation IdentLoc,
11008  IdentifierInfo *Ident) {
11009  R.clear();
11010  NamespaceValidatorCCC CCC{};
11011  if (TypoCorrection Corrected =
11012  S.CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), Sc, &SS, CCC,
11014  if (DeclContext *DC = S.computeDeclContext(SS, false)) {
11015  std::string CorrectedStr(Corrected.getAsString(S.getLangOpts()));
11016  bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
11017  Ident->getName().equals(CorrectedStr);
11018  S.diagnoseTypo(Corrected,
11019  S.PDiag(diag::err_using_directive_member_suggest)
11020  << Ident << DC << DroppedSpecifier << SS.getRange(),
11021  S.PDiag(diag::note_namespace_defined_here));
11022  } else {
11023  S.diagnoseTypo(Corrected,
11024  S.PDiag(diag::err_using_directive_suggest) << Ident,
11025  S.PDiag(diag::note_namespace_defined_here));
11026  }
11027  R.addDecl(Corrected.getFoundDecl());
11028  return true;
11029  }
11030  return false;
11031 }
11032 
11034  SourceLocation NamespcLoc, CXXScopeSpec &SS,
11035  SourceLocation IdentLoc,
11036  IdentifierInfo *NamespcName,
11037  const ParsedAttributesView &AttrList) {
11038  assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
11039  assert(NamespcName && "Invalid NamespcName.");
11040  assert(IdentLoc.isValid() && "Invalid NamespceName location.");
11041 
11042  // This can only happen along a recovery path.
11043  while (S->isTemplateParamScope())
11044  S = S->getParent();
11045  assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
11046 
11047  UsingDirectiveDecl *UDir = nullptr;
11048  NestedNameSpecifier *Qualifier = nullptr;
11049  if (SS.isSet())
11050  Qualifier = SS.getScopeRep();
11051 
11052  // Lookup namespace name.
11053  LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
11054  LookupParsedName(R, S, &SS);
11055  if (R.isAmbiguous())
11056  return nullptr;
11057 
11058  if (R.empty()) {
11059  R.clear();
11060  // Allow "using namespace std;" or "using namespace ::std;" even if
11061  // "std" hasn't been defined yet, for GCC compatibility.
11062  if ((!Qualifier || Qualifier->getKind() == NestedNameSpecifier::Global) &&
11063  NamespcName->isStr("std")) {
11064  Diag(IdentLoc, diag::ext_using_undefined_std);
11065  R.addDecl(getOrCreateStdNamespace());
11066  R.resolveKind();
11067  }
11068  // Otherwise, attempt typo correction.
11069  else TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, NamespcName);
11070  }
11071 
11072  if (!R.empty()) {
11073  NamedDecl *Named = R.getRepresentativeDecl();
11075  assert(NS && "expected namespace decl");
11076 
11077  // The use of a nested name specifier may trigger deprecation warnings.
11078  DiagnoseUseOfDecl(Named, IdentLoc);
11079 
11080  // C++ [namespace.udir]p1:
11081  // A using-directive specifies that the names in the nominated
11082  // namespace can be used in the scope in which the
11083  // using-directive appears after the using-directive. During
11084  // unqualified name lookup (3.4.1), the names appear as if they
11085  // were declared in the nearest enclosing namespace which
11086  // contains both the using-directive and the nominated
11087  // namespace. [Note: in this context, "contains" means "contains
11088  // directly or indirectly". ]
11089 
11090  // Find enclosing context containing both using-directive and
11091  // nominated namespace.
11092  DeclContext *CommonAncestor = NS;
11093  while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
11094  CommonAncestor = CommonAncestor->getParent();
11095 
11096  UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
11097  SS.getWithLocInContext(Context),
11098  IdentLoc, Named, CommonAncestor);
11099 
11100  if (IsUsingDirectiveInToplevelContext(CurContext) &&
11101  !SourceMgr.isInMainFile(SourceMgr.getExpansionLoc(IdentLoc))) {
11102  Diag(IdentLoc, diag::warn_using_directive_in_header);
11103  }
11104 
11105  PushUsingDirective(S, UDir);
11106  } else {
11107  Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
11108  }
11109 
11110  if (UDir)
11111  ProcessDeclAttributeList(S, UDir, AttrList);
11112 
11113  return UDir;
11114 }
11115 
11117  // If the scope has an associated entity and the using directive is at
11118  // namespace or translation unit scope, add the UsingDirectiveDecl into
11119  // its lookup structure so qualified name lookup can find it.
11120  DeclContext *Ctx = S->getEntity();
11121  if (Ctx && !Ctx->isFunctionOrMethod())
11122  Ctx->addDecl(UDir);
11123  else
11124  // Otherwise, it is at block scope. The using-directives will affect lookup
11125  // only to the end of the scope.
11126  S->PushUsingDirective(UDir);
11127 }
11128 
11130  SourceLocation UsingLoc,
11131  SourceLocation TypenameLoc, CXXScopeSpec &SS,
11132  UnqualifiedId &Name,
11133  SourceLocation EllipsisLoc,
11134  const ParsedAttributesView &AttrList) {
11135  assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
11136 
11137  if (SS.isEmpty()) {
11138  Diag(Name.getBeginLoc(), diag::err_using_requires_qualname);
11139  return nullptr;
11140  }
11141 
11142  switch (Name.getKind()) {
11148  break;
11149 
11152  // C++11 inheriting constructors.
11153  Diag(Name.getBeginLoc(),
11154  getLangOpts().CPlusPlus11
11155  ? diag::warn_cxx98_compat_using_decl_constructor
11156  : diag::err_using_decl_constructor)
11157  << SS.getRange();
11158 
11159  if (getLangOpts().CPlusPlus11) break;
11160 
11161  return nullptr;
11162 
11164  Diag(Name.getBeginLoc(), diag::err_using_decl_destructor) << SS.getRange();
11165  return nullptr;
11166 
11168  Diag(Name.getBeginLoc(), diag::err_using_decl_template_id)
11170  return nullptr;
11171 
11173  llvm_unreachable("cannot parse qualified deduction guide name");
11174  }
11175 
11176  DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
11177  DeclarationName TargetName = TargetNameInfo.getName();
11178  if (!TargetName)
11179  return nullptr;
11180 
11181  // Warn about access declarations.
11182  if (UsingLoc.isInvalid()) {
11183  Diag(Name.getBeginLoc(), getLangOpts().CPlusPlus11
11184  ? diag::err_access_decl
11185  : diag::warn_access_decl_deprecated)
11186  << FixItHint::CreateInsertion(SS.getRange().getBegin(), "using ");
11187  }
11188 
11189  if (EllipsisLoc.isInvalid()) {
11190  if (DiagnoseUnexpandedParameterPack(SS, UPPC_UsingDeclaration) ||
11191  DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC_UsingDeclaration))
11192  return nullptr;
11193  } else {
11195  !TargetNameInfo.containsUnexpandedParameterPack()) {
11196  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
11197  << SourceRange(SS.getBeginLoc(), TargetNameInfo.getEndLoc());
11198  EllipsisLoc = SourceLocation();
11199  }
11200  }
11201 
11202  NamedDecl *UD =
11203  BuildUsingDeclaration(S, AS, UsingLoc, TypenameLoc.isValid(), TypenameLoc,
11204  SS, TargetNameInfo, EllipsisLoc, AttrList,
11205  /*IsInstantiation*/false);
11206  if (UD)
11207  PushOnScopeChains(UD, S, /*AddToContext*/ false);
11208 
11209  return UD;
11210 }
11211 
11212 /// Determine whether a using declaration considers the given
11213 /// declarations as "equivalent", e.g., if they are redeclarations of
11214 /// the same entity or are both typedefs of the same type.
11215 static bool
11217  if (D1->getCanonicalDecl() == D2->getCanonicalDecl())
11218  return true;
11219 
11220  if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(D1))
11221  if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2))
11222  return Context.hasSameType(TD1->getUnderlyingType(),
11223  TD2->getUnderlyingType());
11224 
11225  return false;
11226 }
11227 
11228 
11229 /// Determines whether to create a using shadow decl for a particular
11230 /// decl, given the set of decls existing prior to this using lookup.
11232  const LookupResult &Previous,
11233  UsingShadowDecl *&PrevShadow) {
11234  // Diagnose finding a decl which is not from a base class of the
11235  // current class. We do this now because there are cases where this
11236  // function will silently decide not to build a shadow decl, which
11237  // will pre-empt further diagnostics.
11238  //
11239  // We don't need to do this in C++11 because we do the check once on
11240  // the qualifier.
11241  //
11242  // FIXME: diagnose the following if we care enough:
11243  // struct A { int foo; };
11244  // struct B : A { using A::foo; };
11245  // template <class T> struct C : A {};
11246  // template <class T> struct D : C<T> { using B::foo; } // <---
11247  // This is invalid (during instantiation) in C++03 because B::foo
11248  // resolves to the using decl in B, which is not a base class of D<T>.
11249  // We can't diagnose it immediately because C<T> is an unknown
11250  // specialization. The UsingShadowDecl in D<T> then points directly
11251  // to A::foo, which will look well-formed when we instantiate.
11252  // The right solution is to not collapse the shadow-decl chain.
11253  if (!getLangOpts().CPlusPlus11 && CurContext->isRecord()) {
11254  DeclContext *OrigDC = Orig->getDeclContext();
11255 
11256  // Handle enums and anonymous structs.
11257  if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
11258  CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
11259  while (OrigRec->isAnonymousStructOrUnion())
11260  OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
11261 
11262  if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
11263  if (OrigDC == CurContext) {
11264  Diag(Using->getLocation(),
11265  diag::err_using_decl_nested_name_specifier_is_current_class)
11266  << Using->getQualifierLoc().getSourceRange();
11267  Diag(Orig->getLocation(), diag::note_using_decl_target);
11268  Using->setInvalidDecl();
11269  return true;
11270  }
11271 
11272  Diag(Using->getQualifierLoc().getBeginLoc(),
11273  diag::err_using_decl_nested_name_specifier_is_not_base_class)
11274  << Using->getQualifier()
11275  << cast<CXXRecordDecl>(CurContext)
11276  << Using->getQualifierLoc().getSourceRange();
11277  Diag(Orig->getLocation(), diag::note_using_decl_target);
11278  Using->setInvalidDecl();
11279  return true;
11280  }
11281  }
11282 
11283  if (Previous.empty()) return false;
11284 
11285  NamedDecl *Target = Orig;
11286  if (isa<UsingShadowDecl>(Target))
11287  Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
11288 
11289  // If the target happens to be one of the previous declarations, we
11290  // don't have a conflict.
11291  //
11292  // FIXME: but we might be increasing its access, in which case we
11293  // should redeclare it.
11294  NamedDecl *NonTag = nullptr, *Tag = nullptr;
11295  bool FoundEquivalentDecl = false;
11296  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
11297  I != E; ++I) {
11298  NamedDecl *D = (*I)->getUnderlyingDecl();
11299  // We can have UsingDecls in our Previous results because we use the same
11300  // LookupResult for checking whether the UsingDecl itself is a valid
11301  // redeclaration.
11302  if (isa<UsingDecl>(D) || isa<UsingPackDecl>(D))
11303  continue;
11304 
11305  if (auto *RD = dyn_cast<CXXRecordDecl>(D)) {
11306  // C++ [class.mem]p19:
11307  // If T is the name of a class, then [every named member other than
11308  // a non-static data member] shall have a name different from T
11309  if (RD->isInjectedClassName() && !isa<FieldDecl>(Target) &&
11310  !isa<IndirectFieldDecl>(Target) &&
11311  !isa<UnresolvedUsingValueDecl>(Target) &&
11312  DiagnoseClassNameShadow(
11313  CurContext,
11314  DeclarationNameInfo(Using->getDeclName(), Using->getLocation())))
11315  return true;
11316  }
11317 
11318  if (IsEquivalentForUsingDecl(Context, D, Target)) {
11319  if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(*I))
11320  PrevShadow = Shadow;
11321  FoundEquivalentDecl = true;
11322  } else if (isEquivalentInternalLinkageDeclaration(D, Target)) {
11323  // We don't conflict with an existing using shadow decl of an equivalent
11324  // declaration, but we're not a redeclaration of it.
11325  FoundEquivalentDecl = true;
11326  }
11327 
11328  if (isVisible(D))
11329  (isa<TagDecl>(D) ? Tag : NonTag) = D;
11330  }
11331 
11332  if (FoundEquivalentDecl)
11333  return false;
11334 
11335  if (FunctionDecl *FD = Target->getAsFunction()) {
11336  NamedDecl *OldDecl = nullptr;
11337  switch (CheckOverload(nullptr, FD, Previous, OldDecl,
11338  /*IsForUsingDecl*/ true)) {
11339  case Ovl_Overload:
11340  return false;
11341 
11342  case Ovl_NonFunction:
11343  Diag(Using->getLocation(), diag::err_using_decl_conflict);
11344  break;
11345 
11346  // We found a decl with the exact signature.
11347  case Ovl_Match:
11348  // If we're in a record, we want to hide the target, so we
11349  // return true (without a diagnostic) to tell the caller not to
11350  // build a shadow decl.
11351  if (CurContext->isRecord())
11352  return true;
11353 
11354  // If we're not in a record, this is an error.
11355  Diag(Using->getLocation(), diag::err_using_decl_conflict);
11356  break;
11357  }
11358 
11359  Diag(Target->getLocation(), diag::note_using_decl_target);
11360  Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
11361  Using->setInvalidDecl();
11362  return true;
11363  }
11364 
11365  // Target is not a function.
11366 
11367  if (isa<TagDecl>(Target)) {
11368  // No conflict between a tag and a non-tag.
11369  if (!Tag) return false;
11370 
11371  Diag(Using->getLocation(), diag::err_using_decl_conflict);
11372  Diag(Target->getLocation(), diag::note_using_decl_target);
11373  Diag(Tag->getLocation(), diag::note_using_decl_conflict);
11374  Using->setInvalidDecl();
11375  return true;
11376  }
11377 
11378  // No conflict between a tag and a non-tag.
11379  if (!NonTag) return false;
11380 
11381  Diag(Using->getLocation(), diag::err_using_decl_conflict);
11382  Diag(Target->getLocation(), diag::note_using_decl_target);
11383  Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
11384  Using->setInvalidDecl();
11385  return true;
11386 }
11387 
11388 /// Determine whether a direct base class is a virtual base class.
11389 static bool isVirtualDirectBase(CXXRecordDecl *Derived, CXXRecordDecl *Base) {
11390  if (!Derived->getNumVBases())
11391  return false;
11392  for (auto &B : Derived->bases())
11393  if (B.getType()->getAsCXXRecordDecl() == Base)
11394  return B.isVirtual();
11395  llvm_unreachable("not a direct base class");
11396 }
11397 
11398 /// Builds a shadow declaration corresponding to a 'using' declaration.
11400  UsingDecl *UD,
11401  NamedDecl *Orig,
11402  UsingShadowDecl *PrevDecl) {
11403  // If we resolved to another shadow declaration, just coalesce them.
11404  NamedDecl *Target = Orig;
11405  if (isa<UsingShadowDecl>(Target)) {
11406  Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
11407  assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
11408  }
11409 
11410  NamedDecl *NonTemplateTarget = Target;
11411  if (auto *TargetTD = dyn_cast<TemplateDecl>(Target))
11412  NonTemplateTarget = TargetTD->getTemplatedDecl();
11413 
11414  UsingShadowDecl *Shadow;
11415  if (NonTemplateTarget && isa<CXXConstructorDecl>(NonTemplateTarget)) {
11416  bool IsVirtualBase =
11417  isVirtualDirectBase(cast<CXXRecordDecl>(CurContext),
11418  UD->getQualifier()->getAsRecordDecl());
11420  Context, CurContext, UD->getLocation(), UD, Orig, IsVirtualBase);
11421  } else {
11422  Shadow = UsingShadowDecl::Create(Context, CurContext, UD->getLocation(), UD,
11423  Target);
11424  }
11425  UD->addShadowDecl(Shadow);
11426 
11427  Shadow->setAccess(UD->getAccess());
11428  if (Orig->isInvalidDecl() || UD->isInvalidDecl())
11429  Shadow->setInvalidDecl();
11430 
11431  Shadow->setPreviousDecl(PrevDecl);
11432 
11433  if (S)
11434  PushOnScopeChains(Shadow, S);
11435  else
11436  CurContext->addDecl(Shadow);
11437 
11438 
11439  return Shadow;
11440 }
11441 
11442 /// Hides a using shadow declaration. This is required by the current
11443 /// using-decl implementation when a resolvable using declaration in a
11444 /// class is followed by a declaration which would hide or override
11445 /// one or more of the using decl's targets; for example:
11446 ///
11447 /// struct Base { void foo(int); };
11448 /// struct Derived : Base {
11449 /// using Base::foo;
11450 /// void foo(int);
11451 /// };
11452 ///
11453 /// The governing language is C++03 [namespace.udecl]p12:
11454 ///
11455 /// When a using-declaration brings names from a base class into a
11456 /// derived class scope, member functions in the derived class
11457 /// override and/or hide member functions with the same name and
11458 /// parameter types in a base class (rather than conflicting).
11459 ///
11460 /// There are two ways to implement this:
11461 /// (1) optimistically create shadow decls when they're not hidden
11462 /// by existing declarations, or
11463 /// (2) don't create any shadow decls (or at least don't make them
11464 /// visible) until we've fully parsed/instantiated the class.
11465 /// The problem with (1) is that we might have to retroactively remove
11466 /// a shadow decl, which requires several O(n) operations because the
11467 /// decl structures are (very reasonably) not designed for removal.
11468 /// (2) avoids this but is very fiddly and phase-dependent.
11470  if (Shadow->getDeclName().getNameKind() ==
11472  cast<CXXRecordDecl>(Shadow->getDeclContext())->removeConversion(Shadow);
11473 
11474  // Remove it from the DeclContext...
11475  Shadow->getDeclContext()->removeDecl(Shadow);
11476 
11477  // ...and the scope, if applicable...
11478  if (S) {
11479  S->RemoveDecl(Shadow);
11480  IdResolver.RemoveDecl(Shadow);
11481  }
11482 
11483  // ...and the using decl.
11484  Shadow->getUsingDecl()->removeShadowDecl(Shadow);
11485 
11486  // TODO: complain somehow if Shadow was used. It shouldn't
11487  // be possible for this to happen, because...?
11488 }
11489 
11490 /// Find the base specifier for a base class with the given type.
11492  QualType DesiredBase,
11493  bool &AnyDependentBases) {
11494  // Check whether the named type is a direct base class.
11495  CanQualType CanonicalDesiredBase = DesiredBase->getCanonicalTypeUnqualified()
11496  .getUnqualifiedType();
11497  for (auto &Base : Derived->bases()) {
11498  CanQualType BaseType = Base.getType()->getCanonicalTypeUnqualified();
11499  if (CanonicalDesiredBase == BaseType)
11500  return &Base;
11501  if (BaseType->isDependentType())
11502  AnyDependentBases = true;
11503  }
11504  return nullptr;
11505 }
11506 
11507 namespace {
11508 class UsingValidatorCCC final : public CorrectionCandidateCallback {
11509 public:
11510  UsingValidatorCCC(bool HasTypenameKeyword, bool IsInstantiation,
11511  NestedNameSpecifier *NNS, CXXRecordDecl *RequireMemberOf)
11512  : HasTypenameKeyword(HasTypenameKeyword),
11513  IsInstantiation(IsInstantiation), OldNNS(NNS),
11514  RequireMemberOf(RequireMemberOf) {}
11515 
11516  bool ValidateCandidate(const TypoCorrection &Candidate) override {
11517  NamedDecl *ND = Candidate.getCorrectionDecl();
11518 
11519  // Keywords are not valid here.
11520  if (!ND || isa<NamespaceDecl>(ND))
11521  return false;
11522 
11523  // Completely unqualified names are invalid for a 'using' declaration.
11524  if (Candidate.WillReplaceSpecifier() && !Candidate.getCorrectionSpecifier())
11525  return false;
11526 
11527  // FIXME: Don't correct to a name that CheckUsingDeclRedeclaration would
11528  // reject.
11529 
11530  if (RequireMemberOf) {
11531  auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
11532  if (FoundRecord && FoundRecord->isInjectedClassName()) {
11533  // No-one ever wants a using-declaration to name an injected-class-name
11534  // of a base class, unless they're declaring an inheriting constructor.
11535  ASTContext &Ctx = ND->getASTContext();
11536  if (!Ctx.getLangOpts().CPlusPlus11)
11537  return false;
11538  QualType FoundType = Ctx.getRecordType(FoundRecord);
11539 
11540  // Check that the injected-class-name is named as a member of its own
11541  // type; we don't want to suggest 'using Derived::Base;', since that
11542  // means something else.
11544  Candidate.WillReplaceSpecifier()
11545  ? Candidate.getCorrectionSpecifier()
11546  : OldNNS;
11547  if (!Specifier->getAsType() ||
11548  !Ctx.hasSameType(QualType(Specifier->getAsType(), 0), FoundType))
11549  return false;
11550 
11551  // Check that this inheriting constructor declaration actually names a
11552  // direct base class of the current class.
11553  bool AnyDependentBases = false;
11554  if (!findDirectBaseWithType(RequireMemberOf,
11555  Ctx.getRecordType(FoundRecord),
11556  AnyDependentBases) &&
11557  !AnyDependentBases)
11558  return false;
11559  } else {
11560  auto *RD = dyn_cast<CXXRecordDecl>(ND->getDeclContext());
11561  if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(RD))
11562  return false;
11563 
11564  // FIXME: Check that the base class member is accessible?
11565  }
11566  } else {
11567  auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
11568  if (FoundRecord && FoundRecord->isInjectedClassName())
11569  return false;
11570  }
11571 
11572  if (isa<TypeDecl>(ND))
11573  return HasTypenameKeyword || !IsInstantiation;
11574 
11575  return !HasTypenameKeyword;
11576  }
11577 
11578  std::unique_ptr<CorrectionCandidateCallback> clone() override {
11579  return std::make_unique<UsingValidatorCCC>(*this);
11580  }
11581 
11582 private:
11583  bool HasTypenameKeyword;
11584  bool IsInstantiation;
11585  NestedNameSpecifier *OldNNS;
11586  CXXRecordDecl *RequireMemberOf;
11587 };
11588 } // end anonymous namespace
11589 
11590 /// Builds a using declaration.
11591 ///
11592 /// \param IsInstantiation - Whether this call arises from an
11593 /// instantiation of an unresolved using declaration. We treat
11594 /// the lookup differently for these declarations.
11596  Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,
11597  bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,
11598  DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,
11599  const ParsedAttributesView &AttrList, bool IsInstantiation) {
11600  assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
11601  SourceLocation IdentLoc = NameInfo.getLoc();
11602  assert(IdentLoc.isValid() && "Invalid TargetName location.");
11603 
11604  // FIXME: We ignore attributes for now.
11605 
11606  // For an inheriting constructor declaration, the name of the using
11607  // declaration is the name of a constructor in this class, not in the
11608  // base class.
11609  DeclarationNameInfo UsingName = NameInfo;
11610  if (UsingName.getName().getNameKind() == DeclarationName::CXXConstructorName)
11611  if (auto *RD = dyn_cast<CXXRecordDecl>(CurContext))
11613  Context.getCanonicalType(Context.getRecordType(RD))));
11614 
11615  // Do the redeclaration lookup in the current scope.
11616  LookupResult Previous(*this, UsingName, LookupUsingDeclName,
11617  ForVisibleRedeclaration);
11618  Previous.setHideTags(false);
11619  if (S) {
11620  LookupName(Previous, S);
11621 
11622  // It is really dumb that we have to do this.
11623  LookupResult::Filter F = Previous.makeFilter();
11624  while (F.hasNext()) {
11625  NamedDecl *D = F.next();
11626  if (!isDeclInScope(D, CurContext, S))
11627  F.erase();
11628  // If we found a local extern declaration that's not ordinarily visible,
11629  // and this declaration is being added to a non-block scope, ignore it.
11630  // We're only checking for scope conflicts here, not also for violations
11631  // of the linkage rules.
11632  else if (!CurContext->isFunctionOrMethod() && D->isLocalExternDecl() &&
11634  F.erase();
11635  }
11636  F.done();
11637  } else {
11638  assert(IsInstantiation && "no scope in non-instantiation");
11639  if (CurContext->isRecord())
11640  LookupQualifiedName(Previous, CurContext);
11641  else {
11642  // No redeclaration check is needed here; in non-member contexts we
11643  // diagnosed all possible conflicts with other using-declarations when
11644  // building the template:
11645  //
11646  // For a dependent non-type using declaration, the only valid case is
11647  // if we instantiate to a single enumerator. We check for conflicts
11648  // between shadow declarations we introduce, and we check in the template
11649  // definition for conflicts between a non-type using declaration and any
11650  // other declaration, which together covers all cases.
11651  //
11652  // A dependent typename using declaration will never successfully
11653  // instantiate, since it will always name a class member, so we reject
11654  // that in the template definition.
11655  }
11656  }
11657 
11658  // Check for invalid redeclarations.
11659  if (CheckUsingDeclRedeclaration(UsingLoc, HasTypenameKeyword,
11660  SS, IdentLoc, Previous))
11661  return nullptr;
11662 
11663  // Check for bad qualifiers.
11664  if (CheckUsingDeclQualifier(UsingLoc, HasTypenameKeyword, SS, NameInfo,
11665  IdentLoc))
11666  return nullptr;
11667 
11668  DeclContext *LookupContext = computeDeclContext(SS);
11669  NamedDecl *D;
11670  NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
11671  if (!LookupContext || EllipsisLoc.isValid()) {
11672  if (HasTypenameKeyword) {
11673  // FIXME: not all declaration name kinds are legal here
11674  D = UnresolvedUsingTypenameDecl::Create(Context, CurContext,
11675  UsingLoc, TypenameLoc,
11676  QualifierLoc,
11677  IdentLoc, NameInfo.getName(),
11678  EllipsisLoc);
11679  } else {
11680  D = UnresolvedUsingValueDecl::Create(Context, CurContext, UsingLoc,
11681  QualifierLoc, NameInfo, EllipsisLoc);
11682  }
11683  D->setAccess(AS);
11684  CurContext->addDecl(D);
11685  return D;
11686  }
11687 
11688  auto Build = [&](bool Invalid) {
11689  UsingDecl *UD =
11690  UsingDecl::Create(Context, CurContext, UsingLoc, QualifierLoc,
11691  UsingName, HasTypenameKeyword);
11692  UD->setAccess(AS);
11693  CurContext->addDecl(UD);
11694  UD->setInvalidDecl(Invalid);
11695  return UD;
11696  };
11697  auto BuildInvalid = [&]{ return Build(true); };
11698  auto BuildValid = [&]{ return Build(false); };
11699 
11700  if (RequireCompleteDeclContext(SS, LookupContext))
11701  return BuildInvalid();
11702 
11703  // Look up the target name.
11704  LookupResult R(*this, NameInfo, LookupOrdinaryName);
11705 
11706  // Unlike most lookups, we don't always want to hide tag
11707  // declarations: tag names are visible through the using declaration
11708  // even if hidden by ordinary names, *except* in a dependent context
11709  // where it's important for the sanity of two-phase lookup.
11710  if (!IsInstantiation)
11711  R.setHideTags(false);
11712 
11713  // For the purposes of this lookup, we have a base object type
11714  // equal to that of the current context.
11715  if (CurContext->isRecord()) {
11717  Context.getTypeDeclType(cast<CXXRecordDecl>(CurContext)));
11718  }
11719 
11720  LookupQualifiedName(R, LookupContext);
11721 
11722  // Try to correct typos if possible. If constructor name lookup finds no
11723  // results, that means the named class has no explicit constructors, and we
11724  // suppressed declaring implicit ones (probably because it's dependent or
11725  // invalid).
11726  if (R.empty() &&
11728  // HACK: Work around a bug in libstdc++'s detection of ::gets. Sometimes
11729  // it will believe that glibc provides a ::gets in cases where it does not,
11730  // and will try to pull it into namespace std with a using-declaration.
11731  // Just ignore the using-declaration in that case.
11732  auto *II = NameInfo.getName().getAsIdentifierInfo();
11733  if (getLangOpts().CPlusPlus14 && II && II->isStr("gets") &&
11734  CurContext->isStdNamespace() &&
11735  isa<TranslationUnitDecl>(LookupContext) &&
11736  getSourceManager().isInSystemHeader(UsingLoc))
11737  return nullptr;
11738  UsingValidatorCCC CCC(HasTypenameKeyword, IsInstantiation, SS.getScopeRep(),
11739  dyn_cast<CXXRecordDecl>(CurContext));
11740  if (TypoCorrection Corrected =
11741  CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, &SS, CCC,
11742  CTK_ErrorRecovery)) {
11743  // We reject candidates where DroppedSpecifier == true, hence the
11744  // literal '0' below.
11745  diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
11746  << NameInfo.getName() << LookupContext << 0
11747  << SS.getRange());
11748 
11749  // If we picked a correction with no attached Decl we can't do anything
11750  // useful with it, bail out.
11751  NamedDecl *ND = Corrected.getCorrectionDecl();
11752  if (!ND)
11753  return BuildInvalid();
11754 
11755  // If we corrected to an inheriting constructor, handle it as one.
11756  auto *RD = dyn_cast<CXXRecordDecl>(ND);
11757  if (RD && RD->isInjectedClassName()) {
11758  // The parent of the injected class name is the class itself.
11759  RD = cast<CXXRecordDecl>(RD->getParent());
11760 
11761  // Fix up the information we'll use to build the using declaration.
11762  if (Corrected.WillReplaceSpecifier()) {
11764  Builder.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
11765  QualifierLoc.getSourceRange());
11766  QualifierLoc = Builder.getWithLocInContext(Context);
11767  }
11768 
11769  // In this case, the name we introduce is the name of a derived class
11770  // constructor.
11771  auto *CurClass = cast<CXXRecordDecl>(CurContext);
11772  UsingName.setName(Context.DeclarationNames.getCXXConstructorName(
11773  Context.getCanonicalType(Context.getRecordType(CurClass))));
11774  UsingName.setNamedTypeInfo(nullptr);
11775  for (auto *Ctor : LookupConstructors(RD))
11776  R.addDecl(Ctor);
11777  R.resolveKind();
11778  } else {
11779  // FIXME: Pick up all the declarations if we found an overloaded
11780  // function.
11781  UsingName.setName(ND->getDeclName());
11782  R.addDecl(ND);
11783  }
11784  } else {
11785  Diag(IdentLoc, diag::err_no_member)
11786  << NameInfo.getName() << LookupContext << SS.getRange();
11787  return BuildInvalid();
11788  }
11789  }
11790 
11791  if (R.isAmbiguous())
11792  return BuildInvalid();
11793 
11794  if (HasTypenameKeyword) {
11795  // If we asked for a typename and got a non-type decl, error out.
11796  if (!R.getAsSingle<TypeDecl>()) {
11797  Diag(IdentLoc, diag::err_using_typename_non_type);
11798  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
11799  Diag((*I)->getUnderlyingDecl()->getLocation(),
11800  diag::note_using_decl_target);
11801  return BuildInvalid();
11802  }
11803  } else {
11804  // If we asked for a non-typename and we got a type, error out,
11805  // but only if this is an instantiation of an unresolved using
11806  // decl. Otherwise just silently find the type name.
11807  if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
11808  Diag(IdentLoc, diag::err_using_dependent_value_is_type);
11809  Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
11810  return BuildInvalid();
11811  }
11812  }
11813 
11814  // C++14 [namespace.udecl]p6:
11815  // A using-declaration shall not name a namespace.
11816  if (R.getAsSingle<NamespaceDecl>()) {
11817  Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
11818  << SS.getRange();
11819  return BuildInvalid();
11820  }
11821 
11822  // C++14 [namespace.udecl]p7:
11823  // A using-declaration shall not name a scoped enumerator.
11824  if (auto *ED = R.getAsSingle<EnumConstantDecl>()) {
11825  if (cast<EnumDecl>(ED->getDeclContext())->isScoped()) {
11826  Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_scoped_enum)
11827  << SS.getRange();
11828  return BuildInvalid();
11829  }
11830  }
11831 
11832  UsingDecl *UD = BuildValid();
11833 
11834  // Some additional rules apply to inheriting constructors.
11835  if (UsingName.getName().getNameKind() ==
11837  // Suppress access diagnostics; the access check is instead performed at the
11838  // point of use for an inheriting constructor.
11839  R.suppressDiagnostics();
11840  if (CheckInheritingConstructorUsingDecl(UD))
11841  return UD;
11842  }
11843 
11844  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
11845  UsingShadowDecl *PrevDecl = nullptr;
11846  if (!CheckUsingShadowDecl(UD, *I, Previous, PrevDecl))
11847  BuildUsingShadowDecl(S, UD, *I, PrevDecl);
11848  }
11849 
11850  return UD;
11851 }
11852 
11854  ArrayRef<NamedDecl *> Expansions) {
11855  assert(isa<UnresolvedUsingValueDecl>(InstantiatedFrom) ||
11856  isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) ||
11857  isa<UsingPackDecl>(InstantiatedFrom));
11858 
11859  auto *UPD =
11860  UsingPackDecl::Create(Context, CurContext, InstantiatedFrom, Expansions);
11861  UPD->setAccess(InstantiatedFrom->getAccess());
11862  CurContext->addDecl(UPD);
11863  return UPD;
11864 }
11865 
11866 /// Additional checks for a using declaration referring to a constructor name.
11868  assert(!UD->hasTypename() && "expecting a constructor name");
11869 
11870  const Type *SourceType = UD->getQualifier()->getAsType();
11871  assert(SourceType &&
11872  "Using decl naming constructor doesn't have type in scope spec.");
11873  CXXRecordDecl *TargetClass = cast<CXXRecordDecl>(CurContext);
11874 
11875  // Check whether the named type is a direct base class.
11876  bool AnyDependentBases = false;
11877  auto *Base = findDirectBaseWithType(TargetClass, QualType(SourceType, 0),
11878  AnyDependentBases);
11879  if (!Base && !AnyDependentBases) {
11880  Diag(UD->getUsingLoc(),
11881  diag::err_using_decl_constructor_not_in_direct_base)
11882  << UD->getNameInfo().getSourceRange()
11883  << QualType(SourceType, 0) << TargetClass;
11884  UD->setInvalidDecl();
11885  return true;
11886  }
11887 
11888  if (Base)
11889  Base->setInheritConstructors();
11890 
11891  return false;
11892 }
11893 
11894 /// Checks that the given using declaration is not an invalid
11895 /// redeclaration. Note that this is checking only for the using decl
11896 /// itself, not for any ill-formedness among the UsingShadowDecls.
11898  bool HasTypenameKeyword,
11899  const CXXScopeSpec &SS,
11900  SourceLocation NameLoc,
11901  const LookupResult &Prev) {
11902  NestedNameSpecifier *Qual = SS.getScopeRep();
11903 
11904  // C++03 [namespace.udecl]p8:
11905  // C++0x [namespace.udecl]p10:
11906  // A using-declaration is a declaration and can therefore be used
11907  // repeatedly where (and only where) multiple declarations are
11908  // allowed.
11909  //
11910  // That's in non-member contexts.
11911  if (!CurContext->getRedeclContext()->isRecord()) {
11912  // A dependent qualifier outside a class can only ever resolve to an
11913  // enumeration type. Therefore it conflicts with any other non-type
11914  // declaration in the same scope.
11915  // FIXME: How should we check for dependent type-type conflicts at block
11916  // scope?
11917  if (Qual->isDependent() && !HasTypenameKeyword) {
11918  for (auto *D : Prev) {
11919  if (!isa<TypeDecl>(D) && !isa<UsingDecl>(D) && !isa<UsingPackDecl>(D)) {
11920  bool OldCouldBeEnumerator =
11921  isa<UnresolvedUsingValueDecl>(D) || isa<EnumConstantDecl>(D);
11922  Diag(NameLoc,
11923  OldCouldBeEnumerator ? diag::err_redefinition
11924  : diag::err_redefinition_different_kind)
11925  << Prev.getLookupName();
11926  Diag(D->getLocation(), diag::note_previous_definition);
11927  return true;
11928  }
11929  }
11930  }
11931  return false;
11932  }
11933 
11934  for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
11935  NamedDecl *D = *I;
11936 
11937  bool DTypename;
11938  NestedNameSpecifier *DQual;
11939  if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
11940  DTypename = UD->hasTypename();
11941  DQual = UD->getQualifier();
11942  } else if (UnresolvedUsingValueDecl *UD
11943  = dyn_cast<UnresolvedUsingValueDecl>(D)) {
11944  DTypename = false;
11945  DQual = UD->getQualifier();
11946  } else if (UnresolvedUsingTypenameDecl *UD
11947  = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
11948  DTypename = true;
11949  DQual = UD->getQualifier();
11950  } else continue;
11951 
11952  // using decls differ if one says 'typename' and the other doesn't.
11953  // FIXME: non-dependent using decls?
11954  if (HasTypenameKeyword != DTypename) continue;
11955 
11956  // using decls differ if they name different scopes (but note that
11957  // template instantiation can cause this check to trigger when it
11958  // didn't before instantiation).
11959  if (Context.getCanonicalNestedNameSpecifier(Qual) !=
11960  Context.getCanonicalNestedNameSpecifier(DQual))
11961  continue;
11962 
11963  Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
11964  Diag(D->getLocation(), diag::note_using_decl) << 1;
11965  return true;
11966  }
11967 
11968  return false;
11969 }
11970 
11971 
11972 /// Checks that the given nested-name qualifier used in a using decl
11973 /// in the current context is appropriately related to the current
11974 /// scope. If an error is found, diagnoses it and returns true.
11976  bool HasTypename,
11977  const CXXScopeSpec &SS,
11978  const DeclarationNameInfo &NameInfo,
11979  SourceLocation NameLoc) {
11980  DeclContext *NamedContext = computeDeclContext(SS);
11981 
11982  if (!CurContext->isRecord()) {
11983  // C++03 [namespace.udecl]p3:
11984  // C++0x [namespace.udecl]p8:
11985  // A using-declaration for a class member shall be a member-declaration.
11986 
11987  // If we weren't able to compute a valid scope, it might validly be a
11988  // dependent class scope or a dependent enumeration unscoped scope. If
11989  // we have a 'typename' keyword, the scope must resolve to a class type.
11990  if ((HasTypename && !NamedContext) ||
11991  (NamedContext && NamedContext->getRedeclContext()->isRecord())) {
11992  auto *RD = NamedContext
11993  ? cast<CXXRecordDecl>(NamedContext->getRedeclContext())
11994  : nullptr;
11995  if (RD && RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), RD))
11996  RD = nullptr;
11997 
11998  Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member)
11999  << SS.getRange();
12000 
12001  // If we have a complete, non-dependent source type, try to suggest a
12002  // way to get the same effect.
12003  if (!RD)
12004  return true;
12005 
12006  // Find what this using-declaration was referring to.
12007  LookupResult R(*this, NameInfo, LookupOrdinaryName);
12008  R.setHideTags(false);
12009  R.suppressDiagnostics();
12010  LookupQualifiedName(R, RD);
12011 
12012  if (R.getAsSingle<TypeDecl>()) {
12013  if (getLangOpts().CPlusPlus11) {
12014  // Convert 'using X::Y;' to 'using Y = X::Y;'.
12015  Diag(SS.getBeginLoc(), diag::note_using_decl_class_member_workaround)
12016  << 0 // alias declaration
12018  NameInfo.getName().getAsString() +
12019  " = ");
12020  } else {
12021  // Convert 'using X::Y;' to 'typedef X::Y Y;'.
12022  SourceLocation InsertLoc = getLocForEndOfToken(NameInfo.getEndLoc());
12023  Diag(InsertLoc, diag::note_using_decl_class_member_workaround)
12024  << 1 // typedef declaration
12025  << FixItHint::CreateReplacement(UsingLoc, "typedef")
12027  InsertLoc, " " + NameInfo.getName().getAsString());
12028  }
12029  } else if (R.getAsSingle<VarDecl>()) {
12030  // Don't provide a fixit outside C++11 mode; we don't want to suggest
12031  // repeating the type of the static data member here.
12032  FixItHint FixIt;
12033  if (getLangOpts().CPlusPlus11) {
12034  // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
12036  UsingLoc, "auto &" + NameInfo.getName().getAsString() + " = ");
12037  }
12038 
12039  Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
12040  << 2 // reference declaration
12041  << FixIt;
12042  } else if (R.getAsSingle<EnumConstantDecl>()) {
12043  // Don't provide a fixit outside C++11 mode; we don't want to suggest
12044  // repeating the type of the enumeration here, and we can't do so if
12045  // the type is anonymous.
12046  FixItHint FixIt;
12047  if (getLangOpts().CPlusPlus11) {
12048  // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
12050  UsingLoc,
12051  "constexpr auto " + NameInfo.getName().getAsString() + " = ");
12052  }
12053 
12054  Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
12055  << (getLangOpts().CPlusPlus11 ? 4 : 3) // const[expr] variable
12056  << FixIt;
12057  }
12058  return true;
12059  }
12060 
12061  // Otherwise, this might be valid.
12062  return false;
12063  }
12064 
12065  // The current scope is a record.
12066 
12067  // If the named context is dependent, we can't decide much.
12068  if (!NamedContext) {
12069  // FIXME: in C++0x, we can diagnose if we can prove that the
12070  // nested-name-specifier does not refer to a base class, which is
12071  // still possible in some cases.
12072 
12073  // Otherwise we have to conservatively report that things might be
12074  // okay.
12075  return false;
12076  }
12077 
12078  if (!NamedContext->isRecord()) {
12079  // Ideally this would point at the last name in the specifier,
12080  // but we don't have that level of source info.
12081  Diag(SS.getRange().getBegin(),
12082  diag::err_using_decl_nested_name_specifier_is_not_class)
12083  << SS.getScopeRep() << SS.getRange();
12084  return true;
12085  }
12086 
12087  if (!NamedContext->isDependentContext() &&
12088  RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), NamedContext))
12089  return true;
12090 
12091  if (getLangOpts().CPlusPlus11) {
12092  // C++11 [namespace.udecl]p3:
12093  // In a using-declaration used as a member-declaration, the
12094  // nested-name-specifier shall name a base class of the class
12095  // being defined.
12096 
12097  if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
12098  cast<CXXRecordDecl>(NamedContext))) {
12099  if (CurContext == NamedContext) {
12100  Diag(NameLoc,
12101  diag::err_using_decl_nested_name_specifier_is_current_class)
12102  << SS.getRange();
12103  return true;
12104  }
12105 
12106  if (!cast<CXXRecordDecl>(NamedContext)->isInvalidDecl()) {
12107  Diag(SS.getRange().getBegin(),
12108  diag::err_using_decl_nested_name_specifier_is_not_base_class)
12109  << SS.getScopeRep()
12110  << cast<CXXRecordDecl>(CurContext)
12111  << SS.getRange();
12112  }
12113  return true;
12114  }
12115 
12116  return false;
12117  }
12118 
12119  // C++03 [namespace.udecl]p4:
12120  // A using-declaration used as a member-declaration shall refer
12121  // to a member of a base class of the class being defined [etc.].
12122 
12123  // Salient point: SS doesn't have to name a base class as long as
12124  // lookup only finds members from base classes. Therefore we can
12125  // diagnose here only if we can prove that that can't happen,
12126  // i.e. if the class hierarchies provably don't intersect.
12127 
12128  // TODO: it would be nice if "definitely valid" results were cached
12129  // in the UsingDecl and UsingShadowDecl so that these checks didn't
12130  // need to be repeated.
12131 
12132  llvm::SmallPtrSet<const CXXRecordDecl *, 4> Bases;
12133  auto Collect = [&Bases](const CXXRecordDecl *Base) {
12134  Bases.insert(Base);
12135  return true;
12136  };
12137 
12138  // Collect all bases. Return false if we find a dependent base.
12139  if (!cast<CXXRecordDecl>(CurContext)->forallBases(Collect))
12140  return false;
12141 
12142  // Returns true if the base is dependent or is one of the accumulated base
12143  // classes.
12144  auto IsNotBase = [&Bases](const CXXRecordDecl *Base) {
12145  return !Bases.count(Base);
12146  };
12147 
12148  // Return false if the class has a dependent base or if it or one
12149  // of its bases is present in the base set of the current context.
12150  if (Bases.count(cast<CXXRecordDecl>(NamedContext)) ||
12151  !cast<CXXRecordDecl>(NamedContext)->forallBases(IsNotBase))
12152  return false;
12153 
12154  Diag(SS.getRange().getBegin(),
12155  diag::err_using_decl_nested_name_specifier_is_not_base_class)
12156  << SS.getScopeRep()
12157  << cast<CXXRecordDecl>(CurContext)
12158  << SS.getRange();
12159 
12160  return true;
12161 }
12162 
12164  MultiTemplateParamsArg TemplateParamLists,
12165  SourceLocation UsingLoc, UnqualifiedId &Name,
12166  const ParsedAttributesView &AttrList,
12167  TypeResult Type, Decl *DeclFromDeclSpec) {
12168  // Skip up to the relevant declaration scope.
12169  while (S->isTemplateParamScope())
12170  S = S->getParent();
12171  assert((S->getFlags() & Scope::DeclScope) &&
12172  "got alias-declaration outside of declaration scope");
12173 
12174  if (Type.isInvalid())
12175  return nullptr;
12176 
12177  bool Invalid = false;
12178  DeclarationNameInfo NameInfo = GetNameFromUnqualifiedId(Name);
12179  TypeSourceInfo *TInfo = nullptr;
12180  GetTypeFromParser(Type.get(), &TInfo);
12181 
12182  if (DiagnoseClassNameShadow(CurContext, NameInfo))
12183  return nullptr;
12184 
12185  if (DiagnoseUnexpandedParameterPack(Name.StartLocation, TInfo,
12186  UPPC_DeclarationType)) {
12187  Invalid = true;
12188  TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
12189  TInfo->getTypeLoc().getBeginLoc());
12190  }
12191 
12192  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
12193  TemplateParamLists.size()
12194  ? forRedeclarationInCurContext()
12195  : ForVisibleRedeclaration);
12196  LookupName(Previous, S);
12197 
12198  // Warn about shadowing the name of a template parameter.
12199  if (Previous.isSingleResult() &&
12200  Previous.getFoundDecl()->isTemplateParameter()) {
12201  DiagnoseTemplateParameterShadow(Name.StartLocation,Previous.getFoundDecl());
12202  Previous.clear();
12203  }
12204 
12205  assert(Name.Kind == UnqualifiedIdKind::IK_Identifier &&
12206  "name in alias declaration must be an identifier");
12207  TypeAliasDecl *NewTD = TypeAliasDecl::Create(Context, CurContext, UsingLoc,
12208  Name.StartLocation,
12209  Name.Identifier, TInfo);
12210 
12211  NewTD->setAccess(AS);
12212 
12213  if (Invalid)
12214  NewTD->setInvalidDecl();
12215 
12216  ProcessDeclAttributeList(S, NewTD, AttrList);
12217  AddPragmaAttributes(S, NewTD);
12218 
12219  CheckTypedefForVariablyModifiedType(S, NewTD);
12220  Invalid |= NewTD->isInvalidDecl();
12221 
12222  bool Redeclaration = false;
12223 
12224  NamedDecl *NewND;
12225  if (TemplateParamLists.size()) {
12226  TypeAliasTemplateDecl *OldDecl = nullptr;
12227  TemplateParameterList *OldTemplateParams = nullptr;
12228 
12229  if (TemplateParamLists.size() != 1) {
12230  Diag(UsingLoc, diag::err_alias_template_extra_headers)
12231  << SourceRange(TemplateParamLists[1]->getTemplateLoc(),
12232  TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
12233  }
12234  TemplateParameterList *TemplateParams = TemplateParamLists[0];
12235 
12236  // Check that we can declare a template here.
12237  if (CheckTemplateDeclScope(S, TemplateParams))
12238  return nullptr;
12239 
12240  // Only consider previous declarations in the same scope.
12241  FilterLookupForScope(Previous, CurContext, S, /*ConsiderLinkage*/false,
12242  /*ExplicitInstantiationOrSpecialization*/false);
12243  if (!Previous.empty()) {
12244  Redeclaration = true;
12245 
12246  OldDecl = Previous.getAsSingle<TypeAliasTemplateDecl>();
12247  if (!OldDecl && !Invalid) {
12248  Diag(UsingLoc, diag::err_redefinition_different_kind)
12249  << Name.Identifier;
12250 
12251  NamedDecl *OldD = Previous.getRepresentativeDecl();
12252  if (OldD->getLocation().isValid())
12253  Diag(OldD->getLocation(), diag::note_previous_definition);
12254 
12255  Invalid = true;
12256  }
12257 
12258  if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) {
12259  if (TemplateParameterListsAreEqual(TemplateParams,
12260  OldDecl->getTemplateParameters(),
12261  /*Complain=*/true,
12262  TPL_TemplateMatch))
12263  OldTemplateParams =
12265  else
12266  Invalid = true;
12267 
12268  TypeAliasDecl *OldTD = OldDecl->getTemplatedDecl();
12269  if (!Invalid &&
12270  !Context.hasSameType(OldTD->getUnderlyingType(),
12271  NewTD->getUnderlyingType())) {
12272  // FIXME: The C++0x standard does not clearly say this is ill-formed,
12273  // but we can't reasonably accept it.
12274  Diag(NewTD->getLocation(), diag::err_redefinition_different_typedef)
12275  << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType();
12276  if (OldTD->getLocation().isValid())
12277  Diag(OldTD->getLocation(), diag::note_previous_definition);
12278  Invalid = true;
12279  }
12280  }
12281  }
12282 
12283  // Merge any previous default template arguments into our parameters,
12284  // and check the parameter list.
12285  if (CheckTemplateParameterList(TemplateParams, OldTemplateParams,
12286  TPC_TypeAliasTemplate))
12287  return nullptr;
12288 
12289  TypeAliasTemplateDecl *NewDecl =
12290  TypeAliasTemplateDecl::Create(Context, CurContext, UsingLoc,
12291  Name.Identifier, TemplateParams,
12292  NewTD);
12293  NewTD->setDescribedAliasTemplate(NewDecl);
12294 
12295  NewDecl->setAccess(AS);
12296 
12297  if (Invalid)
12298  NewDecl->setInvalidDecl();
12299  else if (OldDecl) {
12300  NewDecl->setPreviousDecl(OldDecl);
12301  CheckRedeclarationModuleOwnership(NewDecl, OldDecl);
12302  }
12303 
12304  NewND = NewDecl;
12305  } else {
12306  if (auto *TD = dyn_cast_or_null<TagDecl>(DeclFromDeclSpec)) {
12307  setTagNameForLinkagePurposes(TD, NewTD);
12308  handleTagNumbering(TD, S);
12309  }
12310  ActOnTypedefNameDecl(S, CurContext, NewTD, Previous, Redeclaration);
12311  NewND = NewTD;
12312  }
12313 
12314  PushOnScopeChains(NewND, S);
12315  ActOnDocumentableDecl(NewND);
12316  return NewND;
12317 }
12318 
12320  SourceLocation AliasLoc,
12321  IdentifierInfo *Alias, CXXScopeSpec &SS,
12322  SourceLocation IdentLoc,
12323  IdentifierInfo *Ident) {
12324 
12325  // Lookup the namespace name.
12326  LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
12327  LookupParsedName(R, S, &SS);
12328 
12329  if (R.isAmbiguous())
12330  return nullptr;
12331 
12332  if (R.empty()) {
12333  if (!TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, Ident)) {
12334  Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
12335  return nullptr;
12336  }
12337  }
12338  assert(!R.isAmbiguous() && !R.empty());
12339  NamedDecl *ND = R.getRepresentativeDecl();
12340 
12341  // Check if we have a previous declaration with the same name.
12342  LookupResult PrevR(*this, Alias, AliasLoc, LookupOrdinaryName,
12343  ForVisibleRedeclaration);
12344  LookupName(PrevR, S);
12345 
12346  // Check we're not shadowing a template parameter.
12347  if (PrevR.isSingleResult() && PrevR.getFoundDecl()->isTemplateParameter()) {
12348  DiagnoseTemplateParameterShadow(AliasLoc, PrevR.getFoundDecl());
12349  PrevR.clear();
12350  }
12351 
12352  // Filter out any other lookup result from an enclosing scope.
12353  FilterLookupForScope(PrevR, CurContext, S, /*ConsiderLinkage*/false,
12354  /*AllowInlineNamespace*/false);
12355 
12356  // Find the previous declaration and check that we can redeclare it.
12357  NamespaceAliasDecl *Prev = nullptr;
12358  if (PrevR.isSingleResult()) {
12359  NamedDecl *PrevDecl = PrevR.getRepresentativeDecl();
12360  if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
12361  // We already have an alias with the same name that points to the same
12362  // namespace; check that it matches.
12363  if (AD->getNamespace()->Equals(getNamespaceDecl(ND))) {
12364  Prev = AD;
12365  } else if (isVisible(PrevDecl)) {
12366  Diag(AliasLoc, diag::err_redefinition_different_namespace_alias)
12367  << Alias;
12368  Diag(AD->getLocation(), diag::note_previous_namespace_alias)
12369  << AD->getNamespace();
12370  return nullptr;
12371  }
12372  } else if (isVisible(PrevDecl)) {
12373  unsigned DiagID = isa<NamespaceDecl>(PrevDecl->getUnderlyingDecl())
12374  ? diag::err_redefinition
12375  : diag::err_redefinition_different_kind;
12376  Diag(AliasLoc, DiagID) << Alias;
12377  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
12378  return nullptr;
12379  }
12380  }
12381 
12382  // The use of a nested name specifier may trigger deprecation warnings.
12383  DiagnoseUseOfDecl(ND, IdentLoc);
12384 
12385  NamespaceAliasDecl *AliasDecl =
12386  NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
12387  Alias, SS.getWithLocInContext(Context),
12388  IdentLoc, ND);
12389  if (Prev)
12390  AliasDecl->setPreviousDecl(Prev);
12391 
12392  PushOnScopeChains(AliasDecl, S);
12393  return AliasDecl;
12394 }
12395 
12396 namespace {
12397 struct SpecialMemberExceptionSpecInfo
12398  : SpecialMemberVisitor<SpecialMemberExceptionSpecInfo> {
12399  SourceLocation Loc;
12401 
12402  SpecialMemberExceptionSpecInfo(Sema &S, CXXMethodDecl *MD,
12405  SourceLocation Loc)
12406  : SpecialMemberVisitor(S, MD, CSM, ICI), Loc(Loc), ExceptSpec(S) {}
12407 
12408  bool visitBase(CXXBaseSpecifier *Base);
12409  bool visitField(FieldDecl *FD);
12410 
12411  void visitClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
12412  unsigned Quals);
12413 
12414  void visitSubobjectCall(Subobject Subobj,
12416 };
12417 }
12418 
12419 bool SpecialMemberExceptionSpecInfo::visitBase(CXXBaseSpecifier *Base) {
12420  auto *RT = Base->getType()->getAs<RecordType>();
12421  if (!RT)
12422  return false;
12423 
12424  auto *BaseClass = cast<CXXRecordDecl>(RT->getDecl());
12425  Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
12426  if (auto *BaseCtor = SMOR.getMethod()) {
12427  visitSubobjectCall(Base, BaseCtor);
12428  return false;
12429  }
12430 
12431  visitClassSubobject(BaseClass, Base, 0);
12432  return false;
12433 }
12434 
12435 bool SpecialMemberExceptionSpecInfo::visitField(FieldDecl *FD) {
12436  if (CSM == Sema::CXXDefaultConstructor && FD->hasInClassInitializer()) {
12437  Expr *E = FD->getInClassInitializer();
12438  if (!E)
12439  // FIXME: It's a little wasteful to build and throw away a
12440  // CXXDefaultInitExpr here.
12441  // FIXME: We should have a single context note pointing at Loc, and
12442  // this location should be MD->getLocation() instead, since that's
12443  // the location where we actually use the default init expression.
12444  E = S.BuildCXXDefaultInitExpr(Loc, FD).get();
12445  if (E)
12446  ExceptSpec.CalledExpr(E);
12447  } else if (auto *RT = S.Context.getBaseElementType(FD->getType())
12448  ->getAs<RecordType>()) {
12449  visitClassSubobject(cast<CXXRecordDecl>(RT->getDecl()), FD,
12450  FD->getType().getCVRQualifiers());
12451  }
12452  return false;
12453 }
12454 
12455 void SpecialMemberExceptionSpecInfo::visitClassSubobject(CXXRecordDecl *Class,
12456  Subobject Subobj,
12457  unsigned Quals) {
12458  FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
12459  bool IsMutable = Field && Field->isMutable();
12460  visitSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable));
12461 }
12462 
12463 void SpecialMemberExceptionSpecInfo::visitSubobjectCall(
12464  Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR) {
12465  // Note, if lookup fails, it doesn't matter what exception specification we
12466  // choose because the special member will be deleted.
12467  if (CXXMethodDecl *MD = SMOR.getMethod())
12468  ExceptSpec.CalledDecl(getSubobjectLoc(Subobj), MD);
12469 }
12470 
12474  ExplicitSpec.getExpr(), Context.BoolTy, Result, CCEK_ExplicitBool);
12475  ExplicitSpec.setExpr(Converted.get());
12476  if (Converted.isUsable() && !Converted.get()->isValueDependent()) {
12477  ExplicitSpec.setKind(Result.getBoolValue()
12480  return true;
12481  }
12482  ExplicitSpec.setKind(ExplicitSpecKind::Unresolved);
12483  return false;
12484 }
12485 
12488  if (!ExplicitExpr->isTypeDependent())
12489  tryResolveExplicitSpecifier(ES);
12490  return ES;
12491 }
12492 
12497  ComputingExceptionSpec CES(S, MD, Loc);
12498 
12499  CXXRecordDecl *ClassDecl = MD->getParent();
12500 
12501  // C++ [except.spec]p14:
12502  // An implicitly declared special member function (Clause 12) shall have an
12503  // exception-specification. [...]
12504  SpecialMemberExceptionSpecInfo Info(S, MD, CSM, ICI, MD->getLocation());
12505  if (ClassDecl->isInvalidDecl())
12506  return Info.ExceptSpec;
12507 
12508  // FIXME: If this diagnostic fires, we're probably missing a check for
12509  // attempting to resolve an exception specification before it's known
12510  // at a higher level.
12512  S.Context.getRecordType(ClassDecl),
12513  diag::err_exception_spec_incomplete_type))
12514  return Info.ExceptSpec;
12515 
12516  // C++1z [except.spec]p7:
12517  // [Look for exceptions thrown by] a constructor selected [...] to
12518  // initialize a potentially constructed subobject,
12519  // C++1z [except.spec]p8:
12520  // The exception specification for an implicitly-declared destructor, or a
12521  // destructor without a noexcept-specifier, is potentially-throwing if and
12522  // only if any of the destructors for any of its potentially constructed
12523  // subojects is potentially throwing.
12524  // FIXME: We respect the first rule but ignore the "potentially constructed"
12525  // in the second rule to resolve a core issue (no number yet) that would have
12526  // us reject:
12527  // struct A { virtual void f() = 0; virtual ~A() noexcept(false) = 0; };
12528  // struct B : A {};
12529  // struct C : B { void f(); };
12530  // ... due to giving B::~B() a non-throwing exception specification.
12531  Info.visit(Info.IsConstructor ? Info.VisitPotentiallyConstructedBases
12532  : Info.VisitAllBases);
12533 
12534  return Info.ExceptSpec;
12535 }
12536 
12537 namespace {
12538 /// RAII object to register a special member as being currently declared.
12539 struct DeclaringSpecialMember {
12540  Sema &S;
12542  Sema::ContextRAII SavedContext;
12543  bool WasAlreadyBeingDeclared;
12544 
12545  DeclaringSpecialMember(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM)
12546  : S(S), D(RD, CSM), SavedContext(S, RD) {
12547  WasAlreadyBeingDeclared = !S.SpecialMembersBeingDeclared.insert(D).second;
12548  if (WasAlreadyBeingDeclared)
12549  // This almost never happens, but if it does, ensure that our cache
12550  // doesn't contain a stale result.
12551  S.SpecialMemberCache.clear();
12552  else {
12553  // Register a note to be produced if we encounter an error while
12554  // declaring the special member.
12557  // FIXME: We don't have a location to use here. Using the class's
12558  // location maintains the fiction that we declare all special members
12559  // with the class, but (1) it's not clear that lying about that helps our
12560  // users understand what's going on, and (2) there may be outer contexts
12561  // on the stack (some of which are relevant) and printing them exposes
12562  // our lies.
12563  Ctx.PointOfInstantiation = RD->getLocation();
12564  Ctx.Entity = RD;
12565  Ctx.SpecialMember = CSM;
12566  S.pushCodeSynthesisContext(Ctx);
12567  }
12568  }
12569  ~DeclaringSpecialMember() {
12570  if (!WasAlreadyBeingDeclared) {
12571  S.SpecialMembersBeingDeclared.erase(D);
12573  }
12574  }
12575 
12576  /// Are we already trying to declare this special member?
12577  bool isAlreadyBeingDeclared() const {
12578  return WasAlreadyBeingDeclared;
12579  }
12580 };
12581 }
12582 
12584  // Look up any existing declarations, but don't trigger declaration of all
12585  // implicit special members with this name.
12586  DeclarationName Name = FD->getDeclName();
12587  LookupResult R(*this, Name, SourceLocation(), LookupOrdinaryName,
12588  ForExternalRedeclaration);
12589  for (auto *D : FD->getParent()->lookup(Name))
12590  if (auto *Acceptable = R.getAcceptableDecl(D))
12591  R.addDecl(Acceptable);
12592  R.resolveKind();
12593  R.suppressDiagnostics();
12594 
12595  CheckFunctionDeclaration(S, FD, R, /*IsMemberSpecialization*/false);
12596 }
12597 
12598 void Sema::setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem,
12599  QualType ResultTy,
12600  ArrayRef<QualType> Args) {
12601  // Build an exception specification pointing back at this constructor.
12602  FunctionProtoType::ExtProtoInfo EPI = getImplicitMethodEPI(*this, SpecialMem);
12603 
12604  LangAS AS = getDefaultCXXMethodAddrSpace();
12605  if (AS != LangAS::Default) {
12606  EPI.TypeQuals.addAddressSpace(AS);
12607  }
12608 
12609  auto QT = Context.getFunctionType(ResultTy, Args, EPI);
12610  SpecialMem->setType(QT);
12611 }
12612 
12614  CXXRecordDecl *ClassDecl) {
12615  // C++ [class.ctor]p5:
12616  // A default constructor for a class X is a constructor of class X
12617  // that can be called without an argument. If there is no
12618  // user-declared constructor for class X, a default constructor is
12619  // implicitly declared. An implicitly-declared default constructor
12620  // is an inline public member of its class.
12621  assert(ClassDecl->needsImplicitDefaultConstructor() &&
12622  "Should not build implicit default constructor!");
12623 
12624  DeclaringSpecialMember DSM(*this, ClassDecl, CXXDefaultConstructor);
12625  if (DSM.isAlreadyBeingDeclared())
12626  return nullptr;
12627 
12628  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
12629  CXXDefaultConstructor,
12630  false);
12631 
12632  // Create the actual constructor declaration.
12633  CanQualType ClassType
12634  = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
12635  SourceLocation ClassLoc = ClassDecl->getLocation();
12636  DeclarationName Name
12637  = Context.DeclarationNames.getCXXConstructorName(ClassType);
12638  DeclarationNameInfo NameInfo(Name, ClassLoc);
12640  Context, ClassDecl, ClassLoc, NameInfo, /*Type*/ QualType(),
12641  /*TInfo=*/nullptr, ExplicitSpecifier(),
12642  /*isInline=*/true, /*isImplicitlyDeclared=*/true,
12643  Constexpr ? CSK_constexpr : CSK_unspecified);
12644  DefaultCon->setAccess(AS_public);
12645  DefaultCon->setDefaulted();
12646 
12647  if (getLangOpts().CUDA) {
12648  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDefaultConstructor,
12649  DefaultCon,
12650  /* ConstRHS */ false,
12651  /* Diagnose */ false);
12652  }
12653 
12654  setupImplicitSpecialMemberType(DefaultCon, Context.VoidTy, None);
12655 
12656  // We don't need to use SpecialMemberIsTrivial here; triviality for default
12657  // constructors is easy to compute.
12658  DefaultCon->setTrivial(ClassDecl->hasTrivialDefaultConstructor());
12659 
12660  // Note that we have declared this constructor.
12661  ++getASTContext().NumImplicitDefaultConstructorsDeclared;
12662 
12663  Scope *S = getScopeForContext(ClassDecl);
12664  CheckImplicitSpecialMemberDeclaration(S, DefaultCon);
12665 
12666  if (ShouldDeleteSpecialMember(DefaultCon, CXXDefaultConstructor))
12667  SetDeclDeleted(DefaultCon, ClassLoc);
12668 
12669  if (S)
12670  PushOnScopeChains(DefaultCon, S, false);
12671  ClassDecl->addDecl(DefaultCon);
12672 
12673  return DefaultCon;
12674 }
12675 
12677  CXXConstructorDecl *Constructor) {
12678  assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
12679  !Constructor->doesThisDeclarationHaveABody() &&
12680  !Constructor->isDeleted()) &&
12681  "DefineImplicitDefaultConstructor - call it for implicit default ctor");
12682  if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
12683  return;
12684 
12685  CXXRecordDecl *ClassDecl = Constructor->getParent();
12686  assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
12687 
12688  SynthesizedFunctionScope Scope(*this, Constructor);
12689 
12690  // The exception specification is needed because we are defining the
12691  // function.
12692  ResolveExceptionSpec(CurrentLocation,
12693  Constructor->getType()->castAs<FunctionProtoType>());
12694  MarkVTableUsed(CurrentLocation, ClassDecl);
12695 
12696  // Add a context note for diagnostics produced after this point.
12697  Scope.addContextNote(CurrentLocation);
12698 
12699  if (SetCtorInitializers(Constructor, /*AnyErrors=*/false)) {
12700  Constructor->setInvalidDecl();
12701  return;
12702  }
12703 
12704  SourceLocation Loc = Constructor->getEndLoc().isValid()
12705  ? Constructor->getEndLoc()
12706  : Constructor->getLocation();
12707  Constructor->setBody(new (Context) CompoundStmt(Loc));
12708  Constructor->markUsed(Context);
12709 
12710  if (ASTMutationListener *L = getASTMutationListener()) {
12711  L->CompletedImplicitDefinition(Constructor);
12712  }
12713 
12714  DiagnoseUninitializedFields(*this, Constructor);
12715 }
12716 
12718  // Perform any delayed checks on exception specifications.
12719  CheckDelayedMemberExceptionSpecs();
12720 }
12721 
12722 /// Find or create the fake constructor we synthesize to model constructing an
12723 /// object of a derived class via a constructor of a base class.
12726  CXXConstructorDecl *BaseCtor,
12727  ConstructorUsingShadowDecl *Shadow) {
12728  CXXRecordDecl *Derived = Shadow->getParent();
12729  SourceLocation UsingLoc = Shadow->getLocation();
12730 
12731  // FIXME: Add a new kind of DeclarationName for an inherited constructor.
12732  // For now we use the name of the base class constructor as a member of the
12733  // derived class to indicate a (fake) inherited constructor name.
12734  DeclarationName Name = BaseCtor->getDeclName();
12735 
12736  // Check to see if we already have a fake constructor for this inherited
12737  // constructor call.
12738  for (NamedDecl *Ctor : Derived->lookup(Name))
12739  if (declaresSameEntity(cast<CXXConstructorDecl>(Ctor)
12740  ->getInheritedConstructor()
12741  .getConstructor(),
12742  BaseCtor))
12743  return cast<CXXConstructorDecl>(Ctor);
12744 
12745  DeclarationNameInfo NameInfo(Name, UsingLoc);
12746  TypeSourceInfo *TInfo =
12747  Context.getTrivialTypeSourceInfo(BaseCtor->getType(), UsingLoc);
12748  FunctionProtoTypeLoc ProtoLoc =
12750 
12751  // Check the inherited constructor is valid and find the list of base classes
12752  // from which it was inherited.
12753  InheritedConstructorInfo ICI(*this, Loc, Shadow);
12754 
12755  bool Constexpr =
12756  BaseCtor->isConstexpr() &&
12757  defaultedSpecialMemberIsConstexpr(*this, Derived, CXXDefaultConstructor,
12758  false, BaseCtor, &ICI);
12759 
12761  Context, Derived, UsingLoc, NameInfo, TInfo->getType(), TInfo,
12762  BaseCtor->getExplicitSpecifier(), /*isInline=*/true,
12763  /*isImplicitlyDeclared=*/true,
12764  Constexpr ? BaseCtor->getConstexprKind() : CSK_unspecified,
12765  InheritedConstructor(Shadow, BaseCtor),
12766  BaseCtor->getTrailingRequiresClause());
12767  if (Shadow->isInvalidDecl())
12768  DerivedCtor->setInvalidDecl();
12769 
12770  // Build an unevaluated exception specification for this fake constructor.
12771  const FunctionProtoType *FPT = TInfo->getType()->castAs<FunctionProtoType>();
12774  EPI.ExceptionSpec.SourceDecl = DerivedCtor;
12775  DerivedCtor->setType(Context.getFunctionType(FPT->getReturnType(),
12776  FPT->getParamTypes(), EPI));
12777 
12778  // Build the parameter declarations.
12779  SmallVector<ParmVarDecl *, 16> ParamDecls;
12780  for (unsigned I = 0, N = FPT->getNumParams(); I != N; ++I) {
12781  TypeSourceInfo *TInfo =
12782  Context.getTrivialTypeSourceInfo(FPT->getParamType(I), UsingLoc);
12784  Context, DerivedCtor, UsingLoc, UsingLoc, /*IdentifierInfo=*/nullptr,
12785  FPT->getParamType(I), TInfo, SC_None, /*DefArg=*/nullptr);
12786  PD->setScopeInfo(0, I);
12787  PD->setImplicit();
12788  // Ensure attributes are propagated onto parameters (this matters for
12789  // format, pass_object_size, ...).
12790  mergeDeclAttributes(PD, BaseCtor->getParamDecl(I));
12791  ParamDecls.push_back(PD);
12792  ProtoLoc.setParam(I, PD);
12793  }
12794 
12795  // Set up the new constructor.
12796  assert(!BaseCtor->isDeleted() && "should not use deleted constructor");
12797  DerivedCtor->setAccess(BaseCtor->getAccess());
12798  DerivedCtor->setParams(ParamDecls);
12799  Derived->addDecl(DerivedCtor);
12800 
12801  if (ShouldDeleteSpecialMember(DerivedCtor, CXXDefaultConstructor, &ICI))
12802  SetDeclDeleted(DerivedCtor, UsingLoc);
12803 
12804  return DerivedCtor;
12805 }
12806 
12808  InheritedConstructorInfo ICI(*this, Ctor->getLocation(),
12810  ShouldDeleteSpecialMember(Ctor, CXXDefaultConstructor, &ICI,
12811  /*Diagnose*/true);
12812 }
12813 
12815  CXXConstructorDecl *Constructor) {
12816  CXXRecordDecl *ClassDecl = Constructor->getParent();
12817  assert(Constructor->getInheritedConstructor() &&
12818  !Constructor->doesThisDeclarationHaveABody() &&
12819  !Constructor->isDeleted());
12820  if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
12821  return;
12822 
12823  // Initializations are performed "as if by a defaulted default constructor",
12824  // so enter the appropriate scope.
12825  SynthesizedFunctionScope Scope(*this, Constructor);
12826 
12827  // The exception specification is needed because we are defining the
12828  // function.
12829  ResolveExceptionSpec(CurrentLocation,
12830  Constructor->getType()->castAs<FunctionProtoType>());
12831  MarkVTableUsed(CurrentLocation, ClassDecl);
12832 
12833  // Add a context note for diagnostics produced after this point.
12834  Scope.addContextNote(CurrentLocation);
12835 
12836  ConstructorUsingShadowDecl *Shadow =
12837  Constructor->getInheritedConstructor().getShadowDecl();
12838  CXXConstructorDecl *InheritedCtor =
12839  Constructor->getInheritedConstructor().getConstructor();
12840 
12841  // [class.inhctor.init]p1:
12842  // initialization proceeds as if a defaulted default constructor is used to
12843  // initialize the D object and each base class subobject from which the
12844  // constructor was inherited
12845 
12846  InheritedConstructorInfo ICI(*this, CurrentLocation, Shadow);
12847  CXXRecordDecl *RD = Shadow->getParent();
12848  SourceLocation InitLoc = Shadow->getLocation();
12849 
12850  // Build explicit initializers for all base classes from which the
12851  // constructor was inherited.
12853  for (bool VBase : {false, true}) {
12854  for (CXXBaseSpecifier &B : VBase ? RD->vbases() : RD->bases()) {
12855  if (B.isVirtual() != VBase)
12856  continue;
12857 
12858  auto *BaseRD = B.getType()->getAsCXXRecordDecl();
12859  if (!BaseRD)
12860  continue;
12861 
12862  auto BaseCtor = ICI.findConstructorForBase(BaseRD, InheritedCtor);
12863  if (!BaseCtor.first)
12864  continue;
12865 
12866  MarkFunctionReferenced(CurrentLocation, BaseCtor.first);
12867  ExprResult Init = new (Context) CXXInheritedCtorInitExpr(
12868  InitLoc, B.getType(), BaseCtor.first, VBase, BaseCtor.second);
12869 
12870  auto *TInfo = Context.getTrivialTypeSourceInfo(B.getType(), InitLoc);
12871  Inits.push_back(new (Context) CXXCtorInitializer(
12872  Context, TInfo, VBase, InitLoc, Init.get(), InitLoc,
12873  SourceLocation()));
12874  }
12875  }
12876 
12877  // We now proceed as if for a defaulted default constructor, with the relevant
12878  // initializers replaced.
12879 
12880  if (SetCtorInitializers(Constructor, /*AnyErrors*/false, Inits)) {
12881  Constructor->setInvalidDecl();
12882  return;
12883  }
12884 
12885  Constructor->setBody(new (Context) CompoundStmt(InitLoc));
12886  Constructor->markUsed(Context);
12887 
12888  if (ASTMutationListener *L = getASTMutationListener()) {
12889  L->CompletedImplicitDefinition(Constructor);
12890  }
12891 
12892  DiagnoseUninitializedFields(*this, Constructor);
12893 }
12894 
12896  // C++ [class.dtor]p2:
12897  // If a class has no user-declared destructor, a destructor is
12898  // declared implicitly. An implicitly-declared destructor is an
12899  // inline public member of its class.
12900  assert(ClassDecl->needsImplicitDestructor());
12901 
12902  DeclaringSpecialMember DSM(*this, ClassDecl, CXXDestructor);
12903  if (DSM.isAlreadyBeingDeclared())
12904  return nullptr;
12905 
12906  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
12907  CXXDestructor,
12908  false);
12909 
12910  // Create the actual destructor declaration.
12911  CanQualType ClassType
12912  = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
12913  SourceLocation ClassLoc = ClassDecl->getLocation();
12914  DeclarationName Name
12915  = Context.DeclarationNames.getCXXDestructorName(ClassType);
12916  DeclarationNameInfo NameInfo(Name, ClassLoc);
12917  CXXDestructorDecl *Destructor =
12918  CXXDestructorDecl::Create(Context, ClassDecl, ClassLoc, NameInfo,
12919  QualType(), nullptr, /*isInline=*/true,
12920  /*isImplicitlyDeclared=*/true,
12921  Constexpr ? CSK_constexpr : CSK_unspecified);
12922  Destructor->setAccess(AS_public);
12923  Destructor->setDefaulted();
12924 
12925  if (getLangOpts().CUDA) {
12926  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDestructor,
12927  Destructor,
12928  /* ConstRHS */ false,
12929  /* Diagnose */ false);
12930  }
12931 
12932  setupImplicitSpecialMemberType(Destructor, Context.VoidTy, None);
12933 
12934  // We don't need to use SpecialMemberIsTrivial here; triviality for
12935  // destructors is easy to compute.
12936  Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
12937  Destructor->setTrivialForCall(ClassDecl->hasAttr<TrivialABIAttr>() ||
12938  ClassDecl->hasTrivialDestructorForCall());
12939 
12940  // Note that we have declared this destructor.
12941  ++getASTContext().NumImplicitDestructorsDeclared;
12942 
12943  Scope *S = getScopeForContext(ClassDecl);
12944  CheckImplicitSpecialMemberDeclaration(S, Destructor);
12945 
12946  // We can't check whether an implicit destructor is deleted before we complete
12947  // the definition of the class, because its validity depends on the alignment
12948  // of the class. We'll check this from ActOnFields once the class is complete.
12949  if (ClassDecl->isCompleteDefinition() &&
12950  ShouldDeleteSpecialMember(Destructor, CXXDestructor))
12951  SetDeclDeleted(Destructor, ClassLoc);
12952 
12953  // Introduce this destructor into its scope.
12954  if (S)
12955  PushOnScopeChains(Destructor, S, false);
12956  ClassDecl->addDecl(Destructor);
12957 
12958  return Destructor;
12959 }
12960 
12962  CXXDestructorDecl *Destructor) {
12963  assert((Destructor->isDefaulted() &&
12964  !Destructor->doesThisDeclarationHaveABody() &&
12965  !Destructor->isDeleted()) &&
12966  "DefineImplicitDestructor - call it for implicit default dtor");
12967  if (Destructor->willHaveBody() || Destructor->isInvalidDecl())
12968  return;
12969 
12970  CXXRecordDecl *ClassDecl = Destructor->getParent();
12971  assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
12972 
12973  SynthesizedFunctionScope Scope(*this, Destructor);
12974 
12975  // The exception specification is needed because we are defining the
12976  // function.
12977  ResolveExceptionSpec(CurrentLocation,
12978  Destructor->getType()->castAs<FunctionProtoType>());
12979  MarkVTableUsed(CurrentLocation, ClassDecl);
12980 
12981  // Add a context note for diagnostics produced after this point.
12982  Scope.addContextNote(CurrentLocation);
12983 
12984  MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
12985  Destructor->getParent());
12986 
12987  if (CheckDestructor(Destructor)) {
12988  Destructor->setInvalidDecl();
12989  return;
12990  }
12991 
12992  SourceLocation Loc = Destructor->getEndLoc().isValid()
12993  ? Destructor->getEndLoc()
12994  : Destructor->getLocation();
12995  Destructor->setBody(new (Context) CompoundStmt(Loc));
12996  Destructor->markUsed(Context);
12997 
12998  if (ASTMutationListener *L = getASTMutationListener()) {
12999  L->CompletedImplicitDefinition(Destructor);
13000  }
13001 }
13002 
13003 /// Perform any semantic analysis which needs to be delayed until all
13004 /// pending class member declarations have been parsed.
13006  // If the context is an invalid C++ class, just suppress these checks.
13007  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(CurContext)) {
13008  if (Record->isInvalidDecl()) {
13009  DelayedOverridingExceptionSpecChecks.clear();
13010  DelayedEquivalentExceptionSpecChecks.clear();
13011  return;
13012  }
13014  }
13015 }
13016 
13018  referenceDLLExportedClassMethods();
13019 
13020  if (!DelayedDllExportMemberFunctions.empty()) {
13022  std::swap(DelayedDllExportMemberFunctions, WorkList);
13023  for (CXXMethodDecl *M : WorkList) {
13024  DefineImplicitSpecialMember(*this, M, M->getLocation());
13025 
13026  // Pass the method to the consumer to get emitted. This is not necessary
13027  // for explicit instantiation definitions, as they will get emitted
13028  // anyway.
13029  if (M->getParent()->getTemplateSpecializationKind() !=
13031  ActOnFinishInlineFunctionDef(M);
13032  }
13033  }
13034 }
13035 
13037  if (!DelayedDllExportClasses.empty()) {
13038  // Calling ReferenceDllExportedMembers might cause the current function to
13039  // be called again, so use a local copy of DelayedDllExportClasses.
13041  std::swap(DelayedDllExportClasses, WorkList);
13042  for (CXXRecordDecl *Class : WorkList)
13043  ReferenceDllExportedMembers(*this, Class);
13044  }
13045 }
13046 
13048  assert(getLangOpts().CPlusPlus11 &&
13049  "adjusting dtor exception specs was introduced in c++11");
13050 
13051  if (Destructor->isDependentContext())
13052  return;
13053 
13054  // C++11 [class.dtor]p3:
13055  // A declaration of a destructor that does not have an exception-
13056  // specification is implicitly considered to have the same exception-
13057  // specification as an implicit declaration.
13058  const auto *DtorType = Destructor->getType()->castAs<FunctionProtoType>();
13059  if (DtorType->hasExceptionSpec())
13060  return;
13061 
13062  // Replace the destructor's type, building off the existing one. Fortunately,
13063  // the only thing of interest in the destructor type is its extended info.
13064  // The return and arguments are fixed.
13065  FunctionProtoType::ExtProtoInfo EPI = DtorType->getExtProtoInfo();
13067  EPI.ExceptionSpec.SourceDecl = Destructor;
13068  Destructor->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
13069 
13070  // FIXME: If the destructor has a body that could throw, and the newly created
13071  // spec doesn't allow exceptions, we should emit a warning, because this
13072  // change in behavior can break conforming C++03 programs at runtime.
13073  // However, we don't have a body or an exception specification yet, so it
13074  // needs to be done somewhere else.
13075 }
13076 
13077 namespace {
13078 /// An abstract base class for all helper classes used in building the
13079 // copy/move operators. These classes serve as factory functions and help us
13080 // avoid using the same Expr* in the AST twice.
13081 class ExprBuilder {
13082  ExprBuilder(const ExprBuilder&) = delete;
13083  ExprBuilder &operator=(const ExprBuilder&) = delete;
13084 
13085 protected:
13086  static Expr *assertNotNull(Expr *E) {
13087  assert(E && "Expression construction must not fail.");
13088  return E;
13089  }
13090 
13091 public:
13092  ExprBuilder() {}
13093  virtual ~ExprBuilder() {}
13094 
13095  virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
13096 };
13097 
13098 class RefBuilder: public ExprBuilder {
13099  VarDecl *Var;
13100  QualType VarType;
13101 
13102 public:
13103  Expr *build(Sema &S, SourceLocation Loc) const override {
13104  return assertNotNull(S.BuildDeclRefExpr(Var, VarType, VK_LValue, Loc));
13105  }
13106 
13107  RefBuilder(VarDecl *Var, QualType VarType)
13108  : Var(Var), VarType(VarType) {}
13109 };
13110 
13111 class ThisBuilder: public ExprBuilder {
13112 public:
13113  Expr *build(Sema &S, SourceLocation Loc) const override {
13114  return assertNotNull(S.ActOnCXXThis(Loc).getAs<Expr>());
13115  }
13116 };
13117 
13118 class CastBuilder: public ExprBuilder {
13119  const ExprBuilder &Builder;
13120  QualType Type;
13122  const CXXCastPath &Path;
13123 
13124 public:
13125  Expr *build(Sema &S, SourceLocation Loc) const override {
13126  return assertNotNull(S.ImpCastExprToType(Builder.build(S, Loc), Type,
13127  CK_UncheckedDerivedToBase, Kind,
13128  &Path).get());
13129  }
13130 
13131  CastBuilder(const ExprBuilder &Builder, QualType Type, ExprValueKind Kind,
13132  const CXXCastPath &Path)
13133  : Builder(Builder), Type(Type), Kind(Kind), Path(Path) {}
13134 };
13135 
13136 class DerefBuilder: public ExprBuilder {
13137  const ExprBuilder &Builder;
13138 
13139 public:
13140  Expr *build(Sema &S, SourceLocation Loc) const override {
13141  return assertNotNull(
13142  S.CreateBuiltinUnaryOp(Loc, UO_Deref, Builder.build(S, Loc)).get());
13143  }
13144 
13145  DerefBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
13146 };
13147 
13148 class MemberBuilder: public ExprBuilder {
13149  const ExprBuilder &Builder;
13150  QualType Type;
13151  CXXScopeSpec SS;
13152  bool IsArrow;
13153  LookupResult &MemberLookup;
13154 
13155 public:
13156  Expr *build(Sema &S, SourceLocation Loc) const override {
13157  return assertNotNull(S.BuildMemberReferenceExpr(
13158  Builder.build(S, Loc), Type, Loc, IsArrow, SS, SourceLocation(),
13159  nullptr, MemberLookup, nullptr, nullptr).get());
13160  }
13161 
13162  MemberBuilder(const ExprBuilder &Builder, QualType Type, bool IsArrow,
13163  LookupResult &MemberLookup)
13164  : Builder(Builder), Type(Type), IsArrow(IsArrow),
13165  MemberLookup(MemberLookup) {}
13166 };
13167 
13168 class MoveCastBuilder: public ExprBuilder {
13169  const ExprBuilder &Builder;
13170 
13171 public:
13172  Expr *build(Sema &S, SourceLocation Loc) const override {
13173  return assertNotNull(CastForMoving(S, Builder.build(S, Loc)));
13174  }
13175 
13176  MoveCastBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
13177 };
13178 
13179 class LvalueConvBuilder: public ExprBuilder {
13180  const ExprBuilder &Builder;
13181 
13182 public:
13183  Expr *build(Sema &S, SourceLocation Loc) const override {
13184  return assertNotNull(
13185  S.DefaultLvalueConversion(Builder.build(S, Loc)).get());
13186  }
13187 
13188  LvalueConvBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
13189 };
13190 
13191 class SubscriptBuilder: public ExprBuilder {
13192  const ExprBuilder &Base;
13193  const ExprBuilder &Index;
13194 
13195 public:
13196  Expr *build(Sema &S, SourceLocation Loc) const override {
13197  return assertNotNull(S.CreateBuiltinArraySubscriptExpr(
13198  Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).get());
13199  }
13200 
13201  SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index)
13202  : Base(Base), Index(Index) {}
13203 };
13204 
13205 } // end anonymous namespace
13206 
13207 /// When generating a defaulted copy or move assignment operator, if a field
13208 /// should be copied with __builtin_memcpy rather than via explicit assignments,
13209 /// do so. This optimization only applies for arrays of scalars, and for arrays
13210 /// of class type where the selected copy/move-assignment operator is trivial.
13211 static StmtResult
13213  const ExprBuilder &ToB, const ExprBuilder &FromB) {
13214  // Compute the size of the memory buffer to be copied.
13215  QualType SizeType = S.Context.getSizeType();
13216  llvm::APInt Size(S.Context.getTypeSize(SizeType),
13218 
13219  // Take the address of the field references for "from" and "to". We
13220  // directly construct UnaryOperators here because semantic analysis
13221  // does not permit us to take the address of an xvalue.
13222  Expr *From = FromB.build(S, Loc);
13223  From = new (S.Context) UnaryOperator(From, UO_AddrOf,
13224  S.Context.getPointerType(From->getType()),
13225  VK_RValue, OK_Ordinary, Loc, false);
13226  Expr *To = ToB.build(S, Loc);
13227  To = new (S.Context) UnaryOperator(To, UO_AddrOf,
13228  S.Context.getPointerType(To->getType()),
13229  VK_RValue, OK_Ordinary, Loc, false);
13230 
13231  const Type *E = T->getBaseElementTypeUnsafe();
13232  bool NeedsCollectableMemCpy =
13233  E->isRecordType() &&
13234  E->castAs<RecordType>()->getDecl()->hasObjectMember();
13235 
13236  // Create a reference to the __builtin_objc_memmove_collectable function
13237  StringRef MemCpyName = NeedsCollectableMemCpy ?
13238  "__builtin_objc_memmove_collectable" :
13239  "__builtin_memcpy";
13240  LookupResult R(S, &S.Context.Idents.get(MemCpyName), Loc,
13242  S.LookupName(R, S.TUScope, true);
13243 
13244  FunctionDecl *MemCpy = R.getAsSingle<FunctionDecl>();
13245  if (!MemCpy)
13246  // Something went horribly wrong earlier, and we will have complained
13247  // about it.
13248  return StmtError();
13249 
13250  ExprResult MemCpyRef = S.BuildDeclRefExpr(MemCpy, S.Context.BuiltinFnTy,
13251  VK_RValue, Loc, nullptr);
13252  assert(MemCpyRef.isUsable() && "Builtin reference cannot fail");
13253 
13254  Expr *CallArgs[] = {
13255  To, From, IntegerLiteral::Create(S.Context, Size, SizeType, Loc)
13256  };
13257  ExprResult Call = S.BuildCallExpr(/*Scope=*/nullptr, MemCpyRef.get(),
13258  Loc, CallArgs, Loc);
13259 
13260  assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!");
13261  return Call.getAs<Stmt>();
13262 }
13263 
13264 /// Builds a statement that copies/moves the given entity from \p From to
13265 /// \c To.
13266 ///
13267 /// This routine is used to copy/move the members of a class with an
13268 /// implicitly-declared copy/move assignment operator. When the entities being
13269 /// copied are arrays, this routine builds for loops to copy them.
13270 ///
13271 /// \param S The Sema object used for type-checking.
13272 ///
13273 /// \param Loc The location where the implicit copy/move is being generated.
13274 ///
13275 /// \param T The type of the expressions being copied/moved. Both expressions
13276 /// must have this type.
13277 ///
13278 /// \param To The expression we are copying/moving to.
13279 ///
13280 /// \param From The expression we are copying/moving from.
13281 ///
13282 /// \param CopyingBaseSubobject Whether we're copying/moving a base subobject.
13283 /// Otherwise, it's a non-static member subobject.
13284 ///
13285 /// \param Copying Whether we're copying or moving.
13286 ///
13287 /// \param Depth Internal parameter recording the depth of the recursion.
13288 ///
13289 /// \returns A statement or a loop that copies the expressions, or StmtResult(0)
13290 /// if a memcpy should be used instead.
13291 static StmtResult
13293  const ExprBuilder &To, const ExprBuilder &From,
13294  bool CopyingBaseSubobject, bool Copying,
13295  unsigned Depth = 0) {
13296  // C++11 [class.copy]p28:
13297  // Each subobject is assigned in the manner appropriate to its type:
13298  //
13299  // - if the subobject is of class type, as if by a call to operator= with
13300  // the subobject as the object expression and the corresponding
13301  // subobject of x as a single function argument (as if by explicit
13302  // qualification; that is, ignoring any possible virtual overriding
13303  // functions in more derived classes);
13304  //
13305  // C++03 [class.copy]p13:
13306  // - if the subobject is of class type, the copy assignment operator for
13307  // the class is used (as if by explicit qualification; that is,
13308  // ignoring any possible virtual overriding functions in more derived
13309  // classes);
13310  if (const RecordType *RecordTy = T->getAs<RecordType>()) {
13311  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
13312 
13313  // Look for operator=.
13314  DeclarationName Name
13316  LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName);
13317  S.LookupQualifiedName(OpLookup, ClassDecl, false);
13318 
13319  // Prior to C++11, filter out any result that isn't a copy/move-assignment
13320  // operator.
13321  if (!S.getLangOpts().CPlusPlus11) {
13322  LookupResult::Filter F = OpLookup.makeFilter();
13323  while (F.hasNext()) {
13324  NamedDecl *D = F.next();
13325  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
13326  if (Method->isCopyAssignmentOperator() ||
13327  (!Copying && Method->isMoveAssignmentOperator()))
13328  continue;
13329 
13330  F.erase();
13331  }
13332  F.done();
13333  }
13334 
13335  // Suppress the protected check (C++ [class.protected]) for each of the
13336  // assignment operators we found. This strange dance is required when
13337  // we're assigning via a base classes's copy-assignment operator. To
13338  // ensure that we're getting the right base class subobject (without
13339  // ambiguities), we need to cast "this" to that subobject type; to
13340  // ensure that we don't go through the virtual call mechanism, we need
13341  // to qualify the operator= name with the base class (see below). However,
13342  // this means that if the base class has a protected copy assignment
13343  // operator, the protected member access check will fail. So, we
13344  // rewrite "protected" access to "public" access in this case, since we
13345  // know by construction that we're calling from a derived class.
13346  if (CopyingBaseSubobject) {
13347  for (LookupResult::iterator L = OpLookup.begin(), LEnd = OpLookup.end();
13348  L != LEnd; ++L) {
13349  if (L.getAccess() == AS_protected)
13350  L.setAccess(AS_public);
13351  }
13352  }
13353 
13354  // Create the nested-name-specifier that will be used to qualify the
13355  // reference to operator=; this is required to suppress the virtual
13356  // call mechanism.
13357  CXXScopeSpec SS;
13358  const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
13359  SS.MakeTrivial(S.Context,
13360  NestedNameSpecifier::Create(S.Context, nullptr, false,
13361  CanonicalT),
13362  Loc);
13363 
13364  // Create the reference to operator=.
13365  ExprResult OpEqualRef
13366  = S.BuildMemberReferenceExpr(To.build(S, Loc), T, Loc, /*IsArrow=*/false,
13367  SS, /*TemplateKWLoc=*/SourceLocation(),
13368  /*FirstQualifierInScope=*/nullptr,
13369  OpLookup,
13370  /*TemplateArgs=*/nullptr, /*S*/nullptr,
13371  /*SuppressQualifierCheck=*/true);
13372  if (OpEqualRef.isInvalid())
13373  return StmtError();
13374 
13375  // Build the call to the assignment operator.
13376 
13377  Expr *FromInst = From.build(S, Loc);
13378  ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/nullptr,
13379  OpEqualRef.getAs<Expr>(),
13380  Loc, FromInst, Loc);
13381  if (Call.isInvalid())
13382  return StmtError();
13383 
13384  // If we built a call to a trivial 'operator=' while copying an array,
13385  // bail out. We'll replace the whole shebang with a memcpy.
13386  CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(Call.get());
13387  if (CE && CE->getMethodDecl()->isTrivial() && Depth)
13388  return StmtResult((Stmt*)nullptr);
13389 
13390  // Convert to an expression-statement, and clean up any produced
13391  // temporaries.
13392  return S.ActOnExprStmt(Call);
13393  }
13394 
13395  // - if the subobject is of scalar type, the built-in assignment
13396  // operator is used.
13397  const ConstantArrayType *ArrayTy = S.Context.getAsConstantArrayType(T);
13398  if (!ArrayTy) {
13400  Loc, BO_Assign, To.build(S, Loc), From.build(S, Loc));
13401  if (Assignment.isInvalid())
13402  return StmtError();
13403  return S.ActOnExprStmt(Assignment);
13404  }
13405 
13406  // - if the subobject is an array, each element is assigned, in the
13407  // manner appropriate to the element type;
13408 
13409  // Construct a loop over the array bounds, e.g.,
13410  //
13411  // for (__SIZE_TYPE__ i0 = 0; i0 != array-size; ++i0)
13412  //
13413  // that will copy each of the array elements.
13414  QualType SizeType = S.Context.getSizeType();
13415 
13416  // Create the iteration variable.
13417  IdentifierInfo *IterationVarName = nullptr;
13418  {
13419  SmallString<8> Str;
13420  llvm::raw_svector_ostream OS(Str);
13421  OS << "__i" << Depth;
13422  IterationVarName = &S.Context.Idents.get(OS.str());
13423  }
13424  VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
13425  IterationVarName, SizeType,
13426  S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
13427  SC_None);
13428 
13429  // Initialize the iteration variable to zero.
13430  llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
13431  IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
13432 
13433  // Creates a reference to the iteration variable.
13434  RefBuilder IterationVarRef(IterationVar, SizeType);
13435  LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
13436 
13437  // Create the DeclStmt that holds the iteration variable.
13438  Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);
13439 
13440  // Subscript the "from" and "to" expressions with the iteration variable.
13441  SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
13442  MoveCastBuilder FromIndexMove(FromIndexCopy);
13443  const ExprBuilder *FromIndex;
13444  if (Copying)
13445  FromIndex = &FromIndexCopy;
13446  else
13447  FromIndex = &FromIndexMove;
13448 
13449  SubscriptBuilder ToIndex(To, IterationVarRefRVal);
13450 
13451  // Build the copy/move for an individual element of the array.
13452  StmtResult Copy =
13454  ToIndex, *FromIndex, CopyingBaseSubobject,
13455  Copying, Depth + 1);
13456  // Bail out if copying fails or if we determined that we should use memcpy.
13457  if (Copy.isInvalid() || !Copy.get())
13458  return Copy;
13459 
13460  // Create the comparison against the array bound.
13461  llvm::APInt Upper
13462  = ArrayTy->getSize().zextOrTrunc(S.Context.getTypeSize(SizeType));
13463  Expr *Comparison
13464  = new (S.Context) BinaryOperator(IterationVarRefRVal.build(S, Loc),
13465  IntegerLiteral::Create(S.Context, Upper, SizeType, Loc),
13466  BO_NE, S.Context.BoolTy,
13467  VK_RValue, OK_Ordinary, Loc, FPOptions());
13468 
13469  // Create the pre-increment of the iteration variable. We can determine
13470  // whether the increment will overflow based on the value of the array
13471  // bound.
13472  Expr *Increment = new (S.Context)
13473  UnaryOperator(IterationVarRef.build(S, Loc), UO_PreInc, SizeType,
13474  VK_LValue, OK_Ordinary, Loc, Upper.isMaxValue());
13475 
13476  // Construct the loop that copies all elements of this array.
13477  return S.ActOnForStmt(
13478  Loc, Loc, InitStmt,
13479  S.ActOnCondition(nullptr, Loc, Comparison, Sema::ConditionKind::Boolean),
13480  S.MakeFullDiscardedValueExpr(Increment), Loc, Copy.get());
13481 }
13482 
13483 static StmtResult
13485  const ExprBuilder &To, const ExprBuilder &From,
13486  bool CopyingBaseSubobject, bool Copying) {
13487  // Maybe we should use a memcpy?
13488  if (T->isArrayType() && !T.isConstQualified() && !T.isVolatileQualified() &&
13490  return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
13491 
13493  CopyingBaseSubobject,
13494  Copying, 0));
13495 
13496  // If we ended up picking a trivial assignment operator for an array of a
13497  // non-trivially-copyable class type, just emit a memcpy.
13498  if (!Result.isInvalid() && !Result.get())
13499  return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
13500 
13501  return Result;
13502 }
13503 
13505  // Note: The following rules are largely analoguous to the copy
13506  // constructor rules. Note that virtual bases are not taken into account
13507  // for determining the argument type of the operator. Note also that
13508  // operators taking an object instead of a reference are allowed.
13509  assert(ClassDecl->needsImplicitCopyAssignment());
13510 
13511  DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyAssignment);
13512  if (DSM.isAlreadyBeingDeclared())
13513  return nullptr;
13514 
13515  QualType ArgType = Context.getTypeDeclType(ClassDecl);
13516  LangAS AS = getDefaultCXXMethodAddrSpace();
13517  if (AS != LangAS::Default)
13518  ArgType = Context.getAddrSpaceQualType(ArgType, AS);
13519  QualType RetType = Context.getLValueReferenceType(ArgType);
13520  bool Const = ClassDecl->implicitCopyAssignmentHasConstParam();
13521  if (Const)
13522  ArgType = ArgType.withConst();
13523 
13524  ArgType = Context.getLValueReferenceType(ArgType);
13525 
13526  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
13527  CXXCopyAssignment,
13528  Const);
13529 
13530  // An implicitly-declared copy assignment operator is an inline public
13531  // member of its class.
13532  DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
13533  SourceLocation ClassLoc = ClassDecl->getLocation();
13534  DeclarationNameInfo NameInfo(Name, ClassLoc);
13535  CXXMethodDecl *CopyAssignment = CXXMethodDecl::Create(
13536  Context, ClassDecl, ClassLoc, NameInfo, QualType(),
13537  /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
13538  /*isInline=*/true, Constexpr ? CSK_constexpr : CSK_unspecified,
13539  SourceLocation());
13540  CopyAssignment->setAccess(AS_public);
13541  CopyAssignment->setDefaulted();
13542  CopyAssignment->setImplicit();
13543 
13544  if (getLangOpts().CUDA) {
13545  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyAssignment,
13546  CopyAssignment,
13547  /* ConstRHS */ Const,
13548  /* Diagnose */ false);
13549  }
13550 
13551  setupImplicitSpecialMemberType(CopyAssignment, RetType, ArgType);
13552 
13553  // Add the parameter to the operator.
13554  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
13555  ClassLoc, ClassLoc,
13556  /*Id=*/nullptr, ArgType,
13557  /*TInfo=*/nullptr, SC_None,
13558  nullptr);
13559  CopyAssignment->setParams(FromParam);
13560 
13561  CopyAssignment->setTrivial(
13563  ? SpecialMemberIsTrivial(CopyAssignment, CXXCopyAssignment)
13564  : ClassDecl->hasTrivialCopyAssignment());
13565 
13566  // Note that we have added this copy-assignment operator.
13567  ++getASTContext().NumImplicitCopyAssignmentOperatorsDeclared;
13568 
13569  Scope *S = getScopeForContext(ClassDecl);
13570  CheckImplicitSpecialMemberDeclaration(S, CopyAssignment);
13571 
13572  if (ShouldDeleteSpecialMember(CopyAssignment, CXXCopyAssignment))
13573  SetDeclDeleted(CopyAssignment, ClassLoc);
13574 
13575  if (S)
13576  PushOnScopeChains(CopyAssignment, S, false);
13577  ClassDecl->addDecl(CopyAssignment);
13578 
13579  return CopyAssignment;
13580 }
13581 
13582 /// Diagnose an implicit copy operation for a class which is odr-used, but
13583 /// which is deprecated because the class has a user-declared copy constructor,
13584 /// copy assignment operator, or destructor.
13586  assert(CopyOp->isImplicit());
13587 
13588  CXXRecordDecl *RD = CopyOp->getParent();
13589  CXXMethodDecl *UserDeclaredOperation = nullptr;
13590 
13591  // In Microsoft mode, assignment operations don't affect constructors and
13592  // vice versa.
13593  if (RD->hasUserDeclaredDestructor()) {
13594  UserDeclaredOperation = RD->getDestructor();
13595  } else if (!isa<CXXConstructorDecl>(CopyOp) &&
13596  RD->hasUserDeclaredCopyConstructor() &&
13597  !S.getLangOpts().MSVCCompat) {
13598  // Find any user-declared copy constructor.
13599  for (auto *I : RD->ctors()) {
13600  if (I->isCopyConstructor()) {
13601  UserDeclaredOperation = I;
13602  break;
13603  }
13604  }
13605  assert(UserDeclaredOperation);
13606  } else if (isa<CXXConstructorDecl>(CopyOp) &&
13607  RD->hasUserDeclaredCopyAssignment() &&
13608  !S.getLangOpts().MSVCCompat) {
13609  // Find any user-declared move assignment operator.
13610  for (auto *I : RD->methods()) {
13611  if (I->isCopyAssignmentOperator()) {
13612  UserDeclaredOperation = I;
13613  break;
13614  }
13615  }
13616  assert(UserDeclaredOperation);
13617  }
13618 
13619  if (UserDeclaredOperation && UserDeclaredOperation->isUserProvided()) {
13620  S.Diag(UserDeclaredOperation->getLocation(),
13621  isa<CXXDestructorDecl>(UserDeclaredOperation)
13622  ? diag::warn_deprecated_copy_dtor_operation
13623  : diag::warn_deprecated_copy_operation)
13624  << RD << /*copy assignment*/ !isa<CXXConstructorDecl>(CopyOp);
13625  }
13626 }
13627 
13629  CXXMethodDecl *CopyAssignOperator) {
13630  assert((CopyAssignOperator->isDefaulted() &&
13631  CopyAssignOperator->isOverloadedOperator() &&
13632  CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
13633  !CopyAssignOperator->doesThisDeclarationHaveABody() &&
13634  !CopyAssignOperator->isDeleted()) &&
13635  "DefineImplicitCopyAssignment called for wrong function");
13636  if (CopyAssignOperator->willHaveBody() || CopyAssignOperator->isInvalidDecl())
13637  return;
13638 
13639  CXXRecordDecl *ClassDecl = CopyAssignOperator->getParent();
13640  if (ClassDecl->isInvalidDecl()) {
13641  CopyAssignOperator->setInvalidDecl();
13642  return;
13643  }
13644 
13645  SynthesizedFunctionScope Scope(*this, CopyAssignOperator);
13646 
13647  // The exception specification is needed because we are defining the
13648  // function.
13649  ResolveExceptionSpec(CurrentLocation,
13650  CopyAssignOperator->getType()->castAs<FunctionProtoType>());
13651 
13652  // Add a context note for diagnostics produced after this point.
13653  Scope.addContextNote(CurrentLocation);
13654 
13655  // C++11 [class.copy]p18:
13656  // The [definition of an implicitly declared copy assignment operator] is
13657  // deprecated if the class has a user-declared copy constructor or a
13658  // user-declared destructor.
13659  if (getLangOpts().CPlusPlus11 && CopyAssignOperator->isImplicit())
13660  diagnoseDeprecatedCopyOperation(*this, CopyAssignOperator);
13661 
13662  // C++0x [class.copy]p30:
13663  // The implicitly-defined or explicitly-defaulted copy assignment operator
13664  // for a non-union class X performs memberwise copy assignment of its
13665  // subobjects. The direct base classes of X are assigned first, in the
13666  // order of their declaration in the base-specifier-list, and then the
13667  // immediate non-static data members of X are assigned, in the order in
13668  // which they were declared in the class definition.
13669 
13670  // The statements that form the synthesized function body.
13671  SmallVector<Stmt*, 8> Statements;
13672 
13673  // The parameter for the "other" object, which we are copying from.
13674  ParmVarDecl *Other = CopyAssignOperator->getParamDecl(0);
13675  Qualifiers OtherQuals = Other->getType().getQualifiers();
13676  QualType OtherRefType = Other->getType();
13677  if (const LValueReferenceType *OtherRef
13678  = OtherRefType->getAs<LValueReferenceType>()) {
13679  OtherRefType = OtherRef->getPointeeType();
13680  OtherQuals = OtherRefType.getQualifiers();
13681  }
13682 
13683  // Our location for everything implicitly-generated.
13684  SourceLocation Loc = CopyAssignOperator->getEndLoc().isValid()
13685  ? CopyAssignOperator->getEndLoc()
13686  : CopyAssignOperator->getLocation();
13687 
13688  // Builds a DeclRefExpr for the "other" object.
13689  RefBuilder OtherRef(Other, OtherRefType);
13690 
13691  // Builds the "this" pointer.
13692  ThisBuilder This;
13693 
13694  // Assign base classes.
13695  bool Invalid = false;
13696  for (auto &Base : ClassDecl->bases()) {
13697  // Form the assignment:
13698  // static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other));
13699  QualType BaseType = Base.getType().getUnqualifiedType();
13700  if (!BaseType->isRecordType()) {
13701  Invalid = true;
13702  continue;
13703  }
13704 
13705  CXXCastPath BasePath;
13706  BasePath.push_back(&Base);
13707 
13708  // Construct the "from" expression, which is an implicit cast to the
13709  // appropriately-qualified base type.
13710  CastBuilder From(OtherRef, Context.getQualifiedType(BaseType, OtherQuals),
13711  VK_LValue, BasePath);
13712 
13713  // Dereference "this".
13714  DerefBuilder DerefThis(This);
13715  CastBuilder To(DerefThis,
13716  Context.getQualifiedType(
13717  BaseType, CopyAssignOperator->getMethodQualifiers()),
13718  VK_LValue, BasePath);
13719 
13720  // Build the copy.
13721  StmtResult Copy = buildSingleCopyAssign(*this, Loc, BaseType,
13722  To, From,
13723  /*CopyingBaseSubobject=*/true,
13724  /*Copying=*/true);
13725  if (Copy.isInvalid()) {
13726  CopyAssignOperator->setInvalidDecl();
13727  return;
13728  }
13729 
13730  // Success! Record the copy.
13731  Statements.push_back(Copy.getAs<Expr>());
13732  }
13733 
13734  // Assign non-static members.
13735  for (auto *Field : ClassDecl->fields()) {
13736  // FIXME: We should form some kind of AST representation for the implied
13737  // memcpy in a union copy operation.
13738  if (Field->isUnnamedBitfield() || Field->getParent()->isUnion())
13739  continue;
13740 
13741  if (Field->isInvalidDecl()) {
13742  Invalid = true;
13743  continue;
13744  }
13745 
13746  // Check for members of reference type; we can't copy those.
13747  if (Field->getType()->isReferenceType()) {
13748  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
13749  << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
13750  Diag(Field->getLocation(), diag::note_declared_at);
13751  Invalid = true;
13752  continue;
13753  }
13754 
13755  // Check for members of const-qualified, non-class type.
13756  QualType BaseType = Context.getBaseElementType(Field->getType());
13757  if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
13758  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
13759  << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
13760  Diag(Field->getLocation(), diag::note_declared_at);
13761  Invalid = true;
13762  continue;
13763  }
13764 
13765  // Suppress assigning zero-width bitfields.
13766  if (Field->isZeroLengthBitField(Context))
13767  continue;
13768 
13769  QualType FieldType = Field->getType().getNonReferenceType();
13770  if (FieldType->isIncompleteArrayType()) {
13771  assert(ClassDecl->hasFlexibleArrayMember() &&
13772  "Incomplete array type is not valid");
13773  continue;
13774  }
13775 
13776  // Build references to the field in the object we're copying from and to.
13777  CXXScopeSpec SS; // Intentionally empty
13778  LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
13779  LookupMemberName);
13780  MemberLookup.addDecl(Field);
13781  MemberLookup.resolveKind();
13782 
13783  MemberBuilder From(OtherRef, OtherRefType, /*IsArrow=*/false, MemberLookup);
13784 
13785  MemberBuilder To(This, getCurrentThisType(), /*IsArrow=*/true, MemberLookup);
13786 
13787  // Build the copy of this field.
13788  StmtResult Copy = buildSingleCopyAssign(*this, Loc, FieldType,
13789  To, From,
13790  /*CopyingBaseSubobject=*/false,
13791  /*Copying=*/true);
13792  if (Copy.isInvalid()) {
13793  CopyAssignOperator->setInvalidDecl();
13794  return;
13795  }
13796 
13797  // Success! Record the copy.
13798  Statements.push_back(Copy.getAs<Stmt>());
13799  }
13800 
13801  if (!Invalid) {
13802  // Add a "return *this;"
13803  ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
13804 
13805  StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
13806  if (Return.isInvalid())
13807  Invalid = true;
13808  else
13809  Statements.push_back(Return.getAs<Stmt>());
13810  }
13811 
13812  if (Invalid) {
13813  CopyAssignOperator->setInvalidDecl();
13814  return;
13815  }
13816 
13817  StmtResult Body;
13818  {
13819  CompoundScopeRAII CompoundScope(*this);
13820  Body = ActOnCompoundStmt(Loc, Loc, Statements,
13821  /*isStmtExpr=*/false);
13822  assert(!Body.isInvalid() && "Compound statement creation cannot fail");
13823  }
13824  CopyAssignOperator->setBody(Body.getAs<Stmt>());
13825  CopyAssignOperator->markUsed(Context);
13826 
13827  if (ASTMutationListener *L = getASTMutationListener()) {
13828  L->CompletedImplicitDefinition(CopyAssignOperator);
13829  }
13830 }
13831 
13833  assert(ClassDecl->needsImplicitMoveAssignment());
13834 
13835  DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveAssignment);
13836  if (DSM.isAlreadyBeingDeclared())
13837  return nullptr;
13838 
13839  // Note: The following rules are largely analoguous to the move
13840  // constructor rules.
13841 
13842  QualType ArgType = Context.getTypeDeclType(ClassDecl);
13843  LangAS AS = getDefaultCXXMethodAddrSpace();
13844  if (AS != LangAS::Default)
13845  ArgType = Context.getAddrSpaceQualType(ArgType, AS);
13846  QualType RetType = Context.getLValueReferenceType(ArgType);
13847  ArgType = Context.getRValueReferenceType(ArgType);
13848 
13849  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
13850  CXXMoveAssignment,
13851  false);
13852 
13853  // An implicitly-declared move assignment operator is an inline public
13854  // member of its class.
13855  DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
13856  SourceLocation ClassLoc = ClassDecl->getLocation();
13857  DeclarationNameInfo NameInfo(Name, ClassLoc);
13858  CXXMethodDecl *MoveAssignment = CXXMethodDecl::Create(
13859  Context, ClassDecl, ClassLoc, NameInfo, QualType(),
13860  /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
13861  /*isInline=*/true, Constexpr ? CSK_constexpr : CSK_unspecified,
13862  SourceLocation());
13863  MoveAssignment->setAccess(AS_public);
13864  MoveAssignment->setDefaulted();
13865  MoveAssignment->setImplicit();
13866 
13867  if (getLangOpts().CUDA) {
13868  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveAssignment,
13869  MoveAssignment,
13870  /* ConstRHS */ false,
13871  /* Diagnose */ false);
13872  }
13873 
13874  // Build an exception specification pointing back at this member.
13876  getImplicitMethodEPI(*this, MoveAssignment);
13877  MoveAssignment->setType(Context.getFunctionType(RetType, ArgType, EPI));
13878 
13879  // Add the parameter to the operator.
13880  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveAssignment,
13881  ClassLoc, ClassLoc,
13882  /*Id=*/nullptr, ArgType,
13883  /*TInfo=*/nullptr, SC_None,
13884  nullptr);
13885  MoveAssignment->setParams(FromParam);
13886 
13887  MoveAssignment->setTrivial(
13889  ? SpecialMemberIsTrivial(MoveAssignment, CXXMoveAssignment)
13890  : ClassDecl->hasTrivialMoveAssignment());
13891 
13892  // Note that we have added this copy-assignment operator.
13893  ++getASTContext().NumImplicitMoveAssignmentOperatorsDeclared;
13894 
13895  Scope *S = getScopeForContext(ClassDecl);
13896  CheckImplicitSpecialMemberDeclaration(S, MoveAssignment);
13897 
13898  if (ShouldDeleteSpecialMember(MoveAssignment, CXXMoveAssignment)) {
13900  SetDeclDeleted(MoveAssignment, ClassLoc);
13901  }
13902 
13903  if (S)
13904  PushOnScopeChains(MoveAssignment, S, false);
13905  ClassDecl->addDecl(MoveAssignment);
13906 
13907  return MoveAssignment;
13908 }
13909 
13910 /// Check if we're implicitly defining a move assignment operator for a class
13911 /// with virtual bases. Such a move assignment might move-assign the virtual
13912 /// base multiple times.
13914  SourceLocation CurrentLocation) {
13915  assert(!Class->isDependentContext() && "should not define dependent move");
13916 
13917  // Only a virtual base could get implicitly move-assigned multiple times.
13918  // Only a non-trivial move assignment can observe this. We only want to
13919  // diagnose if we implicitly define an assignment operator that assigns
13920  // two base classes, both of which move-assign the same virtual base.
13921  if (Class->getNumVBases() == 0 || Class->hasTrivialMoveAssignment() ||
13922  Class->getNumBases() < 2)
13923  return;
13924 
13926  typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
13927  VBaseMap VBases;
13928 
13929  for (auto &BI : Class->bases()) {
13930  Worklist.push_back(&BI);
13931  while (!Worklist.empty()) {
13932  CXXBaseSpecifier *BaseSpec = Worklist.pop_back_val();
13933  CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
13934 
13935  // If the base has no non-trivial move assignment operators,
13936  // we don't care about moves from it.
13937  if (!Base->hasNonTrivialMoveAssignment())
13938  continue;
13939 
13940  // If there's nothing virtual here, skip it.
13941  if (!BaseSpec->isVirtual() && !Base->getNumVBases())
13942  continue;
13943 
13944  // If we're not actually going to call a move assignment for this base,
13945  // or the selected move assignment is trivial, skip it.
13948  /*ConstArg*/false, /*VolatileArg*/false,
13949  /*RValueThis*/true, /*ConstThis*/false,
13950  /*VolatileThis*/false);
13951  if (!SMOR.getMethod() || SMOR.getMethod()->isTrivial() ||
13953  continue;
13954 
13955  if (BaseSpec->isVirtual()) {
13956  // We're going to move-assign this virtual base, and its move
13957  // assignment operator is not trivial. If this can happen for
13958  // multiple distinct direct bases of Class, diagnose it. (If it
13959  // only happens in one base, we'll diagnose it when synthesizing
13960  // that base class's move assignment operator.)
13961  CXXBaseSpecifier *&Existing =
13962  VBases.insert(std::make_pair(Base->getCanonicalDecl(), &BI))
13963  .first->second;
13964  if (Existing && Existing != &BI) {
13965  S.Diag(CurrentLocation, diag::warn_vbase_moved_multiple_times)
13966  << Class << Base;
13967  S.Diag(Existing->getBeginLoc(), diag::note_vbase_moved_here)
13968  << (Base->getCanonicalDecl() ==
13969  Existing->getType()->getAsCXXRecordDecl()->getCanonicalDecl())
13970  << Base << Existing->getType() << Existing->getSourceRange();
13971  S.Diag(BI.getBeginLoc(), diag::note_vbase_moved_here)
13972  << (Base->getCanonicalDecl() ==
13973  BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
13974  << Base << BI.getType() << BaseSpec->getSourceRange();
13975 
13976  // Only diagnose each vbase once.
13977  Existing = nullptr;
13978  }
13979  } else {
13980  // Only walk over bases that have defaulted move assignment operators.
13981  // We assume that any user-provided move assignment operator handles
13982  // the multiple-moves-of-vbase case itself somehow.
13983  if (!SMOR.getMethod()->isDefaulted())
13984  continue;
13985 
13986  // We're going to move the base classes of Base. Add them to the list.
13987  for (auto &BI : Base->bases())
13988  Worklist.push_back(&BI);
13989  }
13990  }
13991  }
13992 }
13993 
13995  CXXMethodDecl *MoveAssignOperator) {
13996  assert((MoveAssignOperator->isDefaulted() &&
13997  MoveAssignOperator->isOverloadedOperator() &&
13998  MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
13999  !MoveAssignOperator->doesThisDeclarationHaveABody() &&
14000  !MoveAssignOperator->isDeleted()) &&
14001  "DefineImplicitMoveAssignment called for wrong function");
14002  if (MoveAssignOperator->willHaveBody() || MoveAssignOperator->isInvalidDecl())
14003  return;
14004 
14005  CXXRecordDecl *ClassDecl = MoveAssignOperator->getParent();
14006  if (ClassDecl->isInvalidDecl()) {
14007  MoveAssignOperator->setInvalidDecl();
14008  return;
14009  }
14010 
14011  // C++0x [class.copy]p28:
14012  // The implicitly-defined or move assignment operator for a non-union class
14013  // X performs memberwise move assignment of its subobjects. The direct base
14014  // classes of X are assigned first, in the order of their declaration in the
14015  // base-specifier-list, and then the immediate non-static data members of X
14016  // are assigned, in the order in which they were declared in the class
14017  // definition.
14018 
14019  // Issue a warning if our implicit move assignment operator will move
14020  // from a virtual base more than once.
14021  checkMoveAssignmentForRepeatedMove(*this, ClassDecl, CurrentLocation);
14022 
14023  SynthesizedFunctionScope Scope(*this, MoveAssignOperator);
14024 
14025  // The exception specification is needed because we are defining the
14026  // function.
14027  ResolveExceptionSpec(CurrentLocation,
14028  MoveAssignOperator->getType()->castAs<FunctionProtoType>());
14029 
14030  // Add a context note for diagnostics produced after this point.
14031  Scope.addContextNote(CurrentLocation);
14032 
14033  // The statements that form the synthesized function body.
14034  SmallVector<Stmt*, 8> Statements;
14035 
14036  // The parameter for the "other" object, which we are move from.
14037  ParmVarDecl *Other = MoveAssignOperator->getParamDecl(0);
14038  QualType OtherRefType =
14039  Other->getType()->castAs<RValueReferenceType>()->getPointeeType();
14040 
14041  // Our location for everything implicitly-generated.
14042  SourceLocation Loc = MoveAssignOperator->getEndLoc().isValid()
14043  ? MoveAssignOperator->getEndLoc()
14044  : MoveAssignOperator->getLocation();
14045 
14046  // Builds a reference to the "other" object.
14047  RefBuilder OtherRef(Other, OtherRefType);
14048  // Cast to rvalue.
14049  MoveCastBuilder MoveOther(OtherRef);
14050 
14051  // Builds the "this" pointer.
14052  ThisBuilder This;
14053 
14054  // Assign base classes.
14055  bool Invalid = false;
14056  for (auto &Base : ClassDecl->bases()) {
14057  // C++11 [class.copy]p28:
14058  // It is unspecified whether subobjects representing virtual base classes
14059  // are assigned more than once by the implicitly-defined copy assignment
14060  // operator.
14061  // FIXME: Do not assign to a vbase that will be assigned by some other base
14062  // class. For a move-assignment, this can result in the vbase being moved
14063  // multiple times.
14064 
14065  // Form the assignment:
14066  // static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other));
14067  QualType BaseType = Base.getType().getUnqualifiedType();
14068  if (!BaseType->isRecordType()) {
14069  Invalid = true;
14070  continue;
14071  }
14072 
14073  CXXCastPath BasePath;
14074  BasePath.push_back(&Base);
14075 
14076  // Construct the "from" expression, which is an implicit cast to the
14077  // appropriately-qualified base type.
14078  CastBuilder From(OtherRef, BaseType, VK_XValue, BasePath);
14079 
14080  // Dereference "this".
14081  DerefBuilder DerefThis(This);
14082 
14083  // Implicitly cast "this" to the appropriately-qualified base type.
14084  CastBuilder To(DerefThis,
14085  Context.getQualifiedType(
14086  BaseType, MoveAssignOperator->getMethodQualifiers()),
14087  VK_LValue, BasePath);
14088 
14089  // Build the move.
14090  StmtResult Move = buildSingleCopyAssign(*this, Loc, BaseType,
14091  To, From,
14092  /*CopyingBaseSubobject=*/true,
14093  /*Copying=*/false);
14094  if (Move.isInvalid()) {
14095  MoveAssignOperator->setInvalidDecl();
14096  return;
14097  }
14098 
14099  // Success! Record the move.
14100  Statements.push_back(Move.getAs<Expr>());
14101  }
14102 
14103  // Assign non-static members.
14104  for (auto *Field : ClassDecl->fields()) {
14105  // FIXME: We should form some kind of AST representation for the implied
14106  // memcpy in a union copy operation.
14107  if (Field->isUnnamedBitfield() || Field->getParent()->isUnion())
14108  continue;
14109 
14110  if (Field->isInvalidDecl()) {
14111  Invalid = true;
14112  continue;
14113  }
14114 
14115  // Check for members of reference type; we can't move those.
14116  if (Field->getType()->isReferenceType()) {
14117  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
14118  << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
14119  Diag(Field->getLocation(), diag::note_declared_at);
14120  Invalid = true;
14121  continue;
14122  }
14123 
14124  // Check for members of const-qualified, non-class type.
14125  QualType BaseType = Context.getBaseElementType(Field->getType());
14126  if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
14127  Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
14128  << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
14129  Diag(Field->getLocation(), diag::note_declared_at);
14130  Invalid = true;
14131  continue;
14132  }
14133 
14134  // Suppress assigning zero-width bitfields.
14135  if (Field->isZeroLengthBitField(Context))
14136  continue;
14137 
14138  QualType FieldType = Field->getType().getNonReferenceType();
14139  if (FieldType->isIncompleteArrayType()) {
14140  assert(ClassDecl->hasFlexibleArrayMember() &&
14141  "Incomplete array type is not valid");
14142  continue;
14143  }
14144 
14145  // Build references to the field in the object we're copying from and to.
14146  LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
14147  LookupMemberName);
14148  MemberLookup.addDecl(Field);
14149  MemberLookup.resolveKind();
14150  MemberBuilder From(MoveOther, OtherRefType,
14151  /*IsArrow=*/false, MemberLookup);
14152  MemberBuilder To(This, getCurrentThisType(),
14153  /*IsArrow=*/true, MemberLookup);
14154 
14155  assert(!From.build(*this, Loc)->isLValue() && // could be xvalue or prvalue
14156  "Member reference with rvalue base must be rvalue except for reference "
14157  "members, which aren't allowed for move assignment.");
14158 
14159  // Build the move of this field.
14160  StmtResult Move = buildSingleCopyAssign(*this, Loc, FieldType,
14161  To, From,
14162  /*CopyingBaseSubobject=*/false,
14163  /*Copying=*/false);
14164  if (Move.isInvalid()) {
14165  MoveAssignOperator->setInvalidDecl();
14166  return;
14167  }
14168 
14169  // Success! Record the copy.
14170  Statements.push_back(Move.getAs<Stmt>());
14171  }
14172 
14173  if (!Invalid) {
14174  // Add a "return *this;"
14175  ExprResult ThisObj =
14176  CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
14177 
14178  StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
14179  if (Return.isInvalid())
14180  Invalid = true;
14181  else
14182  Statements.push_back(Return.getAs<Stmt>());
14183  }
14184 
14185  if (Invalid) {
14186  MoveAssignOperator->setInvalidDecl();
14187  return;
14188  }
14189 
14190  StmtResult Body;
14191  {
14192  CompoundScopeRAII CompoundScope(*this);
14193  Body = ActOnCompoundStmt(Loc, Loc, Statements,
14194  /*isStmtExpr=*/false);
14195  assert(!Body.isInvalid() && "Compound statement creation cannot fail");
14196  }
14197  MoveAssignOperator->setBody(Body.getAs<Stmt>());
14198  MoveAssignOperator->markUsed(Context);
14199 
14200  if (ASTMutationListener *L = getASTMutationListener()) {
14201  L->CompletedImplicitDefinition(MoveAssignOperator);
14202  }
14203 }
14204 
14206  CXXRecordDecl *ClassDecl) {
14207  // C++ [class.copy]p4:
14208  // If the class definition does not explicitly declare a copy
14209  // constructor, one is declared implicitly.
14210  assert(ClassDecl->needsImplicitCopyConstructor());
14211 
14212  DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyConstructor);
14213  if (DSM.isAlreadyBeingDeclared())
14214  return nullptr;
14215 
14216  QualType ClassType = Context.getTypeDeclType(ClassDecl);
14217  QualType ArgType = ClassType;
14218  bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
14219  if (Const)
14220  ArgType = ArgType.withConst();
14221 
14222  LangAS AS = getDefaultCXXMethodAddrSpace();
14223  if (AS != LangAS::Default)
14224  ArgType = Context.getAddrSpaceQualType(ArgType, AS);
14225 
14226  ArgType = Context.getLValueReferenceType(ArgType);
14227 
14228  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
14229  CXXCopyConstructor,
14230  Const);
14231 
14232  DeclarationName Name
14234  Context.getCanonicalType(ClassType));
14235  SourceLocation ClassLoc = ClassDecl->getLocation();
14236  DeclarationNameInfo NameInfo(Name, ClassLoc);
14237 
14238  // An implicitly-declared copy constructor is an inline public
14239  // member of its class.
14241  Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
14243  /*isInline=*/true,
14244  /*isImplicitlyDeclared=*/true,
14245  Constexpr ? CSK_constexpr : CSK_unspecified);
14246  CopyConstructor->setAccess(AS_public);
14247  CopyConstructor->setDefaulted();
14248 
14249  if (getLangOpts().CUDA) {
14250  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyConstructor,
14251  CopyConstructor,
14252  /* ConstRHS */ Const,
14253  /* Diagnose */ false);
14254  }
14255 
14256  setupImplicitSpecialMemberType(CopyConstructor, Context.VoidTy, ArgType);
14257 
14258  // Add the parameter to the constructor.
14259  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
14260  ClassLoc, ClassLoc,
14261  /*IdentifierInfo=*/nullptr,
14262  ArgType, /*TInfo=*/nullptr,
14263  SC_None, nullptr);
14264  CopyConstructor->setParams(FromParam);
14265 
14266  CopyConstructor->setTrivial(
14268  ? SpecialMemberIsTrivial(CopyConstructor, CXXCopyConstructor)
14269  : ClassDecl->hasTrivialCopyConstructor());
14270 
14271  CopyConstructor->setTrivialForCall(
14272  ClassDecl->hasAttr<TrivialABIAttr>() ||
14274  ? SpecialMemberIsTrivial(CopyConstructor, CXXCopyConstructor,
14275  TAH_ConsiderTrivialABI)
14276  : ClassDecl->hasTrivialCopyConstructorForCall()));
14277 
14278  // Note that we have declared this constructor.
14279  ++getASTContext().NumImplicitCopyConstructorsDeclared;
14280 
14281  Scope *S = getScopeForContext(ClassDecl);
14282  CheckImplicitSpecialMemberDeclaration(S, CopyConstructor);
14283 
14284  if (ShouldDeleteSpecialMember(CopyConstructor, CXXCopyConstructor)) {
14286  SetDeclDeleted(CopyConstructor, ClassLoc);
14287  }
14288 
14289  if (S)
14290  PushOnScopeChains(CopyConstructor, S, false);
14291  ClassDecl->addDecl(CopyConstructor);
14292 
14293  return CopyConstructor;
14294 }
14295 
14297  CXXConstructorDecl *CopyConstructor) {
14298  assert((CopyConstructor->isDefaulted() &&
14299  CopyConstructor->isCopyConstructor() &&
14300  !CopyConstructor->doesThisDeclarationHaveABody() &&
14301  !CopyConstructor->isDeleted()) &&
14302  "DefineImplicitCopyConstructor - call it for implicit copy ctor");
14303  if (CopyConstructor->willHaveBody() || CopyConstructor->isInvalidDecl())
14304  return;
14305 
14306  CXXRecordDecl *ClassDecl = CopyConstructor->getParent();
14307  assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
14308 
14309  SynthesizedFunctionScope Scope(*this, CopyConstructor);
14310 
14311  // The exception specification is needed because we are defining the
14312  // function.
14313  ResolveExceptionSpec(CurrentLocation,
14314  CopyConstructor->getType()->castAs<FunctionProtoType>());
14315  MarkVTableUsed(CurrentLocation, ClassDecl);
14316 
14317  // Add a context note for diagnostics produced after this point.
14318  Scope.addContextNote(CurrentLocation);
14319 
14320  // C++11 [class.copy]p7:
14321  // The [definition of an implicitly declared copy constructor] is
14322  // deprecated if the class has a user-declared copy assignment operator
14323  // or a user-declared destructor.
14324  if (getLangOpts().CPlusPlus11 && CopyConstructor->isImplicit())
14325  diagnoseDeprecatedCopyOperation(*this, CopyConstructor);
14326 
14327  if (SetCtorInitializers(CopyConstructor, /*AnyErrors=*/false)) {
14328  CopyConstructor->setInvalidDecl();
14329  } else {
14330  SourceLocation Loc = CopyConstructor->getEndLoc().isValid()
14331  ? CopyConstructor->getEndLoc()
14332  : CopyConstructor->getLocation();
14333  Sema::CompoundScopeRAII CompoundScope(*this);
14334  CopyConstructor->setBody(
14335  ActOnCompoundStmt(Loc, Loc, None, /*isStmtExpr=*/false).getAs<Stmt>());
14336  CopyConstructor->markUsed(Context);
14337  }
14338 
14339  if (ASTMutationListener *L = getASTMutationListener()) {
14340  L->CompletedImplicitDefinition(CopyConstructor);
14341  }
14342 }
14343 
14345  CXXRecordDecl *ClassDecl) {
14346  assert(ClassDecl->needsImplicitMoveConstructor());
14347 
14348  DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveConstructor);
14349  if (DSM.isAlreadyBeingDeclared())
14350  return nullptr;
14351 
14352  QualType ClassType = Context.getTypeDeclType(ClassDecl);
14353 
14354  QualType ArgType = ClassType;
14355  LangAS AS = getDefaultCXXMethodAddrSpace();
14356  if (AS != LangAS::Default)
14357  ArgType = Context.getAddrSpaceQualType(ClassType, AS);
14358  ArgType = Context.getRValueReferenceType(ArgType);
14359 
14360  bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
14361  CXXMoveConstructor,
14362  false);
14363 
14364  DeclarationName Name
14366  Context.getCanonicalType(ClassType));
14367  SourceLocation ClassLoc = ClassDecl->getLocation();
14368  DeclarationNameInfo NameInfo(Name, ClassLoc);
14369 
14370  // C++11 [class.copy]p11:
14371  // An implicitly-declared copy/move constructor is an inline public
14372  // member of its class.
14374  Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
14376  /*isInline=*/true,
14377  /*isImplicitlyDeclared=*/true,
14378  Constexpr ? CSK_constexpr : CSK_unspecified);
14379  MoveConstructor->setAccess(AS_public);
14380  MoveConstructor->setDefaulted();
14381 
14382  if (getLangOpts().CUDA) {
14383  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveConstructor,
14384  MoveConstructor,
14385  /* ConstRHS */ false,
14386  /* Diagnose */ false);
14387  }
14388 
14389  setupImplicitSpecialMemberType(MoveConstructor, Context.VoidTy, ArgType);
14390 
14391  // Add the parameter to the constructor.
14392  ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveConstructor,
14393  ClassLoc, ClassLoc,
14394  /*IdentifierInfo=*/nullptr,
14395  ArgType, /*TInfo=*/nullptr,
14396  SC_None, nullptr);
14397  MoveConstructor->setParams(FromParam);
14398 
14399  MoveConstructor->setTrivial(
14401  ? SpecialMemberIsTrivial(MoveConstructor, CXXMoveConstructor)
14402  : ClassDecl->hasTrivialMoveConstructor());
14403 
14404  MoveConstructor->setTrivialForCall(
14405  ClassDecl->hasAttr<TrivialABIAttr>() ||
14407  ? SpecialMemberIsTrivial(MoveConstructor, CXXMoveConstructor,
14408  TAH_ConsiderTrivialABI)
14409  : ClassDecl->hasTrivialMoveConstructorForCall()));
14410 
14411  // Note that we have declared this constructor.
14412  ++getASTContext().NumImplicitMoveConstructorsDeclared;
14413 
14414  Scope *S = getScopeForContext(ClassDecl);
14415  CheckImplicitSpecialMemberDeclaration(S, MoveConstructor);
14416 
14417  if (ShouldDeleteSpecialMember(MoveConstructor, CXXMoveConstructor)) {
14419  SetDeclDeleted(MoveConstructor, ClassLoc);
14420  }
14421 
14422  if (S)
14423  PushOnScopeChains(MoveConstructor, S, false);
14424  ClassDecl->addDecl(MoveConstructor);
14425 
14426  return MoveConstructor;
14427 }
14428 
14430  CXXConstructorDecl *MoveConstructor) {
14431  assert((MoveConstructor->isDefaulted() &&
14432  MoveConstructor->isMoveConstructor() &&
14433  !MoveConstructor->doesThisDeclarationHaveABody() &&
14434  !MoveConstructor->isDeleted()) &&
14435  "DefineImplicitMoveConstructor - call it for implicit move ctor");
14436  if (MoveConstructor->willHaveBody() || MoveConstructor->isInvalidDecl())
14437  return;
14438 
14439  CXXRecordDecl *ClassDecl = MoveConstructor->getParent();
14440  assert(ClassDecl && "DefineImplicitMoveConstructor - invalid constructor");
14441 
14442  SynthesizedFunctionScope Scope(*this, MoveConstructor);
14443 
14444  // The exception specification is needed because we are defining the
14445  // function.
14446  ResolveExceptionSpec(CurrentLocation,
14447  MoveConstructor->getType()->castAs<FunctionProtoType>());
14448  MarkVTableUsed(CurrentLocation, ClassDecl);
14449 
14450  // Add a context note for diagnostics produced after this point.
14451  Scope.addContextNote(CurrentLocation);
14452 
14453  if (SetCtorInitializers(MoveConstructor, /*AnyErrors=*/false)) {
14454  MoveConstructor->setInvalidDecl();
14455  } else {
14456  SourceLocation Loc = MoveConstructor->getEndLoc().isValid()
14457  ? MoveConstructor->getEndLoc()
14458  : MoveConstructor->getLocation();
14459  Sema::CompoundScopeRAII CompoundScope(*this);
14460  MoveConstructor->setBody(ActOnCompoundStmt(
14461  Loc, Loc, None, /*isStmtExpr=*/ false).getAs<Stmt>());
14462  MoveConstructor->markUsed(Context);
14463  }
14464 
14465  if (ASTMutationListener *L = getASTMutationListener()) {
14466  L->CompletedImplicitDefinition(MoveConstructor);
14467  }
14468 }
14469 
14471  return FD->isDeleted() && FD->isDefaulted() && isa<CXXMethodDecl>(FD);
14472 }
14473 
14475  SourceLocation CurrentLocation,
14476  CXXConversionDecl *Conv) {
14477  SynthesizedFunctionScope Scope(*this, Conv);
14478  assert(!Conv->getReturnType()->isUndeducedType());
14479 
14480  CXXRecordDecl *Lambda = Conv->getParent();
14481  FunctionDecl *CallOp = Lambda->getLambdaCallOperator();
14482  FunctionDecl *Invoker = Lambda->getLambdaStaticInvoker();
14483 
14484  if (auto *TemplateArgs = Conv->getTemplateSpecializationArgs()) {
14485  CallOp = InstantiateFunctionDeclaration(
14486  CallOp->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
14487  if (!CallOp)
14488  return;
14489 
14490  Invoker = InstantiateFunctionDeclaration(
14491  Invoker->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
14492  if (!Invoker)
14493  return;
14494  }
14495 
14496  if (CallOp->isInvalidDecl())
14497  return;
14498 
14499  // Mark the call operator referenced (and add to pending instantiations
14500  // if necessary).
14501  // For both the conversion and static-invoker template specializations
14502  // we construct their body's in this function, so no need to add them
14503  // to the PendingInstantiations.
14504  MarkFunctionReferenced(CurrentLocation, CallOp);
14505 
14506  // Fill in the __invoke function with a dummy implementation. IR generation
14507  // will fill in the actual details. Update its type in case it contained
14508  // an 'auto'.
14509  Invoker->markUsed(Context);
14510  Invoker->setReferenced();
14511  Invoker->setType(Conv->getReturnType()->getPointeeType());
14512  Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));
14513 
14514  // Construct the body of the conversion function { return __invoke; }.
14515  Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(),
14516  VK_LValue, Conv->getLocation());
14517  assert(FunctionRef && "Can't refer to __invoke function?");
14518  Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
14519  Conv->setBody(CompoundStmt::Create(Context, Return, Conv->getLocation(),
14520  Conv->getLocation()));
14521  Conv->markUsed(Context);
14522  Conv->setReferenced();
14523 
14524  if (ASTMutationListener *L = getASTMutationListener()) {
14525  L->CompletedImplicitDefinition(Conv);
14526  L->CompletedImplicitDefinition(Invoker);
14527  }
14528 }
14529 
14530 
14531 
14533  SourceLocation CurrentLocation,
14534  CXXConversionDecl *Conv)
14535 {
14536  assert(!Conv->getParent()->isGenericLambda());
14537 
14538  SynthesizedFunctionScope Scope(*this, Conv);
14539 
14540  // Copy-initialize the lambda object as needed to capture it.
14541  Expr *This = ActOnCXXThis(CurrentLocation).get();
14542  Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).get();
14543 
14544  ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation,
14545  Conv->getLocation(),
14546  Conv, DerefThis);
14547 
14548  // If we're not under ARC, make sure we still get the _Block_copy/autorelease
14549  // behavior. Note that only the general conversion function does this
14550  // (since it's unusable otherwise); in the case where we inline the
14551  // block literal, it has block literal lifetime semantics.
14552  if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
14553  BuildBlock = ImplicitCastExpr::Create(Context, BuildBlock.get()->getType(),
14554  CK_CopyAndAutoreleaseBlockObject,
14555  BuildBlock.get(), nullptr, VK_RValue);
14556 
14557  if (BuildBlock.isInvalid()) {
14558  Diag(CurrentLocation, diag::note_lambda_to_block_conv);
14559  Conv->setInvalidDecl();
14560  return;
14561  }
14562 
14563  // Create the return statement that returns the block from the conversion
14564  // function.
14565  StmtResult Return = BuildReturnStmt(Conv->getLocation(), BuildBlock.get());
14566  if (Return.isInvalid()) {
14567  Diag(CurrentLocation, diag::note_lambda_to_block_conv);
14568  Conv->setInvalidDecl();
14569  return;
14570  }
14571 
14572  // Set the body of the conversion function.
14573  Stmt *ReturnS = Return.get();
14574  Conv->setBody(CompoundStmt::Create(Context, ReturnS, Conv->getLocation(),
14575  Conv->getLocation()));
14576  Conv->markUsed(Context);
14577 
14578  // We're done; notify the mutation listener, if any.
14579  if (ASTMutationListener *L = getASTMutationListener()) {
14580  L->CompletedImplicitDefinition(Conv);
14581  }
14582 }
14583 
14584 /// Determine whether the given list arguments contains exactly one
14585 /// "real" (non-default) argument.
14587  switch (Args.size()) {
14588  case 0:
14589  return false;
14590 
14591  default:
14592  if (!Args[1]->isDefaultArgument())
14593  return false;
14594 
14595  LLVM_FALLTHROUGH;
14596  case 1:
14597  return !Args[0]->isDefaultArgument();
14598  }
14599 
14600  return false;
14601 }
14602 
14603 ExprResult
14605  NamedDecl *FoundDecl,
14606  CXXConstructorDecl *Constructor,
14607  MultiExprArg ExprArgs,
14608  bool HadMultipleCandidates,
14609  bool IsListInitialization,
14610  bool IsStdInitListInitialization,
14611  bool RequiresZeroInit,
14612  unsigned ConstructKind,
14613  SourceRange ParenRange) {
14614  bool Elidable = false;
14615 
14616  // C++0x [class.copy]p34:
14617  // When certain criteria are met, an implementation is allowed to
14618  // omit the copy/move construction of a class object, even if the
14619  // copy/move constructor and/or destructor for the object have
14620  // side effects. [...]
14621  // - when a temporary class object that has not been bound to a
14622  // reference (12.2) would be copied/moved to a class object
14623  // with the same cv-unqualified type, the copy/move operation
14624  // can be omitted by constructing the temporary object
14625  // directly into the target of the omitted copy/move
14626  if (ConstructKind == CXXConstructExpr::CK_Complete && Constructor &&
14627  Constructor->isCopyOrMoveConstructor() && hasOneRealArgument(ExprArgs)) {
14628  Expr *SubExpr = ExprArgs[0];
14629  Elidable = SubExpr->isTemporaryObject(
14630  Context, cast<CXXRecordDecl>(FoundDecl->getDeclContext()));
14631  }
14632 
14633  return BuildCXXConstructExpr(ConstructLoc, DeclInitType,
14634  FoundDecl, Constructor,
14635  Elidable, ExprArgs, HadMultipleCandidates,
14636  IsListInitialization,
14637  IsStdInitListInitialization, RequiresZeroInit,
14638  ConstructKind, ParenRange);
14639 }
14640 
14641 ExprResult
14643  NamedDecl *FoundDecl,
14644  CXXConstructorDecl *Constructor,
14645  bool Elidable,
14646  MultiExprArg ExprArgs,
14647  bool HadMultipleCandidates,
14648  bool IsListInitialization,
14649  bool IsStdInitListInitialization,
14650  bool RequiresZeroInit,
14651  unsigned ConstructKind,
14652  SourceRange ParenRange) {
14653  if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl)) {
14654  Constructor = findInheritingConstructor(ConstructLoc, Constructor, Shadow);
14655  if (DiagnoseUseOfDecl(Constructor, ConstructLoc))
14656  return ExprError();
14657  }
14658 
14659  return BuildCXXConstructExpr(
14660  ConstructLoc, DeclInitType, Constructor, Elidable, ExprArgs,
14661  HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
14662  RequiresZeroInit, ConstructKind, ParenRange);
14663 }
14664 
14665 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
14666 /// including handling of its default argument expressions.
14667 ExprResult
14669  CXXConstructorDecl *Constructor,
14670  bool Elidable,
14671  MultiExprArg ExprArgs,
14672  bool HadMultipleCandidates,
14673  bool IsListInitialization,
14674  bool IsStdInitListInitialization,
14675  bool RequiresZeroInit,
14676  unsigned ConstructKind,
14677  SourceRange ParenRange) {
14678  assert(declaresSameEntity(
14679  Constructor->getParent(),
14680  DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) &&
14681  "given constructor for wrong type");
14682  MarkFunctionReferenced(ConstructLoc, Constructor);
14683  if (getLangOpts().CUDA && !CheckCUDACall(ConstructLoc, Constructor))
14684  return ExprError();
14685 
14686  return CXXConstructExpr::Create(
14687  Context, DeclInitType, ConstructLoc, Constructor, Elidable,
14688  ExprArgs, HadMultipleCandidates, IsListInitialization,
14689  IsStdInitListInitialization, RequiresZeroInit,
14690  static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
14691  ParenRange);
14692 }
14693 
14695  assert(Field->hasInClassInitializer());
14696 
14697  // If we already have the in-class initializer nothing needs to be done.
14698  if (Field->getInClassInitializer())
14699  return CXXDefaultInitExpr::Create(Context, Loc, Field, CurContext);
14700 
14701  // If we might have already tried and failed to instantiate, don't try again.
14702  if (Field->isInvalidDecl())
14703  return ExprError();
14704 
14705  // Maybe we haven't instantiated the in-class initializer. Go check the
14706  // pattern FieldDecl to see if it has one.
14707  CXXRecordDecl *ParentRD = cast<CXXRecordDecl>(Field->getParent());
14708 
14710  CXXRecordDecl *ClassPattern = ParentRD->getTemplateInstantiationPattern();
14712  ClassPattern->lookup(Field->getDeclName());
14713 
14714  // Lookup can return at most two results: the pattern for the field, or the
14715  // injected class name of the parent record. No other member can have the
14716  // same name as the field.
14717  // In modules mode, lookup can return multiple results (coming from
14718  // different modules).
14719  assert((getLangOpts().Modules || (!Lookup.empty() && Lookup.size() <= 2)) &&
14720  "more than two lookup results for field name");
14721  FieldDecl *Pattern = dyn_cast<FieldDecl>(Lookup[0]);
14722  if (!Pattern) {
14723  assert(isa<CXXRecordDecl>(Lookup[0]) &&
14724  "cannot have other non-field member with same name");
14725  for (auto L : Lookup)
14726  if (isa<FieldDecl>(L)) {
14727  Pattern = cast<FieldDecl>(L);
14728  break;
14729  }
14730  assert(Pattern && "We must have set the Pattern!");
14731  }
14732 
14733  if (!Pattern->hasInClassInitializer() ||
14734  InstantiateInClassInitializer(Loc, Field, Pattern,
14735  getTemplateInstantiationArgs(Field))) {
14736  // Don't diagnose this again.
14737  Field->setInvalidDecl();
14738  return ExprError();
14739  }
14740  return CXXDefaultInitExpr::Create(Context, Loc, Field, CurContext);
14741  }
14742 
14743  // DR1351:
14744  // If the brace-or-equal-initializer of a non-static data member
14745  // invokes a defaulted default constructor of its class or of an
14746  // enclosing class in a potentially evaluated subexpression, the
14747  // program is ill-formed.
14748  //
14749  // This resolution is unworkable: the exception specification of the
14750  // default constructor can be needed in an unevaluated context, in
14751  // particular, in the operand of a noexcept-expression, and we can be
14752  // unable to compute an exception specification for an enclosed class.
14753  //
14754  // Any attempt to resolve the exception specification of a defaulted default
14755  // constructor before the initializer is lexically complete will ultimately
14756  // come here at which point we can diagnose it.
14757  RecordDecl *OutermostClass = ParentRD->getOuterLexicalRecordContext();
14758  Diag(Loc, diag::err_in_class_initializer_not_yet_parsed)
14759  << OutermostClass << Field;
14760  Diag(Field->getEndLoc(), diag::note_in_class_initializer_not_yet_parsed);
14761  // Recover by marking the field invalid, unless we're in a SFINAE context.
14762  if (!isSFINAEContext())
14763  Field->setInvalidDecl();
14764  return ExprError();
14765 }
14766 
14768  if (VD->isInvalidDecl()) return;
14769 
14770  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());
14771  if (ClassDecl->isInvalidDecl()) return;
14772  if (ClassDecl->hasIrrelevantDestructor()) return;
14773  if (ClassDecl->isDependentContext()) return;
14774 
14775  if (VD->isNoDestroy(getASTContext()))
14776  return;
14777 
14778  CXXDestructorDecl *Destructor = LookupDestructor(ClassDecl);
14779 
14780  // If this is an array, we'll require the destructor during initialization, so
14781  // we can skip over this. We still want to emit exit-time destructor warnings
14782  // though.
14783  if (!VD->getType()->isArrayType()) {
14784  MarkFunctionReferenced(VD->getLocation(), Destructor);
14785  CheckDestructorAccess(VD->getLocation(), Destructor,
14786  PDiag(diag::err_access_dtor_var)
14787  << VD->getDeclName() << VD->getType());
14788  DiagnoseUseOfDecl(Destructor, VD->getLocation());
14789  }
14790 
14791  if (Destructor->isTrivial()) return;
14792 
14793  // If the destructor is constexpr, check whether the variable has constant
14794  // destruction now.
14795  if (Destructor->isConstexpr() && VD->getInit() &&
14796  !VD->getInit()->isValueDependent() && VD->evaluateValue()) {
14798  if (!VD->evaluateDestruction(Notes) && VD->isConstexpr()) {
14799  Diag(VD->getLocation(),
14800  diag::err_constexpr_var_requires_const_destruction) << VD;
14801  for (unsigned I = 0, N = Notes.size(); I != N; ++I)
14802  Diag(Notes[I].first, Notes[I].second);
14803  }
14804  }
14805 
14806  if (!VD->hasGlobalStorage()) return;
14807 
14808  // Emit warning for non-trivial dtor in global scope (a real global,
14809  // class-static, function-static).
14810  Diag(VD->getLocation(), diag::warn_exit_time_destructor);
14811 
14812  // TODO: this should be re-enabled for static locals by !CXAAtExit
14813  if (!VD->isStaticLocal())
14814  Diag(VD->getLocation(), diag::warn_global_destructor);
14815 }
14816 
14817 /// Given a constructor and the set of arguments provided for the
14818 /// constructor, convert the arguments and add any required default arguments
14819 /// to form a proper call to this constructor.
14820 ///
14821 /// \returns true if an error occurred, false otherwise.
14822 bool
14824  MultiExprArg ArgsPtr,
14825  SourceLocation Loc,
14826  SmallVectorImpl<Expr*> &ConvertedArgs,
14827  bool AllowExplicit,
14828  bool IsListInitialization) {
14829  // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
14830  unsigned NumArgs = ArgsPtr.size();
14831  Expr **Args = ArgsPtr.data();
14832 
14833  const auto *Proto = Constructor->getType()->castAs<FunctionProtoType>();
14834  unsigned NumParams = Proto->getNumParams();
14835 
14836  // If too few arguments are available, we'll fill in the rest with defaults.
14837  if (NumArgs < NumParams)
14838  ConvertedArgs.reserve(NumParams);
14839  else
14840  ConvertedArgs.reserve(NumArgs);
14841 
14842  VariadicCallType CallType =
14843  Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
14844  SmallVector<Expr *, 8> AllArgs;
14845  bool Invalid = GatherArgumentsForCall(Loc, Constructor,
14846  Proto, 0,
14847  llvm::makeArrayRef(Args, NumArgs),
14848  AllArgs,
14849  CallType, AllowExplicit,
14850  IsListInitialization);
14851  ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
14852 
14853  DiagnoseSentinelCalls(Constructor, Loc, AllArgs);
14854 
14855  CheckConstructorCall(Constructor,
14856  llvm::makeArrayRef(AllArgs.data(), AllArgs.size()),
14857  Proto, Loc);
14858 
14859  return Invalid;
14860 }
14861 
14862 static inline bool
14864  const FunctionDecl *FnDecl) {
14865  const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
14866  if (isa<NamespaceDecl>(DC)) {
14867  return SemaRef.Diag(FnDecl->getLocation(),
14868  diag::err_operator_new_delete_declared_in_namespace)
14869  << FnDecl->getDeclName();
14870  }
14871 
14872  if (isa<TranslationUnitDecl>(DC) &&
14873  FnDecl->getStorageClass() == SC_Static) {
14874  return SemaRef.Diag(FnDecl->getLocation(),
14875  diag::err_operator_new_delete_declared_static)
14876  << FnDecl->getDeclName();
14877  }
14878 
14879  return false;
14880 }
14881 
14882 static QualType
14883 RemoveAddressSpaceFromPtr(Sema &SemaRef, const PointerType *PtrTy) {
14884  QualType QTy = PtrTy->getPointeeType();
14885  QTy = SemaRef.Context.removeAddrSpaceQualType(QTy);
14886  return SemaRef.Context.getPointerType(QTy);
14887 }
14888 
14889 static inline bool
14891  CanQualType ExpectedResultType,
14892  CanQualType ExpectedFirstParamType,
14893  unsigned DependentParamTypeDiag,
14894  unsigned InvalidParamTypeDiag) {
14895  QualType ResultType =
14896  FnDecl->getType()->castAs<FunctionType>()->getReturnType();
14897 
14898  // Check that the result type is not dependent.
14899  if (ResultType->isDependentType())
14900  return SemaRef.Diag(FnDecl->getLocation(),
14901  diag::err_operator_new_delete_dependent_result_type)
14902  << FnDecl->getDeclName() << ExpectedResultType;
14903 
14904  // The operator is valid on any address space for OpenCL.
14905  if (SemaRef.getLangOpts().OpenCLCPlusPlus) {
14906  if (auto *PtrTy = ResultType->getAs<PointerType>()) {
14907  ResultType = RemoveAddressSpaceFromPtr(SemaRef, PtrTy);
14908  }
14909  }
14910 
14911  // Check that the result type is what we expect.
14912  if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType)
14913  return SemaRef.Diag(FnDecl->getLocation(),
14914  diag::err_operator_new_delete_invalid_result_type)
14915  << FnDecl->getDeclName() << ExpectedResultType;
14916 
14917  // A function template must have at least 2 parameters.
14918  if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
14919  return SemaRef.Diag(FnDecl->getLocation(),
14920  diag::err_operator_new_delete_template_too_few_parameters)
14921  << FnDecl->getDeclName();
14922 
14923  // The function decl must have at least 1 parameter.
14924  if (FnDecl->getNumParams() == 0)
14925  return SemaRef.Diag(FnDecl->getLocation(),
14926  diag::err_operator_new_delete_too_few_parameters)
14927  << FnDecl->getDeclName();
14928 
14929  // Check the first parameter type is not dependent.
14930  QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
14931  if (FirstParamType->isDependentType())
14932  return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag)
14933  << FnDecl->getDeclName() << ExpectedFirstParamType;
14934 
14935  // Check that the first parameter type is what we expect.
14936  if (SemaRef.getLangOpts().OpenCLCPlusPlus) {
14937  // The operator is valid on any address space for OpenCL.
14938  if (auto *PtrTy =
14939  FnDecl->getParamDecl(0)->getType()->getAs<PointerType>()) {
14940  FirstParamType = RemoveAddressSpaceFromPtr(SemaRef, PtrTy);
14941  }
14942  }
14943  if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
14944  ExpectedFirstParamType)
14945  return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
14946  << FnDecl->getDeclName() << ExpectedFirstParamType;
14947 
14948  return false;
14949 }
14950 
14951 static bool
14953  // C++ [basic.stc.dynamic.allocation]p1:
14954  // A program is ill-formed if an allocation function is declared in a
14955  // namespace scope other than global scope or declared static in global
14956  // scope.
14957  if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
14958  return true;
14959 
14960  CanQualType SizeTy =
14961  SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType());
14962 
14963  // C++ [basic.stc.dynamic.allocation]p1:
14964  // The return type shall be void*. The first parameter shall have type
14965  // std::size_t.
14966  if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy,
14967  SizeTy,
14968  diag::err_operator_new_dependent_param_type,
14969  diag::err_operator_new_param_type))
14970  return true;
14971 
14972  // C++ [basic.stc.dynamic.allocation]p1:
14973  // The first parameter shall not have an associated default argument.
14974  if (FnDecl->getParamDecl(0)->hasDefaultArg())
14975  return SemaRef.Diag(FnDecl->getLocation(),
14976  diag::err_operator_new_default_arg)
14977  << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();
14978 
14979  return false;
14980 }
14981 
14982 static bool
14984  // C++ [basic.stc.dynamic.deallocation]p1:
14985  // A program is ill-formed if deallocation functions are declared in a
14986  // namespace scope other than global scope or declared static in global
14987  // scope.
14988  if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
14989  return true;
14990 
14991  auto *MD = dyn_cast<CXXMethodDecl>(FnDecl);
14992 
14993  // C++ P0722:
14994  // Within a class C, the first parameter of a destroying operator delete
14995  // shall be of type C *. The first parameter of any other deallocation
14996  // function shall be of type void *.
14997  CanQualType ExpectedFirstParamType =
14998  MD && MD->isDestroyingOperatorDelete()
14999  ? SemaRef.Context.getCanonicalType(SemaRef.Context.getPointerType(
15000  SemaRef.Context.getRecordType(MD->getParent())))
15001  : SemaRef.Context.VoidPtrTy;
15002 
15003  // C++ [basic.stc.dynamic.deallocation]p2:
15004  // Each deallocation function shall return void
15006  SemaRef, FnDecl, SemaRef.Context.VoidTy, ExpectedFirstParamType,
15007  diag::err_operator_delete_dependent_param_type,
15008  diag::err_operator_delete_param_type))
15009  return true;
15010 
15011  // C++ P0722:
15012  // A destroying operator delete shall be a usual deallocation function.
15013  if (MD && !MD->getParent()->isDependentContext() &&
15015  !SemaRef.isUsualDeallocationFunction(MD)) {
15016  SemaRef.Diag(MD->getLocation(),
15017  diag::err_destroying_operator_delete_not_usual);
15018  return true;
15019  }
15020 
15021  return false;
15022 }
15023 
15024 /// CheckOverloadedOperatorDeclaration - Check whether the declaration
15025 /// of this overloaded operator is well-formed. If so, returns false;
15026 /// otherwise, emits appropriate diagnostics and returns true.
15028  assert(FnDecl && FnDecl->isOverloadedOperator() &&
15029  "Expected an overloaded operator declaration");
15030 
15032 
15033  // C++ [over.oper]p5:
15034  // The allocation and deallocation functions, operator new,
15035  // operator new[], operator delete and operator delete[], are
15036  // described completely in 3.7.3. The attributes and restrictions
15037  // found in the rest of this subclause do not apply to them unless
15038  // explicitly stated in 3.7.3.
15039  if (Op == OO_Delete || Op == OO_Array_Delete)
15040  return CheckOperatorDeleteDeclaration(*this, FnDecl);
15041 
15042  if (Op == OO_New || Op == OO_Array_New)
15043  return CheckOperatorNewDeclaration(*this, FnDecl);
15044 
15045  // C++ [over.oper]p6:
15046  // An operator function shall either be a non-static member
15047  // function or be a non-member function and have at least one
15048  // parameter whose type is a class, a reference to a class, an
15049  // enumeration, or a reference to an enumeration.
15050  if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
15051  if (MethodDecl->isStatic())
15052  return Diag(FnDecl->getLocation(),
15053  diag::err_operator_overload_static) << FnDecl->getDeclName();
15054  } else {
15055  bool ClassOrEnumParam = false;
15056  for (auto Param : FnDecl->parameters()) {
15057  QualType ParamType = Param->getType().getNonReferenceType();
15058  if (ParamType->isDependentType() || ParamType->isRecordType() ||
15059  ParamType->isEnumeralType()) {
15060  ClassOrEnumParam = true;
15061  break;
15062  }
15063  }
15064 
15065  if (!ClassOrEnumParam)
15066  return Diag(FnDecl->getLocation(),
15067  diag::err_operator_overload_needs_class_or_enum)
15068  << FnDecl->getDeclName();
15069  }
15070 
15071  // C++ [over.oper]p8:
15072  // An operator function cannot have default arguments (8.3.6),
15073  // except where explicitly stated below.
15074  //
15075  // Only the function-call operator allows default arguments
15076  // (C++ [over.call]p1).
15077  if (Op != OO_Call) {
15078  for (auto Param : FnDecl->parameters()) {
15079  if (Param->hasDefaultArg())
15080  return Diag(Param->getLocation(),
15081  diag::err_operator_overload_default_arg)
15082  << FnDecl->getDeclName() << Param->getDefaultArgRange();
15083  }
15084  }
15085 
15086  static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
15087  { false, false, false }
15088 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
15089  , { Unary, Binary, MemberOnly }
15090 #include "clang/Basic/OperatorKinds.def"
15091  };
15092 
15093  bool CanBeUnaryOperator = OperatorUses[Op][0];
15094  bool CanBeBinaryOperator = OperatorUses[Op][1];
15095  bool MustBeMemberOperator = OperatorUses[Op][2];
15096 
15097  // C++ [over.oper]p8:
15098  // [...] Operator functions cannot have more or fewer parameters
15099  // than the number required for the corresponding operator, as
15100  // described in the rest of this subclause.
15101  unsigned NumParams = FnDecl->getNumParams()
15102  + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
15103  if (Op != OO_Call &&
15104  ((NumParams == 1 && !CanBeUnaryOperator) ||
15105  (NumParams == 2 && !CanBeBinaryOperator) ||
15106  (NumParams < 1) || (NumParams > 2))) {
15107  // We have the wrong number of parameters.
15108  unsigned ErrorKind;
15109  if (CanBeUnaryOperator && CanBeBinaryOperator) {
15110  ErrorKind = 2; // 2 -> unary or binary.
15111  } else if (CanBeUnaryOperator) {
15112  ErrorKind = 0; // 0 -> unary
15113  } else {
15114  assert(CanBeBinaryOperator &&
15115  "All non-call overloaded operators are unary or binary!");
15116  ErrorKind = 1; // 1 -> binary
15117  }
15118 
15119  return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
15120  << FnDecl->getDeclName() << NumParams << ErrorKind;
15121  }
15122 
15123  // Overloaded operators other than operator() cannot be variadic.
15124  if (Op != OO_Call &&
15125  FnDecl->getType()->castAs<FunctionProtoType>()->isVariadic()) {
15126  return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
15127  << FnDecl->getDeclName();
15128  }
15129 
15130  // Some operators must be non-static member functions.
15131  if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
15132  return Diag(FnDecl->getLocation(),
15133  diag::err_operator_overload_must_be_member)
15134  << FnDecl->getDeclName();
15135  }
15136 
15137  // C++ [over.inc]p1:
15138  // The user-defined function called operator++ implements the
15139  // prefix and postfix ++ operator. If this function is a member
15140  // function with no parameters, or a non-member function with one
15141  // parameter of class or enumeration type, it defines the prefix
15142  // increment operator ++ for objects of that type. If the function
15143  // is a member function with one parameter (which shall be of type
15144  // int) or a non-member function with two parameters (the second
15145  // of which shall be of type int), it defines the postfix
15146  // increment operator ++ for objects of that type.
15147  if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
15148  ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
15149  QualType ParamType = LastParam->getType();
15150 
15151  if (!ParamType->isSpecificBuiltinType(BuiltinType::Int) &&
15152  !ParamType->isDependentType())
15153  return Diag(LastParam->getLocation(),
15154  diag::err_operator_overload_post_incdec_must_be_int)
15155  << LastParam->getType() << (Op == OO_MinusMinus);
15156  }
15157 
15158  return false;
15159 }
15160 
15161 static bool
15163  FunctionTemplateDecl *TpDecl) {
15164  TemplateParameterList *TemplateParams = TpDecl->getTemplateParameters();
15165 
15166  // Must have one or two template parameters.
15167  if (TemplateParams->size() == 1) {
15168  NonTypeTemplateParmDecl *PmDecl =
15169  dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(0));
15170 
15171  // The template parameter must be a char parameter pack.
15172  if (PmDecl && PmDecl->isTemplateParameterPack() &&
15173  SemaRef.Context.hasSameType(PmDecl->getType(), SemaRef.Context.CharTy))
15174  return false;
15175 
15176  } else if (TemplateParams->size() == 2) {
15177  TemplateTypeParmDecl *PmType =
15178  dyn_cast<TemplateTypeParmDecl>(TemplateParams->getParam(0));
15179  NonTypeTemplateParmDecl *PmArgs =
15180  dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(1));
15181 
15182  // The second template parameter must be a parameter pack with the
15183  // first template parameter as its type.
15184  if (PmType && PmArgs && !PmType->isTemplateParameterPack() &&
15185  PmArgs->isTemplateParameterPack()) {
15186  const TemplateTypeParmType *TArgs =
15187  PmArgs->getType()->getAs<TemplateTypeParmType>();
15188  if (TArgs && TArgs->getDepth() == PmType->getDepth() &&
15189  TArgs->getIndex() == PmType->getIndex()) {
15190  if (!SemaRef.inTemplateInstantiation())
15191  SemaRef.Diag(TpDecl->getLocation(),
15192  diag::ext_string_literal_operator_template);
15193  return false;
15194  }
15195  }
15196  }
15197 
15198  SemaRef.Diag(TpDecl->getTemplateParameters()->getSourceRange().getBegin(),
15199  diag::err_literal_operator_template)
15200  << TpDecl->getTemplateParameters()->getSourceRange();
15201  return true;
15202 }
15203 
15204 /// CheckLiteralOperatorDeclaration - Check whether the declaration
15205 /// of this literal operator function is well-formed. If so, returns
15206 /// false; otherwise, emits appropriate diagnostics and returns true.
15208  if (isa<CXXMethodDecl>(FnDecl)) {
15209  Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
15210  << FnDecl->getDeclName();
15211  return true;
15212  }
15213 
15214  if (FnDecl->isExternC()) {
15215  Diag(FnDecl->getLocation(), diag::err_literal_operator_extern_c);
15216  if (const LinkageSpecDecl *LSD =
15217  FnDecl->getDeclContext()->getExternCContext())
15218  Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
15219  return true;
15220  }
15221 
15222  // This might be the definition of a literal operator template.
15224 
15225  // This might be a specialization of a literal operator template.
15226  if (!TpDecl)
15227  TpDecl = FnDecl->getPrimaryTemplate();
15228 
15229  // template <char...> type operator "" name() and
15230  // template <class T, T...> type operator "" name() are the only valid
15231  // template signatures, and the only valid signatures with no parameters.
15232  if (TpDecl) {
15233  if (FnDecl->param_size() != 0) {
15234  Diag(FnDecl->getLocation(),
15235  diag::err_literal_operator_template_with_params);
15236  return true;
15237  }
15238 
15239  if (checkLiteralOperatorTemplateParameterList(*this, TpDecl))
15240  return true;
15241 
15242  } else if (FnDecl->param_size() == 1) {
15243  const ParmVarDecl *Param = FnDecl->getParamDecl(0);
15244 
15245  QualType ParamType = Param->getType().getUnqualifiedType();
15246 
15247  // Only unsigned long long int, long double, any character type, and const
15248  // char * are allowed as the only parameters.
15249  if (ParamType->isSpecificBuiltinType(BuiltinType::ULongLong) ||
15250  ParamType->isSpecificBuiltinType(BuiltinType::LongDouble) ||
15251  Context.hasSameType(ParamType, Context.CharTy) ||
15252  Context.hasSameType(ParamType, Context.WideCharTy) ||
15253  Context.hasSameType(ParamType, Context.Char8Ty) ||
15254  Context.hasSameType(ParamType, Context.Char16Ty) ||
15255  Context.hasSameType(ParamType, Context.Char32Ty)) {
15256  } else if (const PointerType *Ptr = ParamType->getAs<PointerType>()) {
15257  QualType InnerType = Ptr->getPointeeType();
15258 
15259  // Pointer parameter must be a const char *.
15260  if (!(Context.hasSameType(InnerType.getUnqualifiedType(),
15261  Context.CharTy) &&
15262  InnerType.isConstQualified() && !InnerType.isVolatileQualified())) {
15263  Diag(Param->getSourceRange().getBegin(),
15264  diag::err_literal_operator_param)
15265  << ParamType << "'const char *'" << Param->getSourceRange();
15266  return true;
15267  }
15268 
15269  } else if (ParamType->isRealFloatingType()) {
15270  Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
15271  << ParamType << Context.LongDoubleTy << Param->getSourceRange();
15272  return true;
15273 
15274  } else if (ParamType->isIntegerType()) {
15275  Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
15276  << ParamType << Context.UnsignedLongLongTy << Param->getSourceRange();
15277  return true;
15278 
15279  } else {
15280  Diag(Param->getSourceRange().getBegin(),
15281  diag::err_literal_operator_invalid_param)
15282  << ParamType << Param->getSourceRange();
15283  return true;
15284  }
15285 
15286  } else if (FnDecl->param_size() == 2) {
15287  FunctionDecl::param_iterator Param = FnDecl->param_begin();
15288 
15289  // First, verify that the first parameter is correct.
15290 
15291  QualType FirstParamType = (*Param)->getType().getUnqualifiedType();
15292 
15293  // Two parameter function must have a pointer to const as a
15294  // first parameter; let's strip those qualifiers.
15295  const PointerType *PT = FirstParamType->getAs<PointerType>();
15296 
15297  if (!PT) {
15298  Diag((*Param)->getSourceRange().getBegin(),
15299  diag::err_literal_operator_param)
15300  << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
15301  return true;
15302  }
15303 
15304  QualType PointeeType = PT->getPointeeType();
15305  // First parameter must be const
15306  if (!PointeeType.isConstQualified() || PointeeType.isVolatileQualified()) {
15307  Diag((*Param)->getSourceRange().getBegin(),
15308  diag::err_literal_operator_param)
15309  << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
15310  return true;
15311  }
15312 
15313  QualType InnerType = PointeeType.getUnqualifiedType();
15314  // Only const char *, const wchar_t*, const char8_t*, const char16_t*, and
15315  // const char32_t* are allowed as the first parameter to a two-parameter
15316  // function
15317  if (!(Context.hasSameType(InnerType, Context.CharTy) ||
15318  Context.hasSameType(InnerType, Context.WideCharTy) ||
15319  Context.hasSameType(InnerType, Context.Char8Ty) ||
15320  Context.hasSameType(InnerType, Context.Char16Ty) ||
15321  Context.hasSameType(InnerType, Context.Char32Ty))) {
15322  Diag((*Param)->getSourceRange().getBegin(),
15323  diag::err_literal_operator_param)
15324  << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
15325  return true;
15326  }
15327 
15328  // Move on to the second and final parameter.
15329  ++Param;
15330 
15331  // The second parameter must be a std::size_t.
15332  QualType SecondParamType = (*Param)->getType().getUnqualifiedType();
15333  if (!Context.hasSameType(SecondParamType, Context.getSizeType())) {
15334  Diag((*Param)->getSourceRange().getBegin(),
15335  diag::err_literal_operator_param)
15336  << SecondParamType << Context.getSizeType()
15337  << (*Param)->getSourceRange();
15338  return true;
15339  }
15340  } else {
15341  Diag(FnDecl->getLocation(), diag::err_literal_operator_bad_param_count);
15342  return true;
15343  }
15344 
15345  // Parameters are good.
15346 
15347  // A parameter-declaration-clause containing a default argument is not
15348  // equivalent to any of the permitted forms.
15349  for (auto Param : FnDecl->parameters()) {
15350  if (Param->hasDefaultArg()) {
15351  Diag(Param->getDefaultArgRange().getBegin(),
15352  diag::err_literal_operator_default_argument)
15353  << Param->getDefaultArgRange();
15354  break;
15355  }
15356  }
15357 
15358  StringRef LiteralName
15359  = FnDecl->getDeclName().getCXXLiteralIdentifier()->getName();
15360  if (LiteralName[0] != '_' &&
15361  !getSourceManager().isInSystemHeader(FnDecl->getLocation())) {
15362  // C++11 [usrlit.suffix]p1:
15363  // Literal suffix identifiers that do not start with an underscore
15364  // are reserved for future standardization.
15365  Diag(FnDecl->getLocation(), diag::warn_user_literal_reserved)
15366  << StringLiteralParser::isValidUDSuffix(getLangOpts(), LiteralName);
15367  }
15368 
15369  return false;
15370 }
15371 
15372 /// ActOnStartLinkageSpecification - Parsed the beginning of a C++
15373 /// linkage specification, including the language and (if present)
15374 /// the '{'. ExternLoc is the location of the 'extern', Lang is the
15375 /// language string literal. LBraceLoc, if valid, provides the location of
15376 /// the '{' brace. Otherwise, this linkage specification does not
15377 /// have any braces.
15379  Expr *LangStr,
15380  SourceLocation LBraceLoc) {
15381  StringLiteral *Lit = cast<StringLiteral>(LangStr);
15382  if (!Lit->isAscii()) {
15383  Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_not_ascii)
15384  << LangStr->getSourceRange();
15385  return nullptr;
15386  }
15387 
15388  StringRef Lang = Lit->getString();
15390  if (Lang == "C")
15391  Language = LinkageSpecDecl::lang_c;
15392  else if (Lang == "C++")
15393  Language = LinkageSpecDecl::lang_cxx;
15394  else {
15395  Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_unknown)
15396  << LangStr->getSourceRange();
15397  return nullptr;
15398  }
15399 
15400  // FIXME: Add all the various semantics of linkage specifications
15401 
15402  LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext, ExternLoc,
15403  LangStr->getExprLoc(), Language,
15404  LBraceLoc.isValid());
15405  CurContext->addDecl(D);
15406  PushDeclContext(S, D);
15407  return D;
15408 }
15409 
15410 /// ActOnFinishLinkageSpecification - Complete the definition of
15411 /// the C++ linkage specification LinkageSpec. If RBraceLoc is
15412 /// valid, it's the position of the closing '}' brace in a linkage
15413 /// specification that uses braces.
15415  Decl *LinkageSpec,
15416  SourceLocation RBraceLoc) {
15417  if (RBraceLoc.isValid()) {
15418  LinkageSpecDecl* LSDecl = cast<LinkageSpecDecl>(LinkageSpec);
15419  LSDecl->setRBraceLoc(RBraceLoc);
15420  }
15421  PopDeclContext();
15422  return LinkageSpec;
15423 }
15424 
15426  const ParsedAttributesView &AttrList,
15427  SourceLocation SemiLoc) {
15428  Decl *ED = EmptyDecl::Create(Context, CurContext, SemiLoc);
15429  // Attribute declarations appertain to empty declaration so we handle
15430  // them here.
15431  ProcessDeclAttributeList(S, ED, AttrList);
15432 
15433  CurContext->addDecl(ED);
15434  return ED;
15435 }
15436 
15437 /// Perform semantic analysis for the variable declaration that
15438 /// occurs within a C++ catch clause, returning the newly-created
15439 /// variable.
15441  TypeSourceInfo *TInfo,
15442  SourceLocation StartLoc,
15443  SourceLocation Loc,
15444  IdentifierInfo *Name) {
15445  bool Invalid = false;
15446  QualType ExDeclType = TInfo->getType();
15447 
15448  // Arrays and functions decay.
15449  if (ExDeclType->isArrayType())
15450  ExDeclType = Context.getArrayDecayedType(ExDeclType);
15451  else if (ExDeclType->isFunctionType())
15452  ExDeclType = Context.getPointerType(ExDeclType);
15453 
15454  // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
15455  // The exception-declaration shall not denote a pointer or reference to an
15456  // incomplete type, other than [cv] void*.
15457  // N2844 forbids rvalue references.
15458  if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
15459  Diag(Loc, diag::err_catch_rvalue_ref);
15460  Invalid = true;
15461  }
15462 
15463  if (ExDeclType->isVariablyModifiedType()) {
15464  Diag(Loc, diag::err_catch_variably_modified) << ExDeclType;
15465  Invalid = true;
15466  }
15467 
15468  QualType BaseType = ExDeclType;
15469  int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
15470  unsigned DK = diag::err_catch_incomplete;
15471  if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
15472  BaseType = Ptr->getPointeeType();
15473  Mode = 1;
15474  DK = diag::err_catch_incomplete_ptr;
15475  } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
15476  // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
15477  BaseType = Ref->getPointeeType();
15478  Mode = 2;
15479  DK = diag::err_catch_incomplete_ref;
15480  }
15481  if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
15482  !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
15483  Invalid = true;
15484 
15485  if (!Invalid && !ExDeclType->isDependentType() &&
15486  RequireNonAbstractType(Loc, ExDeclType,
15487  diag::err_abstract_type_in_decl,
15488  AbstractVariableType))
15489  Invalid = true;
15490 
15491  // Only the non-fragile NeXT runtime currently supports C++ catches
15492  // of ObjC types, and no runtime supports catching ObjC types by value.
15493  if (!Invalid && getLangOpts().ObjC) {
15494  QualType T = ExDeclType;
15495  if (const ReferenceType *RT = T->getAs<ReferenceType>())
15496  T = RT->getPointeeType();
15497 
15498  if (T->isObjCObjectType()) {
15499  Diag(Loc, diag::err_objc_object_catch);
15500  Invalid = true;
15501  } else if (T->isObjCObjectPointerType()) {
15502  // FIXME: should this be a test for macosx-fragile specifically?
15503  if (getLangOpts().ObjCRuntime.isFragile())
15504  Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
15505  }
15506  }
15507 
15508  VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
15509  ExDeclType, TInfo, SC_None);
15510  ExDecl->setExceptionVariable(true);
15511 
15512  // In ARC, infer 'retaining' for variables of retainable type.
15513  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(ExDecl))
15514  Invalid = true;
15515 
15516  if (!Invalid && !ExDeclType->isDependentType()) {
15517  if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) {
15518  // Insulate this from anything else we might currently be parsing.
15520  *this, ExpressionEvaluationContext::PotentiallyEvaluated);
15521 
15522  // C++ [except.handle]p16:
15523  // The object declared in an exception-declaration or, if the
15524  // exception-declaration does not specify a name, a temporary (12.2) is
15525  // copy-initialized (8.5) from the exception object. [...]
15526  // The object is destroyed when the handler exits, after the destruction
15527  // of any automatic objects initialized within the handler.
15528  //
15529  // We just pretend to initialize the object with itself, then make sure
15530  // it can be destroyed later.
15531  QualType initType = Context.getExceptionObjectType(ExDeclType);
15532 
15533  InitializedEntity entity =
15535  InitializationKind initKind =
15537 
15538  Expr *opaqueValue =
15539  new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary);
15540  InitializationSequence sequence(*this, entity, initKind, opaqueValue);
15541  ExprResult result = sequence.Perform(*this, entity, initKind, opaqueValue);
15542  if (result.isInvalid())
15543  Invalid = true;
15544  else {
15545  // If the constructor used was non-trivial, set this as the
15546  // "initializer".
15547  CXXConstructExpr *construct = result.getAs<CXXConstructExpr>();
15548  if (!construct->getConstructor()->isTrivial()) {
15549  Expr *init = MaybeCreateExprWithCleanups(construct);
15550  ExDecl->setInit(init);
15551  }
15552 
15553  // And make sure it's destructable.
15554  FinalizeVarWithDestructor(ExDecl, recordType);
15555  }
15556  }
15557  }
15558 
15559  if (Invalid)
15560  ExDecl->setInvalidDecl();
15561 
15562  return ExDecl;
15563 }
15564 
15565 /// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
15566 /// handler.
15568  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
15569  bool Invalid = D.isInvalidType();
15570 
15571  // Check for unexpanded parameter packs.
15572  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
15573  UPPC_ExceptionType)) {
15574  TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
15575  D.getIdentifierLoc());
15576  Invalid = true;
15577  }
15578 
15579  IdentifierInfo *II = D.getIdentifier();
15580  if (NamedDecl *PrevDecl = LookupSingleName(S, II, D.getIdentifierLoc(),
15581  LookupOrdinaryName,
15582  ForVisibleRedeclaration)) {
15583  // The scope should be freshly made just for us. There is just no way
15584  // it contains any previous declaration, except for function parameters in
15585  // a function-try-block's catch statement.
15586  assert(!S->isDeclScope(PrevDecl));
15587  if (isDeclInScope(PrevDecl, CurContext, S)) {
15588  Diag(D.getIdentifierLoc(), diag::err_redefinition)
15589  << D.getIdentifier();
15590  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
15591  Invalid = true;
15592  } else if (PrevDecl->isTemplateParameter())
15593  // Maybe we will complain about the shadowed template parameter.
15594  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
15595  }
15596 
15597  if (D.getCXXScopeSpec().isSet() && !Invalid) {
15598  Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
15599  << D.getCXXScopeSpec().getRange();
15600  Invalid = true;
15601  }
15602 
15603  VarDecl *ExDecl = BuildExceptionDeclaration(
15604  S, TInfo, D.getBeginLoc(), D.getIdentifierLoc(), D.getIdentifier());
15605  if (Invalid)
15606  ExDecl->setInvalidDecl();
15607 
15608  // Add the exception declaration into this scope.
15609  if (II)
15610  PushOnScopeChains(ExDecl, S);
15611  else
15612  CurContext->addDecl(ExDecl);
15613 
15614  ProcessDeclAttributes(S, ExDecl, D);
15615  return ExDecl;
15616 }
15617 
15619  Expr *AssertExpr,
15620  Expr *AssertMessageExpr,
15621  SourceLocation RParenLoc) {
15622  StringLiteral *AssertMessage =
15623  AssertMessageExpr ? cast<StringLiteral>(AssertMessageExpr) : nullptr;
15624 
15625  if (DiagnoseUnexpandedParameterPack(AssertExpr, UPPC_StaticAssertExpression))
15626  return nullptr;
15627 
15628  return BuildStaticAssertDeclaration(StaticAssertLoc, AssertExpr,
15629  AssertMessage, RParenLoc, false);
15630 }
15631 
15633  Expr *AssertExpr,
15634  StringLiteral *AssertMessage,
15635  SourceLocation RParenLoc,
15636  bool Failed) {
15637  assert(AssertExpr != nullptr && "Expected non-null condition");
15638  if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent() &&
15639  !Failed) {
15640  // In a static_assert-declaration, the constant-expression shall be a
15641  // constant expression that can be contextually converted to bool.
15642  ExprResult Converted = PerformContextuallyConvertToBool(AssertExpr);
15643  if (Converted.isInvalid())
15644  Failed = true;
15645 
15646  ExprResult FullAssertExpr =
15647  ActOnFinishFullExpr(Converted.get(), StaticAssertLoc,
15648  /*DiscardedValue*/ false,
15649  /*IsConstexpr*/ true);
15650  if (FullAssertExpr.isInvalid())
15651  Failed = true;
15652  else
15653  AssertExpr = FullAssertExpr.get();
15654 
15655  llvm::APSInt Cond;
15656  if (!Failed && VerifyIntegerConstantExpression(AssertExpr, &Cond,
15657  diag::err_static_assert_expression_is_not_constant,
15658  /*AllowFold=*/false).isInvalid())
15659  Failed = true;
15660 
15661  if (!Failed && !Cond) {
15662  SmallString<256> MsgBuffer;
15663  llvm::raw_svector_ostream Msg(MsgBuffer);
15664  if (AssertMessage)
15665  AssertMessage->printPretty(Msg, nullptr, getPrintingPolicy());
15666 
15667  Expr *InnerCond = nullptr;
15668  std::string InnerCondDescription;
15669  std::tie(InnerCond, InnerCondDescription) =
15670  findFailedBooleanCondition(Converted.get());
15671  if (InnerCond && isa<ConceptSpecializationExpr>(InnerCond)) {
15672  // Drill down into concept specialization expressions to see why they
15673  // weren't satisfied.
15674  Diag(StaticAssertLoc, diag::err_static_assert_failed)
15675  << !AssertMessage << Msg.str() << AssertExpr->getSourceRange();
15676  ConstraintSatisfaction Satisfaction;
15677  if (!CheckConstraintSatisfaction(InnerCond, Satisfaction))
15678  DiagnoseUnsatisfiedConstraint(Satisfaction);
15679  } else if (InnerCond && !isa<CXXBoolLiteralExpr>(InnerCond)
15680  && !isa<IntegerLiteral>(InnerCond)) {
15681  Diag(StaticAssertLoc, diag::err_static_assert_requirement_failed)
15682  << InnerCondDescription << !AssertMessage
15683  << Msg.str() << InnerCond->getSourceRange();
15684  } else {
15685  Diag(StaticAssertLoc, diag::err_static_assert_failed)
15686  << !AssertMessage << Msg.str() << AssertExpr->getSourceRange();
15687  }
15688  Failed = true;
15689  }
15690  } else {
15691  ExprResult FullAssertExpr = ActOnFinishFullExpr(AssertExpr, StaticAssertLoc,
15692  /*DiscardedValue*/false,
15693  /*IsConstexpr*/true);
15694  if (FullAssertExpr.isInvalid())
15695  Failed = true;
15696  else
15697  AssertExpr = FullAssertExpr.get();
15698  }
15699 
15700  Decl *Decl = StaticAssertDecl::Create(Context, CurContext, StaticAssertLoc,
15701  AssertExpr, AssertMessage, RParenLoc,
15702  Failed);
15703 
15704  CurContext->addDecl(Decl);
15705  return Decl;
15706 }
15707 
15708 /// Perform semantic analysis of the given friend type declaration.
15709 ///
15710 /// \returns A friend declaration that.
15712  SourceLocation FriendLoc,
15713  TypeSourceInfo *TSInfo) {
15714  assert(TSInfo && "NULL TypeSourceInfo for friend type declaration");
15715 
15716  QualType T = TSInfo->getType();
15717  SourceRange TypeRange = TSInfo->getTypeLoc().getLocalSourceRange();
15718 
15719  // C++03 [class.friend]p2:
15720  // An elaborated-type-specifier shall be used in a friend declaration
15721  // for a class.*
15722  //
15723  // * The class-key of the elaborated-type-specifier is required.
15724  if (!CodeSynthesisContexts.empty()) {
15725  // Do not complain about the form of friend template types during any kind
15726  // of code synthesis. For template instantiation, we will have complained
15727  // when the template was defined.
15728  } else {
15729  if (!T->isElaboratedTypeSpecifier()) {
15730  // If we evaluated the type to a record type, suggest putting
15731  // a tag in front.
15732  if (const RecordType *RT = T->getAs<RecordType>()) {
15733  RecordDecl *RD = RT->getDecl();
15734 
15735  SmallString<16> InsertionText(" ");
15736  InsertionText += RD->getKindName();
15737 
15738  Diag(TypeRange.getBegin(),
15739  getLangOpts().CPlusPlus11 ?
15740  diag::warn_cxx98_compat_unelaborated_friend_type :
15741  diag::ext_unelaborated_friend_type)
15742  << (unsigned) RD->getTagKind()
15743  << T
15744  << FixItHint::CreateInsertion(getLocForEndOfToken(FriendLoc),
15745  InsertionText);
15746  } else {
15747  Diag(FriendLoc,
15748  getLangOpts().CPlusPlus11 ?
15749  diag::warn_cxx98_compat_nonclass_type_friend :
15750  diag::ext_nonclass_type_friend)
15751  << T
15752  << TypeRange;
15753  }
15754  } else if (T->getAs<EnumType>()) {
15755  Diag(FriendLoc,
15756  getLangOpts().CPlusPlus11 ?
15757  diag::warn_cxx98_compat_enum_friend :
15758  diag::ext_enum_friend)
15759  << T
15760  << TypeRange;
15761  }
15762 
15763  // C++11 [class.friend]p3:
15764  // A friend declaration that does not declare a function shall have one
15765  // of the following forms:
15766  // friend elaborated-type-specifier ;
15767  // friend simple-type-specifier ;
15768  // friend typename-specifier ;
15769  if (getLangOpts().CPlusPlus11 && LocStart != FriendLoc)
15770  Diag(FriendLoc, diag::err_friend_not_first_in_declaration) << T;
15771  }
15772 
15773  // If the type specifier in a friend declaration designates a (possibly
15774  // cv-qualified) class type, that class is declared as a friend; otherwise,
15775  // the friend declaration is ignored.
15776  return FriendDecl::Create(Context, CurContext,
15777  TSInfo->getTypeLoc().getBeginLoc(), TSInfo,
15778  FriendLoc);
15779 }
15780 
15781 /// Handle a friend tag declaration where the scope specifier was
15782 /// templated.
15784  unsigned TagSpec, SourceLocation TagLoc,
15785  CXXScopeSpec &SS, IdentifierInfo *Name,
15786  SourceLocation NameLoc,
15787  const ParsedAttributesView &Attr,
15788  MultiTemplateParamsArg TempParamLists) {
15790 
15791  bool IsMemberSpecialization = false;
15792  bool Invalid = false;
15793 
15794  if (TemplateParameterList *TemplateParams =
15795  MatchTemplateParametersToScopeSpecifier(
15796  TagLoc, NameLoc, SS, nullptr, TempParamLists, /*friend*/ true,
15797  IsMemberSpecialization, Invalid)) {
15798  if (TemplateParams->size() > 0) {
15799  // This is a declaration of a class template.
15800  if (Invalid)
15801  return nullptr;
15802 
15803  return CheckClassTemplate(S, TagSpec, TUK_Friend, TagLoc, SS, Name,
15804  NameLoc, Attr, TemplateParams, AS_public,
15805  /*ModulePrivateLoc=*/SourceLocation(),
15806  FriendLoc, TempParamLists.size() - 1,
15807  TempParamLists.data()).get();
15808  } else {
15809  // The "template<>" header is extraneous.
15810  Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
15811  << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
15812  IsMemberSpecialization = true;
15813  }
15814  }
15815 
15816  if (Invalid) return nullptr;
15817 
15818  bool isAllExplicitSpecializations = true;
15819  for (unsigned I = TempParamLists.size(); I-- > 0; ) {
15820  if (TempParamLists[I]->size()) {
15821  isAllExplicitSpecializations = false;
15822  break;
15823  }
15824  }
15825 
15826  // FIXME: don't ignore attributes.
15827 
15828  // If it's explicit specializations all the way down, just forget
15829  // about the template header and build an appropriate non-templated
15830  // friend. TODO: for source fidelity, remember the headers.
15831  if (isAllExplicitSpecializations) {
15832  if (SS.isEmpty()) {
15833  bool Owned = false;
15834  bool IsDependent = false;
15835  return ActOnTag(S, TagSpec, TUK_Friend, TagLoc, SS, Name, NameLoc,
15836  Attr, AS_public,
15837  /*ModulePrivateLoc=*/SourceLocation(),
15838  MultiTemplateParamsArg(), Owned, IsDependent,
15839  /*ScopedEnumKWLoc=*/SourceLocation(),
15840  /*ScopedEnumUsesClassTag=*/false,
15841  /*UnderlyingType=*/TypeResult(),
15842  /*IsTypeSpecifier=*/false,
15843  /*IsTemplateParamOrArg=*/false);
15844  }
15845 
15846  NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
15847  ElaboratedTypeKeyword Keyword
15849  QualType T = CheckTypenameType(Keyword, TagLoc, QualifierLoc,
15850  *Name, NameLoc);
15851  if (T.isNull())
15852  return nullptr;
15853 
15854  TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
15855  if (isa<DependentNameType>(T)) {
15858  TL.setElaboratedKeywordLoc(TagLoc);
15859  TL.setQualifierLoc(QualifierLoc);
15860  TL.setNameLoc(NameLoc);
15861  } else {
15863  TL.setElaboratedKeywordLoc(TagLoc);
15864  TL.setQualifierLoc(QualifierLoc);
15865  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(NameLoc);
15866  }
15867 
15868  FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
15869  TSI, FriendLoc, TempParamLists);
15870  Friend->setAccess(AS_public);
15871  CurContext->addDecl(Friend);
15872  return Friend;
15873  }
15874 
15875  assert(SS.isNotEmpty() && "valid templated tag with no SS and no direct?");
15876 
15877 
15878 
15879  // Handle the case of a templated-scope friend class. e.g.
15880  // template <class T> class A<T>::B;
15881  // FIXME: we don't support these right now.
15882  Diag(NameLoc, diag::warn_template_qualified_friend_unsupported)
15883  << SS.getScopeRep() << SS.getRange() << cast<CXXRecordDecl>(CurContext);
15885  QualType T = Context.getDependentNameType(ETK, SS.getScopeRep(), Name);
15886  TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
15888  TL.setElaboratedKeywordLoc(TagLoc);
15889  TL.setQualifierLoc(SS.getWithLocInContext(Context));
15890  TL.setNameLoc(NameLoc);
15891 
15892  FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
15893  TSI, FriendLoc, TempParamLists);
15894  Friend->setAccess(AS_public);
15895  Friend->setUnsupportedFriend(true);
15896  CurContext->addDecl(Friend);
15897  return Friend;
15898 }
15899 
15900 /// Handle a friend type declaration. This works in tandem with
15901 /// ActOnTag.
15902 ///
15903 /// Notes on friend class templates:
15904 ///
15905 /// We generally treat friend class declarations as if they were
15906 /// declaring a class. So, for example, the elaborated type specifier
15907 /// in a friend declaration is required to obey the restrictions of a
15908 /// class-head (i.e. no typedefs in the scope chain), template
15909 /// parameters are required to match up with simple template-ids, &c.
15910 /// However, unlike when declaring a template specialization, it's
15911 /// okay to refer to a template specialization without an empty
15912 /// template parameter declaration, e.g.
15913 /// friend class A<T>::B<unsigned>;
15914 /// We permit this as a special case; if there are any template
15915 /// parameters present at all, require proper matching, i.e.
15916 /// template <> template <class T> friend class A<int>::B;
15918  MultiTemplateParamsArg TempParams) {
15919  SourceLocation Loc = DS.getBeginLoc();
15920 
15921  assert(DS.isFriendSpecified());
15923 
15924  // C++ [class.friend]p3:
15925  // A friend declaration that does not declare a function shall have one of
15926  // the following forms:
15927  // friend elaborated-type-specifier ;
15928  // friend simple-type-specifier ;
15929  // friend typename-specifier ;
15930  //
15931  // Any declaration with a type qualifier does not have that form. (It's
15932  // legal to specify a qualified type as a friend, you just can't write the
15933  // keywords.)
15934  if (DS.getTypeQualifiers()) {
15936  Diag(DS.getConstSpecLoc(), diag::err_friend_decl_spec) << "const";
15938  Diag(DS.getVolatileSpecLoc(), diag::err_friend_decl_spec) << "volatile";
15940  Diag(DS.getRestrictSpecLoc(), diag::err_friend_decl_spec) << "restrict";
15942  Diag(DS.getAtomicSpecLoc(), diag::err_friend_decl_spec) << "_Atomic";
15944  Diag(DS.getUnalignedSpecLoc(), diag::err_friend_decl_spec) << "__unaligned";
15945  }
15946 
15947  // Try to convert the decl specifier to a type. This works for
15948  // friend templates because ActOnTag never produces a ClassTemplateDecl
15949  // for a TUK_Friend.
15950  Declarator TheDeclarator(DS, DeclaratorContext::MemberContext);
15951  TypeSourceInfo *TSI = GetTypeForDeclarator(TheDeclarator, S);
15952  QualType T = TSI->getType();
15953  if (TheDeclarator.isInvalidType())
15954  return nullptr;
15955 
15956  if (DiagnoseUnexpandedParameterPack(Loc, TSI, UPPC_FriendDeclaration))
15957  return nullptr;
15958 
15959  // This is definitely an error in C++98. It's probably meant to
15960  // be forbidden in C++0x, too, but the specification is just
15961  // poorly written.
15962  //
15963  // The problem is with declarations like the following:
15964  // template <T> friend A<T>::foo;
15965  // where deciding whether a class C is a friend or not now hinges
15966  // on whether there exists an instantiation of A that causes
15967  // 'foo' to equal C. There are restrictions on class-heads
15968  // (which we declare (by fiat) elaborated friend declarations to
15969  // be) that makes this tractable.
15970  //
15971  // FIXME: handle "template <> friend class A<T>;", which
15972  // is possibly well-formed? Who even knows?
15973  if (TempParams.size() && !T->isElaboratedTypeSpecifier()) {
15974  Diag(Loc, diag::err_tagless_friend_type_template)
15975  << DS.getSourceRange();
15976  return nullptr;
15977  }
15978 
15979  // C++98 [class.friend]p1: A friend of a class is a function
15980  // or class that is not a member of the class . . .
15981  // This is fixed in DR77, which just barely didn't make the C++03
15982  // deadline. It's also a very silly restriction that seriously
15983  // affects inner classes and which nobody else seems to implement;
15984  // thus we never diagnose it, not even in -pedantic.
15985  //
15986  // But note that we could warn about it: it's always useless to
15987  // friend one of your own members (it's not, however, worthless to
15988  // friend a member of an arbitrary specialization of your template).
15989 
15990  Decl *D;
15991  if (!TempParams.empty())
15992  D = FriendTemplateDecl::Create(Context, CurContext, Loc,
15993  TempParams,
15994  TSI,
15995  DS.getFriendSpecLoc());
15996  else
15997  D = CheckFriendTypeDecl(Loc, DS.getFriendSpecLoc(), TSI);
15998 
15999  if (!D)
16000  return nullptr;
16001 
16002  D->setAccess(AS_public);
16003  CurContext->addDecl(D);
16004 
16005  return D;
16006 }
16007 
16009  MultiTemplateParamsArg TemplateParams) {
16010  const DeclSpec &DS = D.getDeclSpec();
16011 
16012  assert(DS.isFriendSpecified());
16014 
16015  SourceLocation Loc = D.getIdentifierLoc();
16016  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
16017 
16018  // C++ [class.friend]p1
16019  // A friend of a class is a function or class....
16020  // Note that this sees through typedefs, which is intended.
16021  // It *doesn't* see through dependent types, which is correct
16022  // according to [temp.arg.type]p3:
16023  // If a declaration acquires a function type through a
16024  // type dependent on a template-parameter and this causes
16025  // a declaration that does not use the syntactic form of a
16026  // function declarator to have a function type, the program
16027  // is ill-formed.
16028  if (!TInfo->getType()->isFunctionType()) {
16029  Diag(Loc, diag::err_unexpected_friend);
16030 
16031  // It might be worthwhile to try to recover by creating an
16032  // appropriate declaration.
16033  return nullptr;
16034  }
16035 
16036  // C++ [namespace.memdef]p3
16037  // - If a friend declaration in a non-local class first declares a
16038  // class or function, the friend class or function is a member
16039  // of the innermost enclosing namespace.
16040  // - The name of the friend is not found by simple name lookup
16041  // until a matching declaration is provided in that namespace
16042  // scope (either before or after the class declaration granting
16043  // friendship).
16044  // - If a friend function is called, its name may be found by the
16045  // name lookup that considers functions from namespaces and
16046  // classes associated with the types of the function arguments.
16047  // - When looking for a prior declaration of a class or a function
16048  // declared as a friend, scopes outside the innermost enclosing
16049  // namespace scope are not considered.
16050 
16051  CXXScopeSpec &SS = D.getCXXScopeSpec();
16052  DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
16053  assert(NameInfo.getName());
16054 
16055  // Check for unexpanded parameter packs.
16056  if (DiagnoseUnexpandedParameterPack(Loc, TInfo, UPPC_FriendDeclaration) ||
16057  DiagnoseUnexpandedParameterPack(NameInfo, UPPC_FriendDeclaration) ||
16058  DiagnoseUnexpandedParameterPack(SS, UPPC_FriendDeclaration))
16059  return nullptr;
16060 
16061  // The context we found the declaration in, or in which we should
16062  // create the declaration.
16063  DeclContext *DC;
16064  Scope *DCScope = S;
16065  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
16066  ForExternalRedeclaration);
16067 
16068  // There are five cases here.
16069  // - There's no scope specifier and we're in a local class. Only look
16070  // for functions declared in the immediately-enclosing block scope.
16071  // We recover from invalid scope qualifiers as if they just weren't there.
16072  FunctionDecl *FunctionContainingLocalClass = nullptr;
16073  if ((SS.isInvalid() || !SS.isSet()) &&
16074  (FunctionContainingLocalClass =
16075  cast<CXXRecordDecl>(CurContext)->isLocalClass())) {
16076  // C++11 [class.friend]p11:
16077  // If a friend declaration appears in a local class and the name
16078  // specified is an unqualified name, a prior declaration is
16079  // looked up without considering scopes that are outside the
16080  // innermost enclosing non-class scope. For a friend function
16081  // declaration, if there is no prior declaration, the program is
16082  // ill-formed.
16083 
16084  // Find the innermost enclosing non-class scope. This is the block
16085  // scope containing the local class definition (or for a nested class,
16086  // the outer local class).
16087  DCScope = S->getFnParent();
16088 
16089  // Look up the function name in the scope.
16090  Previous.clear(LookupLocalFriendName);
16091  LookupName(Previous, S, /*AllowBuiltinCreation*/false);
16092 
16093  if (!Previous.empty()) {
16094  // All possible previous declarations must have the same context:
16095  // either they were declared at block scope or they are members of
16096  // one of the enclosing local classes.
16097  DC = Previous.getRepresentativeDecl()->getDeclContext();
16098  } else {
16099  // This is ill-formed, but provide the context that we would have
16100  // declared the function in, if we were permitted to, for error recovery.
16101  DC = FunctionContainingLocalClass;
16102  }
16103  adjustContextForLocalExternDecl(DC);
16104 
16105  // C++ [class.friend]p6:
16106  // A function can be defined in a friend declaration of a class if and
16107  // only if the class is a non-local class (9.8), the function name is
16108  // unqualified, and the function has namespace scope.
16109  if (D.isFunctionDefinition()) {
16110  Diag(NameInfo.getBeginLoc(), diag::err_friend_def_in_local_class);
16111  }
16112 
16113  // - There's no scope specifier, in which case we just go to the
16114  // appropriate scope and look for a function or function template
16115  // there as appropriate.
16116  } else if (SS.isInvalid() || !SS.isSet()) {
16117  // C++11 [namespace.memdef]p3:
16118  // If the name in a friend declaration is neither qualified nor
16119  // a template-id and the declaration is a function or an
16120  // elaborated-type-specifier, the lookup to determine whether
16121  // the entity has been previously declared shall not consider
16122  // any scopes outside the innermost enclosing namespace.
16123  bool isTemplateId =
16125 
16126  // Find the appropriate context according to the above.
16127  DC = CurContext;
16128 
16129  // Skip class contexts. If someone can cite chapter and verse
16130  // for this behavior, that would be nice --- it's what GCC and
16131  // EDG do, and it seems like a reasonable intent, but the spec
16132  // really only says that checks for unqualified existing
16133  // declarations should stop at the nearest enclosing namespace,
16134  // not that they should only consider the nearest enclosing
16135  // namespace.
16136  while (DC->isRecord())
16137  DC = DC->getParent();
16138 
16139  DeclContext *LookupDC = DC;
16140  while (LookupDC->isTransparentContext())
16141  LookupDC = LookupDC->getParent();
16142 
16143  while (true) {
16144  LookupQualifiedName(Previous, LookupDC);
16145 
16146  if (!Previous.empty()) {
16147  DC = LookupDC;
16148  break;
16149  }
16150 
16151  if (isTemplateId) {
16152  if (isa<TranslationUnitDecl>(LookupDC)) break;
16153  } else {
16154  if (LookupDC->isFileContext()) break;
16155  }
16156  LookupDC = LookupDC->getParent();
16157  }
16158 
16159  DCScope = getScopeForDeclContext(S, DC);
16160 
16161  // - There's a non-dependent scope specifier, in which case we
16162  // compute it and do a previous lookup there for a function
16163  // or function template.
16164  } else if (!SS.getScopeRep()->isDependent()) {
16165  DC = computeDeclContext(SS);
16166  if (!DC) return nullptr;
16167 
16168  if (RequireCompleteDeclContext(SS, DC)) return nullptr;
16169 
16170  LookupQualifiedName(Previous, DC);
16171 
16172  // C++ [class.friend]p1: A friend of a class is a function or
16173  // class that is not a member of the class . . .
16174  if (DC->Equals(CurContext))
16175  Diag(DS.getFriendSpecLoc(),
16176  getLangOpts().CPlusPlus11 ?
16177  diag::warn_cxx98_compat_friend_is_member :
16178  diag::err_friend_is_member);
16179 
16180  if (D.isFunctionDefinition()) {
16181  // C++ [class.friend]p6:
16182  // A function can be defined in a friend declaration of a class if and
16183  // only if the class is a non-local class (9.8), the function name is
16184  // unqualified, and the function has namespace scope.
16185  //
16186  // FIXME: We should only do this if the scope specifier names the
16187  // innermost enclosing namespace; otherwise the fixit changes the
16188  // meaning of the code.
16190  = Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def);
16191 
16192  DB << SS.getScopeRep();
16193  if (DC->isFileContext())
16194  DB << FixItHint::CreateRemoval(SS.getRange());
16195  SS.clear();
16196  }
16197 
16198  // - There's a scope specifier that does not match any template
16199  // parameter lists, in which case we use some arbitrary context,
16200  // create a method or method template, and wait for instantiation.
16201  // - There's a scope specifier that does match some template
16202  // parameter lists, which we don't handle right now.
16203  } else {
16204  if (D.isFunctionDefinition()) {
16205  // C++ [class.friend]p6:
16206  // A function can be defined in a friend declaration of a class if and
16207  // only if the class is a non-local class (9.8), the function name is
16208  // unqualified, and the function has namespace scope.
16209  Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def)
16210  << SS.getScopeRep();
16211  }
16212 
16213  DC = CurContext;
16214  assert(isa<CXXRecordDecl>(DC) && "friend declaration not in class?");
16215  }
16216 
16217  if (!DC->isRecord()) {
16218  int DiagArg = -1;
16219  switch (D.getName().getKind()) {
16222  DiagArg = 0;
16223  break;
16225  DiagArg = 1;
16226  break;
16228  DiagArg = 2;
16229  break;
16231  DiagArg = 3;
16232  break;
16238  break;
16239  }
16240  // This implies that it has to be an operator or function.
16241  if (DiagArg >= 0) {
16242  Diag(Loc, diag::err_introducing_special_friend) << DiagArg;
16243  return nullptr;
16244  }
16245  }
16246 
16247  // FIXME: This is an egregious hack to cope with cases where the scope stack
16248  // does not contain the declaration context, i.e., in an out-of-line
16249  // definition of a class.
16250  Scope FakeDCScope(S, Scope::DeclScope, Diags);
16251  if (!DCScope) {
16252  FakeDCScope.setEntity(DC);
16253  DCScope = &FakeDCScope;
16254  }
16255 
16256  bool AddToScope = true;
16257  NamedDecl *ND = ActOnFunctionDeclarator(DCScope, D, DC, TInfo, Previous,
16258  TemplateParams, AddToScope);
16259  if (!ND) return nullptr;
16260 
16261  assert(ND->getLexicalDeclContext() == CurContext);
16262 
16263  // If we performed typo correction, we might have added a scope specifier
16264  // and changed the decl context.
16265  DC = ND->getDeclContext();
16266 
16267  // Add the function declaration to the appropriate lookup tables,
16268  // adjusting the redeclarations list as necessary. We don't
16269  // want to do this yet if the friending class is dependent.
16270  //
16271  // Also update the scope-based lookup if the target context's
16272  // lookup context is in lexical scope.
16273  if (!CurContext->isDependentContext()) {
16274  DC = DC->getRedeclContext();
16275  DC->makeDeclVisibleInContext(ND);
16276  if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
16277  PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
16278  }
16279 
16280  FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
16281  D.getIdentifierLoc(), ND,
16282  DS.getFriendSpecLoc());
16283  FrD->setAccess(AS_public);
16284  CurContext->addDecl(FrD);
16285 
16286  if (ND->isInvalidDecl()) {
16287  FrD->setInvalidDecl();
16288  } else {
16289  if (DC->isRecord()) CheckFriendAccess(ND);
16290 
16291  FunctionDecl *FD;
16292  if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
16293  FD = FTD->getTemplatedDecl();
16294  else
16295  FD = cast<FunctionDecl>(ND);
16296 
16297  // C++11 [dcl.fct.default]p4: If a friend declaration specifies a
16298  // default argument expression, that declaration shall be a definition
16299  // and shall be the only declaration of the function or function
16300  // template in the translation unit.
16302  // We can't look at FD->getPreviousDecl() because it may not have been set
16303  // if we're in a dependent context. If the function is known to be a
16304  // redeclaration, we will have narrowed Previous down to the right decl.
16305  if (D.isRedeclaration()) {
16306  Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
16307  Diag(Previous.getRepresentativeDecl()->getLocation(),
16308  diag::note_previous_declaration);
16309  } else if (!D.isFunctionDefinition())
16310  Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_must_be_def);
16311  }
16312 
16313  // Mark templated-scope function declarations as unsupported.
16314  if (FD->getNumTemplateParameterLists() && SS.isValid()) {
16315  Diag(FD->getLocation(), diag::warn_template_qualified_friend_unsupported)
16316  << SS.getScopeRep() << SS.getRange()
16317  << cast<CXXRecordDecl>(CurContext);
16318  FrD->setUnsupportedFriend(true);
16319  }
16320  }
16321 
16322  return ND;
16323 }
16324 
16325 void Sema::SetDeclDeleted(Decl *Dcl, SourceLocation DelLoc) {
16326  AdjustDeclIfTemplate(Dcl);
16327 
16328  FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Dcl);
16329  if (!Fn) {
16330  Diag(DelLoc, diag::err_deleted_non_function);
16331  return;
16332  }
16333 
16334  // Deleted function does not have a body.
16335  Fn->setWillHaveBody(false);
16336 
16337  if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
16338  // Don't consider the implicit declaration we generate for explicit
16339  // specializations. FIXME: Do not generate these implicit declarations.
16340  if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization ||
16341  Prev->getPreviousDecl()) &&
16342  !Prev->isDefined()) {
16343  Diag(DelLoc, diag::err_deleted_decl_not_first);
16344  Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
16345  Prev->isImplicit() ? diag::note_previous_implicit_declaration
16346  : diag::note_previous_declaration);
16347  }
16348  // If the declaration wasn't the first, we delete the function anyway for
16349  // recovery.
16350  Fn = Fn->getCanonicalDecl();
16351  }
16352 
16353  // dllimport/dllexport cannot be deleted.
16354  if (const InheritableAttr *DLLAttr = getDLLAttr(Fn)) {
16355  Diag(Fn->getLocation(), diag::err_attribute_dll_deleted) << DLLAttr;
16356  Fn->setInvalidDecl();
16357  }
16358 
16359  if (Fn->isDeleted())
16360  return;
16361 
16362  // C++11 [basic.start.main]p3:
16363  // A program that defines main as deleted [...] is ill-formed.
16364  if (Fn->isMain())
16365  Diag(DelLoc, diag::err_deleted_main);
16366 
16367  // C++11 [dcl.fct.def.delete]p4:
16368  // A deleted function is implicitly inline.
16369  Fn->setImplicitlyInline();
16370  Fn->setDeletedAsWritten();
16371 
16372  // See if we're deleting a function which is already known to override a
16373  // non-deleted virtual function.
16374  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn)) {
16375  bool IssuedDiagnostic = false;
16376  for (const CXXMethodDecl *O : MD->overridden_methods()) {
16377  if (!(*MD->begin_overridden_methods())->isDeleted()) {
16378  if (!IssuedDiagnostic) {
16379  Diag(DelLoc, diag::err_deleted_override) << MD->getDeclName();
16380  IssuedDiagnostic = true;
16381  }
16382  Diag(O->getLocation(), diag::note_overridden_virtual_function);
16383  }
16384  }
16385  // If this function was implicitly deleted because it was defaulted,
16386  // explain why it was deleted.
16387  if (IssuedDiagnostic && MD->isDefaulted())
16388  DiagnoseDeletedDefaultedFunction(MD);
16389  }
16390 }
16391 
16392 void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) {
16393  if (!Dcl || Dcl->isInvalidDecl())
16394  return;
16395 
16396  auto *FD = dyn_cast<FunctionDecl>(Dcl);
16397  if (!FD) {
16398  if (auto *FTD = dyn_cast<FunctionTemplateDecl>(Dcl)) {
16399  if (getDefaultedFunctionKind(FTD->getTemplatedDecl()).isComparison()) {
16400  Diag(DefaultLoc, diag::err_defaulted_comparison_template);
16401  return;
16402  }
16403  }
16404 
16405  Diag(DefaultLoc, diag::err_default_special_members)
16406  << getLangOpts().CPlusPlus2a;
16407  return;
16408  }
16409 
16410  // Reject if this can't possibly be a defaultable function.
16411  DefaultedFunctionKind DefKind = getDefaultedFunctionKind(FD);
16412  if (!DefKind &&
16413  // A dependent function that doesn't locally look defaultable can
16414  // still instantiate to a defaultable function if it's a constructor
16415  // or assignment operator.
16416  (!FD->isDependentContext() ||
16417  (!isa<CXXConstructorDecl>(FD) &&
16418  FD->getDeclName().getCXXOverloadedOperator() != OO_Equal))) {
16419  Diag(DefaultLoc, diag::err_default_special_members)
16420  << getLangOpts().CPlusPlus2a;
16421  return;
16422  }
16423 
16424  if (DefKind.isComparison() &&
16425  !isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
16426  Diag(FD->getLocation(), diag::err_defaulted_comparison_out_of_class)
16427  << (int)DefKind.asComparison();
16428  return;
16429  }
16430 
16431  // Issue compatibility warning. We already warned if the operator is
16432  // 'operator<=>' when parsing the '<=>' token.
16433  if (DefKind.isComparison() &&
16434  DefKind.asComparison() != DefaultedComparisonKind::ThreeWay) {
16435  Diag(DefaultLoc, getLangOpts().CPlusPlus2a
16436  ? diag::warn_cxx17_compat_defaulted_comparison
16437  : diag::ext_defaulted_comparison);
16438  }
16439 
16440  FD->setDefaulted();
16441  FD->setExplicitlyDefaulted();
16442 
16443  // Defer checking functions that are defaulted in a dependent context.
16444  if (FD->isDependentContext())
16445  return;
16446 
16447  // Unset that we will have a body for this function. We might not,
16448  // if it turns out to be trivial, and we don't need this marking now
16449  // that we've marked it as defaulted.
16450  FD->setWillHaveBody(false);
16451 
16452  // If this definition appears within the record, do the checking when
16453  // the record is complete. This is always the case for a defaulted
16454  // comparison.
16455  if (DefKind.isComparison())
16456  return;
16457  auto *MD = cast<CXXMethodDecl>(FD);
16458 
16459  const FunctionDecl *Primary = FD;
16460  if (const FunctionDecl *Pattern = FD->getTemplateInstantiationPattern())
16461  // Ask the template instantiation pattern that actually had the
16462  // '= default' on it.
16463  Primary = Pattern;
16464 
16465  // If the method was defaulted on its first declaration, we will have
16466  // already performed the checking in CheckCompletedCXXClass. Such a
16467  // declaration doesn't trigger an implicit definition.
16468  if (Primary->getCanonicalDecl()->isDefaulted())
16469  return;
16470 
16471  if (CheckExplicitlyDefaultedSpecialMember(MD, DefKind.asSpecialMember()))
16472  MD->setInvalidDecl();
16473  else
16474  DefineImplicitSpecialMember(*this, MD, DefaultLoc);
16475 }
16476 
16477 static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
16478  for (Stmt *SubStmt : S->children()) {
16479  if (!SubStmt)
16480  continue;
16481  if (isa<ReturnStmt>(SubStmt))
16482  Self.Diag(SubStmt->getBeginLoc(),
16483  diag::err_return_in_constructor_handler);
16484  if (!isa<Expr>(SubStmt))
16485  SearchForReturnInStmt(Self, SubStmt);
16486  }
16487 }
16488 
16490  for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
16491  CXXCatchStmt *Handler = TryBlock->getHandler(I);
16492  SearchForReturnInStmt(*this, Handler);
16493  }
16494 }
16495 
16497  const CXXMethodDecl *Old) {
16498  const auto *NewFT = New->getType()->castAs<FunctionProtoType>();
16499  const auto *OldFT = Old->getType()->castAs<FunctionProtoType>();
16500 
16501  if (OldFT->hasExtParameterInfos()) {
16502  for (unsigned I = 0, E = OldFT->getNumParams(); I != E; ++I)
16503  // A parameter of the overriding method should be annotated with noescape
16504  // if the corresponding parameter of the overridden method is annotated.
16505  if (OldFT->getExtParameterInfo(I).isNoEscape() &&
16506  !NewFT->getExtParameterInfo(I).isNoEscape()) {
16507  Diag(New->getParamDecl(I)->getLocation(),
16508  diag::warn_overriding_method_missing_noescape);
16509  Diag(Old->getParamDecl(I)->getLocation(),
16510  diag::note_overridden_marked_noescape);
16511  }
16512  }
16513 
16514  // Virtual overrides must have the same code_seg.
16515  const auto *OldCSA = Old->getAttr<CodeSegAttr>();
16516  const auto *NewCSA = New->getAttr<CodeSegAttr>();
16517  if ((NewCSA || OldCSA) &&
16518  (!OldCSA || !NewCSA || NewCSA->getName() != OldCSA->getName())) {
16519  Diag(New->getLocation(), diag::err_mismatched_code_seg_override);
16520  Diag(Old->getLocation(), diag::note_previous_declaration);
16521  return true;
16522  }
16523 
16524  CallingConv NewCC = NewFT->getCallConv(), OldCC = OldFT->getCallConv();
16525 
16526  // If the calling conventions match, everything is fine
16527  if (NewCC == OldCC)
16528  return false;
16529 
16530  // If the calling conventions mismatch because the new function is static,
16531  // suppress the calling convention mismatch error; the error about static
16532  // function override (err_static_overrides_virtual from
16533  // Sema::CheckFunctionDeclaration) is more clear.
16534  if (New->getStorageClass() == SC_Static)
16535  return false;
16536 
16537  Diag(New->getLocation(),
16538  diag::err_conflicting_overriding_cc_attributes)
16539  << New->getDeclName() << New->getType() << Old->getType();
16540  Diag(Old->getLocation(), diag::note_overridden_virtual_function);
16541  return true;
16542 }
16543 
16545  const CXXMethodDecl *Old) {
16546  QualType NewTy = New->getType()->castAs<FunctionType>()->getReturnType();
16547  QualType OldTy = Old->getType()->castAs<FunctionType>()->getReturnType();
16548 
16549  if (Context.hasSameType(NewTy, OldTy) ||
16550  NewTy->isDependentType() || OldTy->isDependentType())
16551  return false;
16552 
16553  // Check if the return types are covariant
16554  QualType NewClassTy, OldClassTy;
16555 
16556  /// Both types must be pointers or references to classes.
16557  if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
16558  if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
16559  NewClassTy = NewPT->getPointeeType();
16560  OldClassTy = OldPT->getPointeeType();
16561  }
16562  } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
16563  if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
16564  if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
16565  NewClassTy = NewRT->getPointeeType();
16566  OldClassTy = OldRT->getPointeeType();
16567  }
16568  }
16569  }
16570 
16571  // The return types aren't either both pointers or references to a class type.
16572  if (NewClassTy.isNull()) {
16573  Diag(New->getLocation(),
16574  diag::err_different_return_type_for_overriding_virtual_function)
16575  << New->getDeclName() << NewTy << OldTy
16576  << New->getReturnTypeSourceRange();
16577  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
16578  << Old->getReturnTypeSourceRange();
16579 
16580  return true;
16581  }
16582 
16583  if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
16584  // C++14 [class.virtual]p8:
16585  // If the class type in the covariant return type of D::f differs from
16586  // that of B::f, the class type in the return type of D::f shall be
16587  // complete at the point of declaration of D::f or shall be the class
16588  // type D.
16589  if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
16590  if (!RT->isBeingDefined() &&
16591  RequireCompleteType(New->getLocation(), NewClassTy,
16592  diag::err_covariant_return_incomplete,
16593  New->getDeclName()))
16594  return true;
16595  }
16596 
16597  // Check if the new class derives from the old class.
16598  if (!IsDerivedFrom(New->getLocation(), NewClassTy, OldClassTy)) {
16599  Diag(New->getLocation(), diag::err_covariant_return_not_derived)
16600  << New->getDeclName() << NewTy << OldTy
16601  << New->getReturnTypeSourceRange();
16602  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
16603  << Old->getReturnTypeSourceRange();
16604  return true;
16605  }
16606 
16607  // Check if we the conversion from derived to base is valid.
16608  if (CheckDerivedToBaseConversion(
16609  NewClassTy, OldClassTy,
16610  diag::err_covariant_return_inaccessible_base,
16611  diag::err_covariant_return_ambiguous_derived_to_base_conv,
16612  New->getLocation(), New->getReturnTypeSourceRange(),
16613  New->getDeclName(), nullptr)) {
16614  // FIXME: this note won't trigger for delayed access control
16615  // diagnostics, and it's impossible to get an undelayed error
16616  // here from access control during the original parse because
16617  // the ParsingDeclSpec/ParsingDeclarator are still in scope.
16618  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
16619  << Old->getReturnTypeSourceRange();
16620  return true;
16621  }
16622  }
16623 
16624  // The qualifiers of the return types must be the same.
16625  if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
16626  Diag(New->getLocation(),
16627  diag::err_covariant_return_type_different_qualifications)
16628  << New->getDeclName() << NewTy << OldTy
16629  << New->getReturnTypeSourceRange();
16630  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
16631  << Old->getReturnTypeSourceRange();
16632  return true;
16633  }
16634 
16635 
16636  // The new class type must have the same or less qualifiers as the old type.
16637  if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
16638  Diag(New->getLocation(),
16639  diag::err_covariant_return_type_class_type_more_qualified)
16640  << New->getDeclName() << NewTy << OldTy
16641  << New->getReturnTypeSourceRange();
16642  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
16643  << Old->getReturnTypeSourceRange();
16644  return true;
16645  }
16646 
16647  return false;
16648 }
16649 
16650 /// Mark the given method pure.
16651 ///
16652 /// \param Method the method to be marked pure.
16653 ///
16654 /// \param InitRange the source range that covers the "0" initializer.
16656  SourceLocation EndLoc = InitRange.getEnd();
16657  if (EndLoc.isValid())
16658  Method->setRangeEnd(EndLoc);
16659 
16660  if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
16661  Method->setPure();
16662  return false;
16663  }
16664 
16665  if (!Method->isInvalidDecl())
16666  Diag(Method->getLocation(), diag::err_non_virtual_pure)
16667  << Method->getDeclName() << InitRange;
16668  return true;
16669 }
16670 
16672  if (D->getFriendObjectKind())
16673  Diag(D->getLocation(), diag::err_pure_friend);
16674  else if (auto *M = dyn_cast<CXXMethodDecl>(D))
16675  CheckPureMethod(M, ZeroLoc);
16676  else
16677  Diag(D->getLocation(), diag::err_illegal_initializer);
16678 }
16679 
16680 /// Determine whether the given declaration is a global variable or
16681 /// static data member.
16682 static bool isNonlocalVariable(const Decl *D) {
16683  if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(D))
16684  return Var->hasGlobalStorage();
16685 
16686  return false;
16687 }
16688 
16689 /// Invoked when we are about to parse an initializer for the declaration
16690 /// 'Dcl'.
16691 ///
16692 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
16693 /// static data member of class X, names should be looked up in the scope of
16694 /// class X. If the declaration had a scope specifier, a scope will have
16695 /// been created and passed in for this purpose. Otherwise, S will be null.
16697  // If there is no declaration, there was an error parsing it.
16698  if (!D || D->isInvalidDecl())
16699  return;
16700 
16701  // We will always have a nested name specifier here, but this declaration
16702  // might not be out of line if the specifier names the current namespace:
16703  // extern int n;
16704  // int ::n = 0;
16705  if (S && D->isOutOfLine())
16706  EnterDeclaratorContext(S, D->getDeclContext());
16707 
16708  // If we are parsing the initializer for a static data member, push a
16709  // new expression evaluation context that is associated with this static
16710  // data member.
16711  if (isNonlocalVariable(D))
16712  PushExpressionEvaluationContext(
16713  ExpressionEvaluationContext::PotentiallyEvaluated, D);
16714 }
16715 
16716 /// Invoked after we are finished parsing an initializer for the declaration D.
16718  // If there is no declaration, there was an error parsing it.
16719  if (!D || D->isInvalidDecl())
16720  return;
16721 
16722  if (isNonlocalVariable(D))
16723  PopExpressionEvaluationContext();
16724 
16725  if (S && D->isOutOfLine())
16726  ExitDeclaratorContext(S);
16727 }
16728 
16729 /// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
16730 /// C++ if/switch/while/for statement.
16731 /// e.g: "if (int x = f()) {...}"
16733  // C++ 6.4p2:
16734  // The declarator shall not specify a function or an array.
16735  // The type-specifier-seq shall not contain typedef and shall not declare a
16736  // new class or enumeration.
16738  "Parser allowed 'typedef' as storage class of condition decl.");
16739 
16740  Decl *Dcl = ActOnDeclarator(S, D);
16741  if (!Dcl)
16742  return true;
16743 
16744  if (isa<FunctionDecl>(Dcl)) { // The declarator shall not specify a function.
16745  Diag(Dcl->getLocation(), diag::err_invalid_use_of_function_type)
16746  << D.getSourceRange();
16747  return true;
16748  }
16749 
16750  return Dcl;
16751 }
16752 
16754  if (!ExternalSource)
16755  return;
16756 
16758  ExternalSource->ReadUsedVTables(VTables);
16759  SmallVector<VTableUse, 4> NewUses;
16760  for (unsigned I = 0, N = VTables.size(); I != N; ++I) {
16761  llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
16762  = VTablesUsed.find(VTables[I].Record);
16763  // Even if a definition wasn't required before, it may be required now.
16764  if (Pos != VTablesUsed.end()) {
16765  if (!Pos->second && VTables[I].DefinitionRequired)
16766  Pos->second = true;
16767  continue;
16768  }
16769 
16770  VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
16771  NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location));
16772  }
16773 
16774  VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end());
16775 }
16776 
16778  bool DefinitionRequired) {
16779  // Ignore any vtable uses in unevaluated operands or for classes that do
16780  // not have a vtable.
16781  if (!Class->isDynamicClass() || Class->isDependentContext() ||
16782  CurContext->isDependentContext() || isUnevaluatedContext())
16783  return;
16784  // Do not mark as used if compiling for the device outside of the target
16785  // region.
16786  if (LangOpts.OpenMP && LangOpts.OpenMPIsDevice &&
16787  !isInOpenMPDeclareTargetContext() &&
16788  !isInOpenMPTargetExecutionDirective()) {
16789  if (!DefinitionRequired)
16790  MarkVirtualMembersReferenced(Loc, Class);
16791  return;
16792  }
16793 
16794  // Try to insert this class into the map.
16795  LoadExternalVTableUses();
16796  Class = Class->getCanonicalDecl();
16797  std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator, bool>
16798  Pos = VTablesUsed.insert(std::make_pair(Class, DefinitionRequired));
16799  if (!Pos.second) {
16800  // If we already had an entry, check to see if we are promoting this vtable
16801  // to require a definition. If so, we need to reappend to the VTableUses
16802  // list, since we may have already processed the first entry.
16803  if (DefinitionRequired && !Pos.first->second) {
16804  Pos.first->second = true;
16805  } else {
16806  // Otherwise, we can early exit.
16807  return;
16808  }
16809  } else {
16810  // The Microsoft ABI requires that we perform the destructor body
16811  // checks (i.e. operator delete() lookup) when the vtable is marked used, as
16812  // the deleting destructor is emitted with the vtable, not with the
16813  // destructor definition as in the Itanium ABI.
16814  if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
16815  CXXDestructorDecl *DD = Class->getDestructor();
16816  if (DD && DD->isVirtual() && !DD->isDeleted()) {
16817  if (Class->hasUserDeclaredDestructor() && !DD->isDefined()) {
16818  // If this is an out-of-line declaration, marking it referenced will
16819  // not do anything. Manually call CheckDestructor to look up operator
16820  // delete().
16821  ContextRAII SavedContext(*this, DD);
16822  CheckDestructor(DD);
16823  } else {
16824  MarkFunctionReferenced(Loc, Class->getDestructor());
16825  }
16826  }
16827  }
16828  }
16829 
16830  // Local classes need to have their virtual members marked
16831  // immediately. For all other classes, we mark their virtual members
16832  // at the end of the translation unit.
16833  if (Class->isLocalClass())
16834  MarkVirtualMembersReferenced(Loc, Class);
16835  else
16836  VTableUses.push_back(std::make_pair(Class, Loc));
16837 }
16838 
16840  LoadExternalVTableUses();
16841  if (VTableUses.empty())
16842  return false;
16843 
16844  // Note: The VTableUses vector could grow as a result of marking
16845  // the members of a class as "used", so we check the size each
16846  // time through the loop and prefer indices (which are stable) to
16847  // iterators (which are not).
16848  bool DefinedAnything = false;
16849  for (unsigned I = 0; I != VTableUses.size(); ++I) {
16850  CXXRecordDecl *Class = VTableUses[I].first->getDefinition();
16851  if (!Class)
16852  continue;
16853  TemplateSpecializationKind ClassTSK =
16855 
16856  SourceLocation Loc = VTableUses[I].second;
16857 
16858  bool DefineVTable = true;
16859 
16860  // If this class has a key function, but that key function is
16861  // defined in another translation unit, we don't need to emit the
16862  // vtable even though we're using it.
16863  const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(Class);
16864  if (KeyFunction && !KeyFunction->hasBody()) {
16865  // The key function is in another translation unit.
16866  DefineVTable = false;
16868  KeyFunction->getTemplateSpecializationKind();
16869  assert(TSK != TSK_ExplicitInstantiationDefinition &&
16870  TSK != TSK_ImplicitInstantiation &&
16871  "Instantiations don't have key functions");
16872  (void)TSK;
16873  } else if (!KeyFunction) {
16874  // If we have a class with no key function that is the subject
16875  // of an explicit instantiation declaration, suppress the
16876  // vtable; it will live with the explicit instantiation
16877  // definition.
16878  bool IsExplicitInstantiationDeclaration =
16880  for (auto R : Class->redecls()) {
16882  = cast<CXXRecordDecl>(R)->getTemplateSpecializationKind();
16884  IsExplicitInstantiationDeclaration = true;
16885  else if (TSK == TSK_ExplicitInstantiationDefinition) {
16886  IsExplicitInstantiationDeclaration = false;
16887  break;
16888  }
16889  }
16890 
16891  if (IsExplicitInstantiationDeclaration)
16892  DefineVTable = false;
16893  }
16894 
16895  // The exception specifications for all virtual members may be needed even
16896  // if we are not providing an authoritative form of the vtable in this TU.
16897  // We may choose to emit it available_externally anyway.
16898  if (!DefineVTable) {
16899  MarkVirtualMemberExceptionSpecsNeeded(Loc, Class);
16900  continue;
16901  }
16902 
16903  // Mark all of the virtual members of this class as referenced, so
16904  // that we can build a vtable. Then, tell the AST consumer that a
16905  // vtable for this class is required.
16906  DefinedAnything = true;
16907  MarkVirtualMembersReferenced(Loc, Class);
16908  CXXRecordDecl *Canonical = Class->getCanonicalDecl();
16909  if (VTablesUsed[Canonical])
16910  Consumer.HandleVTable(Class);
16911 
16912  // Warn if we're emitting a weak vtable. The vtable will be weak if there is
16913  // no key function or the key function is inlined. Don't warn in C++ ABIs
16914  // that lack key functions, since the user won't be able to make one.
16915  if (Context.getTargetInfo().getCXXABI().hasKeyFunctions() &&
16916  Class->isExternallyVisible() && ClassTSK != TSK_ImplicitInstantiation) {
16917  const FunctionDecl *KeyFunctionDef = nullptr;
16918  if (!KeyFunction || (KeyFunction->hasBody(KeyFunctionDef) &&
16919  KeyFunctionDef->isInlined())) {
16920  Diag(Class->getLocation(),
16922  ? diag::warn_weak_template_vtable
16923  : diag::warn_weak_vtable)
16924  << Class;
16925  }
16926  }
16927  }
16928  VTableUses.clear();
16929 
16930  return DefinedAnything;
16931 }
16932 
16934  const CXXRecordDecl *RD) {
16935  for (const auto *I : RD->methods())
16936  if (I->isVirtual() && !I->isPure())
16937  ResolveExceptionSpec(Loc, I->getType()->castAs<FunctionProtoType>());
16938 }
16939 
16941  const CXXRecordDecl *RD,
16942  bool ConstexprOnly) {
16943  // Mark all functions which will appear in RD's vtable as used.
16944  CXXFinalOverriderMap FinalOverriders;
16945  RD->getFinalOverriders(FinalOverriders);
16946  for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
16947  E = FinalOverriders.end();
16948  I != E; ++I) {
16949  for (OverridingMethods::const_iterator OI = I->second.begin(),
16950  OE = I->second.end();
16951  OI != OE; ++OI) {
16952  assert(OI->second.size() > 0 && "no final overrider");
16953  CXXMethodDecl *Overrider = OI->second.front().Method;
16954 
16955  // C++ [basic.def.odr]p2:
16956  // [...] A virtual member function is used if it is not pure. [...]
16957  if (!Overrider->isPure() && (!ConstexprOnly || Overrider->isConstexpr()))
16958  MarkFunctionReferenced(Loc, Overrider);
16959  }
16960  }
16961 
16962  // Only classes that have virtual bases need a VTT.
16963  if (RD->getNumVBases() == 0)
16964  return;
16965 
16966  for (const auto &I : RD->bases()) {
16967  const auto *Base =
16968  cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
16969  if (Base->getNumVBases() == 0)
16970  continue;
16971  MarkVirtualMembersReferenced(Loc, Base);
16972  }
16973 }
16974 
16975 /// SetIvarInitializers - This routine builds initialization ASTs for the
16976 /// Objective-C implementation whose ivars need be initialized.
16978  if (!getLangOpts().CPlusPlus)
16979  return;
16980  if (ObjCInterfaceDecl *OID = ObjCImplementation->getClassInterface()) {
16982  CollectIvarsToConstructOrDestruct(OID, ivars);
16983  if (ivars.empty())
16984  return;
16986  for (unsigned i = 0; i < ivars.size(); i++) {
16987  FieldDecl *Field = ivars[i];
16988  if (Field->isInvalidDecl())
16989  continue;
16990 
16991  CXXCtorInitializer *Member;
16993  InitializationKind InitKind =
16994  InitializationKind::CreateDefault(ObjCImplementation->getLocation());
16995 
16996  InitializationSequence InitSeq(*this, InitEntity, InitKind, None);
16997  ExprResult MemberInit =
16998  InitSeq.Perform(*this, InitEntity, InitKind, None);
16999  MemberInit = MaybeCreateExprWithCleanups(MemberInit);
17000  // Note, MemberInit could actually come back empty if no initialization
17001  // is required (e.g., because it would call a trivial default constructor)
17002  if (!MemberInit.get() || MemberInit.isInvalid())
17003  continue;
17004 
17005  Member =
17006  new (Context) CXXCtorInitializer(Context, Field, SourceLocation(),
17007  SourceLocation(),
17008  MemberInit.getAs<Expr>(),
17009  SourceLocation());
17010  AllToInit.push_back(Member);
17011 
17012  // Be sure that the destructor is accessible and is marked as referenced.
17013  if (const RecordType *RecordTy =
17014  Context.getBaseElementType(Field->getType())
17015  ->getAs<RecordType>()) {
17016  CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
17017  if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
17018  MarkFunctionReferenced(Field->getLocation(), Destructor);
17019  CheckDestructorAccess(Field->getLocation(), Destructor,
17020  PDiag(diag::err_access_dtor_ivar)
17021  << Context.getBaseElementType(Field->getType()));
17022  }
17023  }
17024  }
17025  ObjCImplementation->setIvarInitializers(Context,
17026  AllToInit.data(), AllToInit.size());
17027  }
17028 }
17029 
17030 static
17032  llvm::SmallPtrSet<CXXConstructorDecl*, 4> &Valid,
17033  llvm::SmallPtrSet<CXXConstructorDecl*, 4> &Invalid,
17034  llvm::SmallPtrSet<CXXConstructorDecl*, 4> &Current,
17035  Sema &S) {
17036  if (Ctor->isInvalidDecl())
17037  return;
17038 
17040 
17041  // Target may not be determinable yet, for instance if this is a dependent
17042  // call in an uninstantiated template.
17043  if (Target) {
17044  const FunctionDecl *FNTarget = nullptr;
17045  (void)Target->hasBody(FNTarget);
17046  Target = const_cast<CXXConstructorDecl*>(
17047  cast_or_null<CXXConstructorDecl>(FNTarget));
17048  }
17049 
17050  CXXConstructorDecl *Canonical = Ctor->getCanonicalDecl(),
17051  // Avoid dereferencing a null pointer here.
17052  *TCanonical = Target? Target->getCanonicalDecl() : nullptr;
17053 
17054  if (!Current.insert(Canonical).second)
17055  return;
17056 
17057  // We know that beyond here, we aren't chaining into a cycle.
17058  if (!Target || !Target->isDelegatingConstructor() ||
17059  Target->isInvalidDecl() || Valid.count(TCanonical)) {
17060  Valid.insert(Current.begin(), Current.end());
17061  Current.clear();
17062  // We've hit a cycle.
17063  } else if (TCanonical == Canonical || Invalid.count(TCanonical) ||
17064  Current.count(TCanonical)) {
17065  // If we haven't diagnosed this cycle yet, do so now.
17066  if (!Invalid.count(TCanonical)) {
17067  S.Diag((*Ctor->init_begin())->getSourceLocation(),
17068  diag::warn_delegating_ctor_cycle)
17069  << Ctor;
17070 
17071  // Don't add a note for a function delegating directly to itself.
17072  if (TCanonical != Canonical)
17073  S.Diag(Target->getLocation(), diag::note_it_delegates_to);
17074 
17076  while (C->getCanonicalDecl() != Canonical) {
17077  const FunctionDecl *FNTarget = nullptr;
17078  (void)C->getTargetConstructor()->hasBody(FNTarget);
17079  assert(FNTarget && "Ctor cycle through bodiless function");
17080 
17081  C = const_cast<CXXConstructorDecl*>(
17082  cast<CXXConstructorDecl>(FNTarget));
17083  S.Diag(C->getLocation(), diag::note_which_delegates_to);
17084  }
17085  }
17086 
17087  Invalid.insert(Current.begin(), Current.end());
17088  Current.clear();
17089  } else {
17090  DelegatingCycleHelper(Target, Valid, Invalid, Current, S);
17091  }
17092 }
17093 
17094 
17096  llvm::SmallPtrSet<CXXConstructorDecl*, 4> Valid, Invalid, Current;
17097 
17098  for (DelegatingCtorDeclsType::iterator
17099  I = DelegatingCtorDecls.begin(ExternalSource),
17100  E = DelegatingCtorDecls.end();
17101  I != E; ++I)
17102  DelegatingCycleHelper(*I, Valid, Invalid, Current, *this);
17103 
17104  for (auto CI = Invalid.begin(), CE = Invalid.end(); CI != CE; ++CI)
17105  (*CI)->setInvalidDecl();
17106 }
17107 
17108 namespace {
17109  /// AST visitor that finds references to the 'this' expression.
17110  class FindCXXThisExpr : public RecursiveASTVisitor<FindCXXThisExpr> {
17111  Sema &S;
17112 
17113  public:
17114  explicit FindCXXThisExpr(Sema &S) : S(S) { }
17115 
17116  bool VisitCXXThisExpr(CXXThisExpr *E) {
17117  S.Diag(E->getLocation(), diag::err_this_static_member_func)
17118  << E->isImplicit();
17119  return false;
17120  }
17121  };
17122 }
17123 
17125  TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
17126  if (!TSInfo)
17127  return false;
17128 
17129  TypeLoc TL = TSInfo->getTypeLoc();
17131  if (!ProtoTL)
17132  return false;
17133 
17134  // C++11 [expr.prim.general]p3:
17135  // [The expression this] shall not appear before the optional
17136  // cv-qualifier-seq and it shall not appear within the declaration of a
17137  // static member function (although its type and value category are defined
17138  // within a static member function as they are within a non-static member
17139  // function). [ Note: this is because declaration matching does not occur
17140  // until the complete declarator is known. - end note ]
17141  const FunctionProtoType *Proto = ProtoTL.getTypePtr();
17142  FindCXXThisExpr Finder(*this);
17143 
17144  // If the return type came after the cv-qualifier-seq, check it now.
17145  if (Proto->hasTrailingReturn() &&
17146  !Finder.TraverseTypeLoc(ProtoTL.getReturnLoc()))
17147  return true;
17148 
17149  // Check the exception specification.
17150  if (checkThisInStaticMemberFunctionExceptionSpec(Method))
17151  return true;
17152 
17153  // Check the trailing requires clause
17154  if (Expr *E = Method->getTrailingRequiresClause())
17155  if (!Finder.TraverseStmt(E))
17156  return true;
17157 
17158  return checkThisInStaticMemberFunctionAttributes(Method);
17159 }
17160 
17162  TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
17163  if (!TSInfo)
17164  return false;
17165 
17166  TypeLoc TL = TSInfo->getTypeLoc();
17168  if (!ProtoTL)
17169  return false;
17170 
17171  const FunctionProtoType *Proto = ProtoTL.getTypePtr();
17172  FindCXXThisExpr Finder(*this);
17173 
17174  switch (Proto->getExceptionSpecType()) {
17175  case EST_Unparsed:
17176  case EST_Uninstantiated:
17177  case EST_Unevaluated:
17178  case EST_BasicNoexcept:
17179  case EST_NoThrow:
17180  case EST_DynamicNone:
17181  case EST_MSAny:
17182  case EST_None:
17183  break;
17184 
17185  case EST_DependentNoexcept:
17186  case EST_NoexceptFalse:
17187  case EST_NoexceptTrue:
17188  if (!Finder.TraverseStmt(Proto->getNoexceptExpr()))
17189  return true;
17190  LLVM_FALLTHROUGH;
17191 
17192  case EST_Dynamic:
17193  for (const auto &E : Proto->exceptions()) {
17194  if (!Finder.TraverseType(E))
17195  return true;
17196  }
17197  break;
17198  }
17199 
17200  return false;
17201 }
17202 
17204  FindCXXThisExpr Finder(*this);
17205 
17206  // Check attributes.
17207  for (const auto *A : Method->attrs()) {
17208  // FIXME: This should be emitted by tblgen.
17209  Expr *Arg = nullptr;
17210  ArrayRef<Expr *> Args;
17211  if (const auto *G = dyn_cast<GuardedByAttr>(A))
17212  Arg = G->getArg();
17213  else if (const auto *G = dyn_cast<PtGuardedByAttr>(A))
17214  Arg = G->getArg();
17215  else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
17216  Args = llvm::makeArrayRef(AA->args_begin(), AA->args_size());
17217  else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
17218  Args = llvm::makeArrayRef(AB->args_begin(), AB->args_size());
17219  else if (const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
17220  Arg = ETLF->getSuccessValue();
17221  Args = llvm::makeArrayRef(ETLF->args_begin(), ETLF->args_size());
17222  } else if (const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
17223  Arg = STLF->getSuccessValue();
17224  Args = llvm::makeArrayRef(STLF->args_begin(), STLF->args_size());
17225  } else if (const auto *LR = dyn_cast<LockReturnedAttr>(A))
17226  Arg = LR->getArg();
17227  else if (const auto *LE = dyn_cast<LocksExcludedAttr>(A))
17228  Args = llvm::makeArrayRef(LE->args_begin(), LE->args_size());
17229  else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
17230  Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());
17231  else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
17232  Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
17233  else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
17234  Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
17235  else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
17236  Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());
17237 
17238  if (Arg && !Finder.TraverseStmt(Arg))
17239  return true;
17240 
17241  for (unsigned I = 0, N = Args.size(); I != N; ++I) {
17242  if (!Finder.TraverseStmt(Args[I]))
17243  return true;
17244  }
17245  }
17246 
17247  return false;
17248 }
17249 
17251  bool IsTopLevel, ExceptionSpecificationType EST,
17252  ArrayRef<ParsedType> DynamicExceptions,
17253  ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr,
17254  SmallVectorImpl<QualType> &Exceptions,
17256  Exceptions.clear();
17257  ESI.Type = EST;
17258  if (EST == EST_Dynamic) {
17259  Exceptions.reserve(DynamicExceptions.size());
17260  for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
17261  // FIXME: Preserve type source info.
17262  QualType ET = GetTypeFromParser(DynamicExceptions[ei]);
17263 
17264  if (IsTopLevel) {
17266  collectUnexpandedParameterPacks(ET, Unexpanded);
17267  if (!Unexpanded.empty()) {
17269  DynamicExceptionRanges[ei].getBegin(), UPPC_ExceptionType,
17270  Unexpanded);
17271  continue;
17272  }
17273  }
17274 
17275  // Check that the type is valid for an exception spec, and
17276  // drop it if not.
17277  if (!CheckSpecifiedExceptionType(ET, DynamicExceptionRanges[ei]))
17278  Exceptions.push_back(ET);
17279  }
17280  ESI.Exceptions = Exceptions;
17281  return;
17282  }
17283 
17284  if (isComputedNoexcept(EST)) {
17285  assert((NoexceptExpr->isTypeDependent() ||
17286  NoexceptExpr->getType()->getCanonicalTypeUnqualified() ==
17287  Context.BoolTy) &&
17288  "Parser should have made sure that the expression is boolean");
17289  if (IsTopLevel && DiagnoseUnexpandedParameterPack(NoexceptExpr)) {
17290  ESI.Type = EST_BasicNoexcept;
17291  return;
17292  }
17293 
17294  ESI.NoexceptExpr = NoexceptExpr;
17295  return;
17296  }
17297 }
17298 
17301  SourceRange SpecificationRange,
17302  ArrayRef<ParsedType> DynamicExceptions,
17303  ArrayRef<SourceRange> DynamicExceptionRanges,
17304  Expr *NoexceptExpr) {
17305  if (!MethodD)
17306  return;
17307 
17308  // Dig out the method we're referring to.
17309  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(MethodD))
17310  MethodD = FunTmpl->getTemplatedDecl();
17311 
17312  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(MethodD);
17313  if (!Method)
17314  return;
17315 
17316  // Check the exception specification.
17317  llvm::SmallVector<QualType, 4> Exceptions;
17319  checkExceptionSpecification(/*IsTopLevel*/true, EST, DynamicExceptions,
17320  DynamicExceptionRanges, NoexceptExpr, Exceptions,
17321  ESI);
17322 
17323  // Update the exception specification on the function type.
17324  Context.adjustExceptionSpec(Method, ESI, /*AsWritten*/true);
17325 
17326  if (Method->isStatic())
17327  checkThisInStaticMemberFunctionExceptionSpec(Method);
17328 
17329  if (Method->isVirtual()) {
17330  // Check overrides, which we previously had to delay.
17331  for (const CXXMethodDecl *O : Method->overridden_methods())
17332  CheckOverridingFunctionExceptionSpec(Method, O);
17333  }
17334 }
17335 
17336 /// HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
17337 ///
17339  SourceLocation DeclStart, Declarator &D,
17340  Expr *BitWidth,
17341  InClassInitStyle InitStyle,
17342  AccessSpecifier AS,
17343  const ParsedAttr &MSPropertyAttr) {
17344  IdentifierInfo *II = D.getIdentifier();
17345  if (!II) {
17346  Diag(DeclStart, diag::err_anonymous_property);
17347  return nullptr;
17348  }
17349  SourceLocation Loc = D.getIdentifierLoc();
17350 
17351  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
17352  QualType T = TInfo->getType();
17353  if (getLangOpts().CPlusPlus) {
17354  CheckExtraCXXDefaultArguments(D);
17355 
17356  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
17357  UPPC_DataMemberType)) {
17358  D.setInvalidType();
17359  T = Context.IntTy;
17360  TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
17361  }
17362  }
17363 
17364  DiagnoseFunctionSpecifiers(D.getDeclSpec());
17365 
17366  if (D.getDeclSpec().isInlineSpecified())
17367  Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
17368  << getLangOpts().CPlusPlus17;
17371  diag::err_invalid_thread)
17372  << DeclSpec::getSpecifierName(TSCS);
17373 
17374  // Check to see if this name was declared as a member previously
17375  NamedDecl *PrevDecl = nullptr;
17376  LookupResult Previous(*this, II, Loc, LookupMemberName,
17377  ForVisibleRedeclaration);
17378  LookupName(Previous, S);
17379  switch (Previous.getResultKind()) {
17380  case LookupResult::Found:
17382  PrevDecl = Previous.getAsSingle<NamedDecl>();
17383  break;
17384 
17386  PrevDecl = Previous.getRepresentativeDecl();
17387  break;
17388 
17392  break;
17393  }
17394 
17395  if (PrevDecl && PrevDecl->isTemplateParameter()) {
17396  // Maybe we will complain about the shadowed template parameter.
17397  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
17398  // Just pretend that we didn't see the previous declaration.
17399  PrevDecl = nullptr;
17400  }
17401 
17402  if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
17403  PrevDecl = nullptr;
17404 
17405  SourceLocation TSSL = D.getBeginLoc();
17406  MSPropertyDecl *NewPD =
17407  MSPropertyDecl::Create(Context, Record, Loc, II, T, TInfo, TSSL,
17408  MSPropertyAttr.getPropertyDataGetter(),
17409  MSPropertyAttr.getPropertyDataSetter());
17410  ProcessDeclAttributes(TUScope, NewPD, D);
17411  NewPD->setAccess(AS);
17412 
17413  if (NewPD->isInvalidDecl())
17414  Record->setInvalidDecl();
17415 
17417  NewPD->setModulePrivate();
17418 
17419  if (NewPD->isInvalidDecl() && PrevDecl) {
17420  // Don't introduce NewFD into scope; there's already something
17421  // with the same name in the same scope.
17422  } else if (II) {
17423  PushOnScopeChains(NewPD, S);
17424  } else
17425  Record->addDecl(NewPD);
17426 
17427  return NewPD;
17428 }
17429 
17431  Declarator &Declarator, unsigned TemplateParameterDepth) {
17432  auto &Info = InventedParameterInfos.emplace_back();
17433  TemplateParameterList *ExplicitParams = nullptr;
17434  ArrayRef<TemplateParameterList *> ExplicitLists =
17435  Declarator.getTemplateParameterLists();
17436  if (!ExplicitLists.empty()) {
17437  bool IsMemberSpecialization, IsInvalid;
17438  ExplicitParams = MatchTemplateParametersToScopeSpecifier(
17439  Declarator.getBeginLoc(), Declarator.getIdentifierLoc(),
17440  Declarator.getCXXScopeSpec(), /*TemplateId=*/nullptr,
17441  ExplicitLists, /*IsFriend=*/false, IsMemberSpecialization, IsInvalid,
17442  /*SuppressDiagnostic=*/true);
17443  }
17444  if (ExplicitParams) {
17445  Info.AutoTemplateParameterDepth = ExplicitParams->getDepth();
17446  for (NamedDecl *Param : *ExplicitParams)
17447  Info.TemplateParams.push_back(Param);
17448  Info.NumExplicitTemplateParams = ExplicitParams->size();
17449  } else {
17450  Info.AutoTemplateParameterDepth = TemplateParameterDepth;
17451  Info.NumExplicitTemplateParams = 0;
17452  }
17453 }
17454 
17456  auto &FSI = InventedParameterInfos.back();
17457  if (FSI.TemplateParams.size() > FSI.NumExplicitTemplateParams) {
17458  if (FSI.NumExplicitTemplateParams != 0) {
17459  TemplateParameterList *ExplicitParams =
17460  Declarator.getTemplateParameterLists().back();
17463  Context, ExplicitParams->getTemplateLoc(),
17464  ExplicitParams->getLAngleLoc(), FSI.TemplateParams,
17465  ExplicitParams->getRAngleLoc(),
17466  ExplicitParams->getRequiresClause()));
17467  } else {
17470  Context, SourceLocation(), SourceLocation(), FSI.TemplateParams,
17471  SourceLocation(), /*RequiresClause=*/nullptr));
17472  }
17473  }
17474  InventedParameterInfos.pop_back();
17475 }
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:1665
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:78
bool isBaseInitializer() const
Determine whether this initializer is initializing a base class.
Definition: DeclCXX.h:2224
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl)
Definition: DeclCXX.cpp:2771
NamespaceDecl * lookupStdExperimentalNamespace()
ExprResult ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr)
void setSourceOrder(int Pos)
Set the source order of this initializer.
Definition: DeclCXX.h:2338
Defines the clang::ASTContext interface.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
void ActOnFinishDelayedMemberInitializers(Decl *Record)
VariadicCallType
Definition: Sema.h:10527
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.cpp:601
bool isCallToStdMove() const
Definition: Expr.h:2799
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1628
static void collectUnexpandedParameterPacks(Sema &S, TemplateParameterList *Params, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK)
Definition: SemaExpr.cpp:17429
bool hasConstexprDestructor() const
Determine whether this class has a constexpr destructor.
Definition: DeclCXX.cpp:538
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Definition: DeclCXX.h:3224
SourceLocation getBeginLoc() const
Definition: ExprCXX.h:1115
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void setImplicit(bool I=true)
Definition: DeclBase.h:559
Represents a function declaration or definition.
Definition: Decl.h:1783
static StmtResult buildSingleCopyAssignRecursively(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &To, const ExprBuilder &From, bool CopyingBaseSubobject, bool Copying, unsigned Depth=0)
Builds a statement that copies/moves the given entity from From to To.
static bool CheckConstraintSatisfaction(Sema &S, const NamedDecl *Template, ArrayRef< const Expr *> ConstraintExprs, ArrayRef< TemplateArgument > TemplateArgs, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Name lookup found a set of overloaded functions that met the criteria.
Definition: Lookup.h:63
NamespaceDecl * getStdNamespace() const
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
Definition: DeclSpec.h:2313
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Expr * getInit() const
Get the initializer.
Definition: DeclCXX.h:2353
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
Definition: DeclSpec.h:1291
void CheckConstructor(CXXConstructorDecl *Constructor)
CheckConstructor - Checks a fully-formed constructor for well-formedness, issuing any diagnostics req...
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
void setOrigin(CXXRecordDecl *Rec)
CXXMethodDecl * getMethod() const
Definition: Sema.h:1147
no exception specification
static bool checkMemberDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const CXXRecordDecl *OrigRD)
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:502
PtrTy get() const
Definition: Ownership.h:80
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2614
EvaluatedExprVisitor - This class visits &#39;Expr *&#39;s.
CanQualType VoidPtrTy
Definition: ASTContext.h:1044
QualType getPointeeType() const
Definition: Type.h:2627
A (possibly-)qualified type.
Definition: Type.h:654
ASTConsumer & Consumer
Definition: Sema.h:386
Simple class containing the result of Sema::CorrectTypo.
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:2185
base_class_range bases()
Definition: DeclCXX.h:587
bool isArrayType() const
Definition: Type.h:6570
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2919
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
Definition: Decl.h:2525
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2702
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:581
static bool CheckConstexprReturnType(Sema &SemaRef, const FunctionDecl *FD, Sema::CheckConstexprKind Kind)
Check whether a function&#39;s return type is a literal type.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1160
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:3075
void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace)
ActOnFinishNamespaceDef - This callback is called after a namespace is exited.
capture_iterator capture_end() const
Retrieve an iterator pointing past the end of the sequence of lambda captures.
Definition: ExprCXX.cpp:1249
ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val)
Definition: SemaExpr.cpp:3445
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition: DeclSpec.h:1018
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Definition: DeclSpec.h:2224
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
Information about operator rewrites to consider when adding operator functions to a candidate set...
Definition: Overload.h:922
bool SetTypeQual(TQ T, SourceLocation Loc)
Definition: DeclSpec.cpp:923
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:3435
bool willHaveBody() const
True if this function will eventually have a body, once it&#39;s fully parsed.
Definition: Decl.h:2347
DeclarationName getCXXConstructorName(CanQualType Ty)
Returns the name of a C++ constructor for the given Type.
static bool findTrivialSpecialMember(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM, unsigned Quals, bool ConstRHS, Sema::TrivialABIHandling TAH, CXXMethodDecl **Selected)
Perform lookup for a special member of the specified kind, and determine whether it is trivial...
static DeclAccessPair findDecomposableBaseClass(Sema &S, SourceLocation Loc, const CXXRecordDecl *RD, CXXCastPath &BasePath)
Find the base class to decompose in a built-in decomposition of a class type.
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
Definition: Decl.h:2862
const Expr * getInit(unsigned Init) const
Definition: Expr.h:4451
CanQualType Char32Ty
Definition: ASTContext.h:1024
The subobject is a base class.
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Lookup.h:248
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false)
Perform unqualified name lookup starting from a given scope.
static UsingPackDecl * Create(ASTContext &C, DeclContext *DC, NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl *> UsingDecls)
Definition: DeclCXX.cpp:2980
bool CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *MD, DefaultedComparisonKind DCK)
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
Definition: TypeLoc.h:169
Decl * Entity
The entity that is being synthesized.
Definition: Sema.h:8085
Expr *const * semantics_iterator
Definition: Expr.h:5781
static ClassTemplateDecl * LookupStdInitializerList(Sema &S, SourceLocation Loc)
Stmt - This represents one statement.
Definition: Stmt.h:66
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
Definition: DeclSpec.h:988
CXXRecordDecl * getCurrentClass(Scope *S, const CXXScopeSpec *SS)
Get the class that is directly named by the current context.
Filter makeFilter()
Create a filter for this result set.
Definition: Lookup.h:682
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:4473
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3422
CXXCatchStmt * getHandler(unsigned i)
Definition: StmtCXX.h:107
IfStmt - This represents an if/then/else.
Definition: Stmt.h:1834
StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R, ArrayRef< Stmt *> Elts, bool isStmtExpr)
Definition: SemaStmt.cpp:388
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:557
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program...
Definition: Decl.cpp:2926
DefaultedComparisonKind asComparison() const
Definition: Sema.h:2634
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:994
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type...
Definition: Type.h:4148
void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD)
Check a completed declaration of an implicit special member.
bool isElaboratedTypeSpecifier() const
Determine wither this type is a C++ elaborated-type-specifier.
Definition: Type.cpp:2736
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2941
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:2021
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:602
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1029
void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnStartDelayedCXXMethodDeclaration - We have completed parsing a top-level (non-nested) C++ class...
static CharSourceRange getTokenRange(SourceRange R)
void addConst()
Add the const type qualifier to this QualType.
Definition: Type.h:823
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2200
Decl * ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc, SourceLocation NamespcLoc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *NamespcName, const ParsedAttributesView &AttrList)
void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record)
Perform semantic checks on a class definition that has been completing, introducing implicitly-declar...
bool isAscii() const
Definition: Expr.h:1830
bool isRecordType() const
Definition: Type.h:6594
static TemplateArgumentLoc getTrivialTypeTemplateArgument(Sema &S, SourceLocation Loc, QualType T)
Expr * getBase() const
Definition: Expr.h:2913
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D)
ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a C++ if/switch/while/for statem...
void erase()
Erase the last element returned from this iterator.
Definition: Lookup.h:654
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D)
Determine what kind of template specialization the given declaration is.
NamedDecl * BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation)
Builds a using declaration.
static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm)
Create the initialization entity for a parameter.
void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc, const CXXRecordDecl *RD)
Mark the exception specifications of all virtual member functions in the given class as needed...
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1958
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
const Type * getTypeForDecl() const
Definition: Decl.h:3053
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
Definition: DeclCXX.h:1305
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1411
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
void setRangeEnd(SourceLocation E)
Definition: Decl.h:1984
bool needsOverloadResolutionForDestructor() const
Determine whether we need to eagerly declare a destructor for this class.
Definition: DeclCXX.h:955
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToMemberFunction - Build a call to a member function.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclBase.h:421
bool isVirtual() const
Definition: DeclCXX.h:1976
static bool FindBaseInitializer(Sema &SemaRef, CXXRecordDecl *ClassDecl, QualType BaseType, const CXXBaseSpecifier *&DirectBaseSpec, const CXXBaseSpecifier *&VirtualBaseSpec)
Find the direct and/or virtual base specifiers that correspond to the given base type, for use in base initialization within a constructor.
void setArgPassingRestrictions(ArgPassingKind Kind)
Definition: Decl.h:3906
ComparisonCategoryType Kind
The Kind of the comparison category type.
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:198
ThreadStorageClassSpecifier getTSCSpec() const
Definition: Decl.h:1038
Opcode getOpcode() const
Definition: Expr.h:3469
StringRef P
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
bool isTemplateParamScope() const
isTemplateParamScope - Return true if this scope is a C++ template parameter scope.
Definition: Scope.h:378
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:906
void setPure(bool P=true)
Definition: Decl.cpp:2913
static QualType RemoveAddressSpaceFromPtr(Sema &SemaRef, const PointerType *PtrTy)
bool isOverrideSpecified() const
Definition: DeclSpec.h:2604
Not a friend object.
Definition: DeclBase.h:1102
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:960
NamedDecl * getDecl() const
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:6452
void AddDecl(Decl *D)
Definition: Scope.h:289
static bool isVirtualDirectBase(CXXRecordDecl *Derived, CXXRecordDecl *Base)
Determine whether a direct base class is a virtual base class.
A constructor named via a template-id.
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Definition: SemaExpr.cpp:4732
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined...
Definition: Decl.h:2918
static bool lookupStdTypeTraitMember(Sema &S, LookupResult &TraitMemberLookup, SourceLocation Loc, StringRef Trait, TemplateArgumentListInfo &Args, unsigned DiagID)
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
Definition: Type.cpp:2645
The base class of the type hierarchy.
Definition: Type.h:1450
static bool checkTrivialSubobjectCall(Sema &S, SourceLocation SubobjLoc, QualType SubType, bool ConstRHS, Sema::CXXSpecialMember CSM, TrivialSubobjectKind Kind, Sema::TrivialABIHandling TAH, bool Diagnose)
Check whether the special member selected for a given type would be trivial.
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnFinishDelayedCXXMethodDeclaration - We have finished processing the delayed method declaration f...
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:1931
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
One instance of this struct is used for each type in a declarator that is parsed. ...
Definition: DeclSpec.h:1174
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2889
Declaration of a variable template.
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
Represent a C++ namespace.
Definition: Decl.h:497
static bool isNonlocalVariable(const Decl *D)
Determine whether the given declaration is a global variable or static data member.
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
Definition: DeclSpec.h:2282
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1422
static FixItHint CreateInsertionFromRange(SourceLocation InsertionLoc, CharSourceRange FromRange, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code from FromRange at a specific location...
Definition: Diagnostic.h:105
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.h:1251
SourceLocation getEndLoc() const LLVM_READONLY
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
Definition: DeclSpec.cpp:520
Ambiguous candidates found.
Definition: Overload.h:59
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclBase.h:425
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:138
bool hasTrivialMoveConstructor() const
Determine whether this class has a trivial move constructor (C++11 [class.copy]p12) ...
Definition: DeclCXX.h:1204
QualType withConst() const
Definition: Type.h:826
std::unique_ptr< CachedTokens > DefaultArgTokens
DefaultArgTokens - When the parameter&#39;s default argument cannot be parsed immediately (because it occ...
Definition: DeclSpec.h:1260
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:707
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:113
const NestedNameSpecifier * Specifier
A container of type source information.
Definition: Type.h:6227
Store information needed for an explicit specifier.
Definition: DeclCXX.h:1787
Floating point control options.
Definition: LangOptions.h:357
constexpr XRayInstrMask Function
Definition: XRayInstr.h:38
static std::string printTemplateArgs(const PrintingPolicy &PrintingPolicy, TemplateArgumentListInfo &Args)
An overloaded operator name, e.g., operator+.
bool isDefined(const FunctionDecl *&Definition) const
Returns true if the function has a definition that does not need to be instantiated.
Definition: Decl.cpp:2883
TSCS getThreadStorageClassSpec() const
Definition: DeclSpec.h:448
bool needsImplicitMoveAssignment() const
Determine whether this class should get an implicit move assignment operator or if any existing speci...
Definition: DeclCXX.h:925
static Sema::ImplicitExceptionSpecification computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, FunctionDecl *FD)
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2752
static void checkMethodTypeQualifiers(Sema &S, Declarator &D, unsigned DiagID)
static InitializedEntity InitializeMemberFromDefaultMemberInitializer(FieldDecl *Member)
Create the initialization entity for a default member initializer.
bool hasNext() const
Definition: Lookup.h:639
Abstract base class used for diagnosing integer constant expression violations.
Definition: Sema.h:11090
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
unsigned getIdentifierNamespace() const
Definition: DeclBase.h:799
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2383
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
Definition: Lookup.h:554
IdentifierInfo * getPropertyDataGetter() const
Definition: ParsedAttr.h:460
CanQualType WideCharTy
Definition: ASTContext.h:1020
bool implicitCopyAssignmentHasConstParam() const
Determine whether an implicit copy assignment operator for this type would have a parameter with a co...
Definition: DeclCXX.h:888
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
Instantiate or parse a C++ default argument expression as necessary.
Definition: SemaExpr.cpp:4924
static void findImplicitlyDeclaredEqualityComparisons(ASTContext &Ctx, CXXRecordDecl *RD, llvm::SmallVectorImpl< FunctionDecl *> &Spaceships)
Find the equality comparison functions that should be implicitly declared in a given class definition...
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3)
Definition: SemaExpr.cpp:15519
bool needsOverloadResolutionForCopyConstructor() const
Determine whether we need to eagerly declare a defaulted copy constructor for this class...
Definition: DeclCXX.h:772
size_t param_size() const
Definition: Decl.h:2415
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
Definition: Decl.h:2869
SourceLocation getEndLoc() const
Get the end source location.
Definition: TypeLoc.cpp:228
bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S)
MergeCXXFunctionDecl - Merge two declarations of the same C++ function, once we already know that the...
SourceLocation getOverrideLoc() const
Definition: DeclSpec.h:2605
QualType getElementType() const
Definition: Type.h:2910
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3324
void CheckCXXDefaultArguments(FunctionDecl *FD)
CheckCXXDefaultArguments - Verify that the default arguments for a function declaration are well-form...
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2544
RAII object to handle the state changes required to synthesize a function body.
Definition: Sema.h:840
IdentifierInfo * getPropertyDataSetter() const
Definition: ParsedAttr.h:466
NamedDecl * BuildUsingPackDecl(NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl *> Expansions)
static InitializedEntity InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, bool IsInheritedVirtualBase, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a base class subobject.
Definition: SemaInit.cpp:3240
CXXMethodDecl * DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl)
Declare the implicit move assignment operator for the given class.
This file provides some common utility functions for processing Lambda related AST Constructs...
std::list< CXXBasePath >::iterator paths_iterator
static std::vector< ComparisonCategoryResult > getPossibleResultsForType(ComparisonCategoryType Type)
Return the list of results which are valid for the specified comparison category type.
void ActOnDefaultCtorInitializers(Decl *CDtorDecl)
DeclContext::lookup_result Decls
The set of declarations found inside this base class subobject.
bool isFunctionDeclarationContext() const
Return true if this declaration appears in a context where a function declarator would be a function ...
Definition: DeclSpec.h:2336
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:53
bool isInterface() const
Definition: Decl.h:3405
static CXXConstructExpr * Create(const ASTContext &Ctx, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr *> Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, ConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Create a C++ construction expression.
Definition: ExprCXX.cpp:1071
RAII object that enters a new expression evaluation context.
Definition: Sema.h:12029
void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record)
Represents a variable declaration or definition.
Definition: Decl.h:820
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:264
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:24
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1792
QualType getReturnType() const
Definition: Decl.h:2445
DiagnosticsEngine & Diags
Definition: Sema.h:387
Wrapper for source info for member pointers.
Definition: TypeLoc.h:1256
unsigned getNumParams() const
Definition: Type.h:3964
bool isEnumeralType() const
Definition: Type.h:6598
void finishedDefaultedOrDeletedMember(CXXMethodDecl *MD)
Indicates that the declaration of a defaulted or deleted special member function is now complete...
Definition: DeclCXX.cpp:1333
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:7002
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
Definition: Decl.cpp:2758
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
Definition: Type.h:6907
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2487
bool This(InterpState &S, CodePtr OpPC)
Definition: Interp.h:827
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
void ActOnFinishCXXNonNestedClass()
Extra information about a function prototype.
Definition: Type.h:3837
bool hasInheritedDefaultArg() const
Definition: Decl.h:1725
void clear()
Clear the base-paths results.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:2033
TypeSpecifierType
Specifies the kind of type.
Definition: Specifiers.h:60
LangAS
Defines the address space values used by the address space qualifier of QualType. ...
Definition: AddressSpaces.h:25
bool needsImplicitCopyAssignment() const
Determine whether this class needs an implicit copy assignment operator to be lazily declared...
Definition: DeclCXX.h:876
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
Definition: DeclCXX.cpp:3138
The "__interface" keyword.
Definition: Type.h:5192
void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD)
Check that the C++ class annoated with "trivial_abi" satisfies all the conditions that are needed for...
RAII class that determines when any errors have occurred between the time the instance was created an...
Definition: Diagnostic.h:1009
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:414
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
Definition: Sema.h:5849
SourceLocation getFinalLoc() const
Definition: DeclSpec.h:2609
SourceLocation getLAngleLoc() const
Definition: DeclTemplate.h:196
bool field_empty() const
Definition: Decl.h:3971
bool isZeroLengthBitField(const ASTContext &Ctx) const
Is this a zero-length bit-field? Such bit-fields aren&#39;t really bit-fields at all and instead act as a...
Definition: Decl.cpp:4036
bool isAmbiguous() const
Definition: Lookup.h:301
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
DeclClass * getCorrectionDeclAs() const
reference front() const
Definition: DeclBase.h:1242
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
Definition: DeclCXX.h:1143
TypeLoc getNamedTypeLoc() const
Definition: TypeLoc.h:2125
bool isInvalidDecl() const
Definition: DeclBase.h:553
Stmt * getThen()
Definition: Stmt.h:1921
Like System, but searched after the system directories.
static StmtResult buildMemcpyForAssignmentOp(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &ToB, const ExprBuilder &FromB)
When generating a defaulted copy or move assignment operator, if a field should be copied with __buil...
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:69
void setBegin(SourceLocation b)
static StringRef getTagTypeKindName(TagTypeKind Kind)
Definition: Type.h:5269
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
Definition: DeclSpec.h:624
static InitializationKind CreateDirectList(SourceLocation InitLoc)
bool isInterfaceLike() const
Definition: DeclCXX.cpp:1815
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:47
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
Definition: Sema.h:7987
static CXXDefaultInitExpr * Create(const ASTContext &Ctx, SourceLocation Loc, FieldDecl *Field, DeclContext *UsedContext)
Field is the non-static data member whose default initializer is used by this expression.
Definition: ExprCXX.h:1297
void DefineImplicitLambdaToFunctionPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a function pointer.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
CharSourceRange getSourceRange(const SourceRange &Range)
Returns the token CharSourceRange corresponding to Range.
Definition: FixIt.h:32
bool hasMethodTypeQualifiers() const
Determine whether this method has qualifiers.
Definition: DeclSpec.h:1478
bool isStatic() const
Definition: DeclCXX.cpp:1983
bool hasDefinition() const
Definition: DeclCXX.h:540
static StringRef getResultString(ComparisonCategoryResult Kind)
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams)
Handle a friend type declaration.
bool CheckConstexprFunctionDefinition(const FunctionDecl *FD, CheckConstexprKind Kind)
static AccessSpecDecl * Create(ASTContext &C, AccessSpecifier AS, DeclContext *DC, SourceLocation ASLoc, SourceLocation ColonLoc)
Definition: DeclCXX.h:116
Represents a parameter to a function.
Definition: Decl.h:1595
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Definition: Type.h:893
MutableArrayRef< ParmVarDecl * >::iterator param_iterator
Definition: Decl.h:2407
Defines the clang::Expr interface and subclasses for C++ expressions.
Parse and apply any fixits to the source.
bool isUnset() const
Definition: Ownership.h:168
void removeDecl(Decl *D)
Removes a declaration from this context.
Definition: DeclBase.cpp:1444
noexcept(expression), value-dependent
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2105
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:513
CXXConstructorDecl * getTargetConstructor() const
When this constructor delegates to another, retrieve the target.
Definition: DeclCXX.cpp:2535
The collection of all-type qualifiers we support.
Definition: Type.h:143
bool isAnonymousStructOrUnion() const
Determines whether this field is a representative for an anonymous struct or union.
Definition: Decl.cpp:4021
bool isRecordingPaths() const
Whether we are recording paths.
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
Definition: DeclCXX.h:1440
void DefineImplicitMoveConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitMoveConstructor - Checks for feasibility of defining this constructor as the move const...
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type. ...
Definition: Decl.cpp:3395
bool FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI)
Definition: SemaInternal.h:36
QualType CheckConstructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckConstructorDeclarator - Called by ActOnDeclarator to check the well-formedness of the constructo...
static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T)
Determine whether the given type is an incomplete or zero-lenfgth array type.
void CheckDelayedMemberExceptionSpecs()
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:244
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:58
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:2281
SourceLocation getFriendSpecLoc() const
Definition: DeclSpec.h:741
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
bool isRedeclaration() const
Definition: DeclSpec.h:2572
void ActOnMemInitializers(Decl *ConstructorDecl, SourceLocation ColonLoc, ArrayRef< CXXCtorInitializer *> MemInits, bool AnyErrors)
ActOnMemInitializers - Handle the member initializers for a constructor.
Represents a struct/union/class.
Definition: Decl.h:3748
bool hasTrivialCopyConstructorForCall() const
Definition: DeclCXX.h:1185
bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM, InheritedConstructorInfo *ICI=nullptr, bool Diagnose=false)
Determine if a special member function should have a deleted definition when it is defaulted...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
void LoadExternalVTableUses()
Load any externally-stored vtable uses.
bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc)
Checks that the given nested-name qualifier used in a using decl in the current context is appropriat...
static QualType getTupleLikeElementType(Sema &S, SourceLocation Loc, unsigned I, QualType T)
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1099
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
Description of a constructor that was inherited from a base class.
Definition: DeclCXX.h:2357
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:1012
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:272
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1161
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3838
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.
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool RequiresADL=true, bool AllowRewrittenCandidates=true, FunctionDecl *DefaultedFn=nullptr)
Create a binary operation that may resolve to an overloaded operator.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1063
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition: Lookup.h:73
unsigned getDepth() const
Retrieve the depth of the template parameter.
Decl * ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc, SourceLocation NamespaceLoc, SourceLocation IdentLoc, IdentifierInfo *Ident, SourceLocation LBrace, const ParsedAttributesView &AttrList, UsingDirectiveDecl *&UsingDecl)
ActOnStartNamespaceDef - This is called at the start of a namespace definition.
static bool IsUsingDirectiveInToplevelContext(DeclContext *CurContext)
Determine whether a using statement is in a context where it will be apply in all contexts...
Decl * ActOnNamespaceAliasDef(Scope *CurScope, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident)
void setRecordingPaths(bool RP)
Specify whether we should be recording paths or not.
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
Definition: Decl.h:2929
bool isConst() const
Definition: DeclCXX.h:1973
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue=true)
Definition: SemaStmt.cpp:45
UnionParsedType ConversionFunctionId
When Kind == IK_ConversionFunctionId, the type that the conversion function names.
Definition: DeclSpec.h:996
void setUninstantiatedDefaultArg(Expr *arg)
Definition: Decl.cpp:2747
void ActOnStartFunctionDeclarationDeclarator(Declarator &D, unsigned TemplateParameterDepth)
Called before parsing a function declarator belonging to a function declaration.
Diagnose issues that are non-constant or that are extensions.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:168
A C++ nested-name-specifier augmented with source location information.
bool isInline() const
Returns true if this is an inline namespace declaration.
Definition: Decl.h:558
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:8412
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3971
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1195
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:517
TypeSourceInfo * getTypeSourceInfo() const
Definition: TemplateBase.h:506
ConstexprSpecKind getConstexprKind() const
Definition: Decl.h:2206
ImplicitInitializerKind
ImplicitInitializerKind - How an implicit base or member initializer should initialize its base or me...
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
bool defaultedDefaultConstructorIsConstexpr() const
Determine whether a defaulted default constructor for this class would be constexpr.
Definition: DeclCXX.h:1166
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3953
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
field_range fields() const
Definition: Decl.h:3963
BaseResult ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange, ParsedAttributes &Attrs, bool Virtual, AccessSpecifier Access, ParsedType basetype, SourceLocation BaseLoc, SourceLocation EllipsisLoc)
ActOnBaseSpecifier - Parsed a base specifier.
static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info, FieldDecl *Field, IndirectFieldDecl *Indirect=nullptr)
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:275
NameKind getNameKind() const
Determine what kind of name this is.
void checkExceptionSpecification(bool IsTopLevel, ExceptionSpecificationType EST, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr, SmallVectorImpl< QualType > &Exceptions, FunctionProtoType::ExceptionSpecInfo &ESI)
Check the given exception-specification and update the exception specification information with the r...
UnionParsedTemplateTy TemplateName
When Kind == IK_DeductionGuideName, the parsed template-name.
Definition: DeclSpec.h:1007
VarDecl * BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id)
Perform semantic analysis for the variable declaration that occurs within a C++ catch clause...
Represents a member of a struct/union/class.
Definition: Decl.h:2729
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet, OverloadedOperatorKind Op, const UnresolvedSetImpl &Fns, ArrayRef< Expr *> Args, bool RequiresADL=true)
Perform lookup for an overloaded binary operator.
TypeSourceInfo * getTypeSourceInfo() const
Returns the declarator information for a base class or delegating initializer.
Definition: DeclCXX.h:2285
bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, DeclAccessPair Found, QualType ObjectType, SourceLocation Loc, const PartialDiagnostic &Diag)
Is the given member accessible for the purposes of deciding whether to define a special member functi...
void removeConst()
Definition: Type.h:262
DefaultedComparisonKind
Kinds of defaulted comparison operator functions.
Definition: Sema.h:1259
bool isAbstractType(SourceLocation Loc, QualType T)
static bool isIncrementDecrementOp(Opcode Op)
Definition: Expr.h:2119
bool Zero(InterpState &S, CodePtr OpPC)
Definition: Interp.h:812
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Lookup.h:233
bool isFunctionDefinition() const
Definition: DeclSpec.h:2549
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2017
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.h:3031
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
bool isReferenceType() const
Definition: Type.h:6516
CXXRecordDecl * getStdBadAlloc() const
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class.copy]p25)
Definition: DeclCXX.h:1244
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2155
bool evaluateDestruction(SmallVectorImpl< PartialDiagnosticAt > &Notes) const
Evaluate the destruction of this variable to determine if it constitutes constant destruction...
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Definition: DeclCXX.h:2622
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
static UnresolvedUsingTypenameDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation TypenameLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TargetNameLoc, DeclarationName TargetName, SourceLocation EllipsisLoc)
Definition: DeclCXX.cpp:3029
static void extendLeft(SourceRange &R, SourceRange Before)
bool hasUserDeclaredDestructor() const
Determine whether this class has a user-declared destructor.
Definition: DeclCXX.h:943
DeclarationName getCXXDestructorName(CanQualType Ty)
Returns the name of a C++ destructor for the given Type.
ParmVarDecl * getParam(unsigned i) const
Definition: TypeLoc.h:1432
int Category
Definition: Format.cpp:1828
bool isInvalid() const
Definition: Sema.h:11013
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:6744
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1908
llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const
Make an APSInt of the appropriate width and signedness for the given Value and integer Type...
Definition: ASTContext.h:2699
std::pair< VarDecl *, Expr * > get() const
Definition: Sema.h:11014
LookupResultKind getResultKind() const
Definition: Lookup.h:321
bool DefineUsedVTables()
Define all of the vtables that have been used in this translation unit and reference any virtual memb...
void setParams(ArrayRef< ParmVarDecl *> NewParamInfo)
Definition: Decl.h:2430
Expr * getSubExpr()
Definition: Expr.h:3202
Represents an access specifier followed by colon &#39;:&#39;.
Definition: DeclCXX.h:85
void ClearStorageClassSpecs()
Definition: DeclSpec.h:461
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:723
void addShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:2928
ComparisonCategoryResult
An enumeration representing the possible results of a three-way comparison.
void CheckDeductionGuideDeclarator(Declarator &D, QualType &R, StorageClass &SC)
Check the validity of a declarator that we parsed for a deduction-guide.
SourceLocation getTemplateLoc() const
Definition: DeclTemplate.h:195
void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator, which is not a function declaration or definition and therefore is not permitted to have default arguments.
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition: Lookup.h:55
A user-defined literal name, e.g., operator "" _i.
IdentifierTable & Idents
Definition: ASTContext.h:580
specific_decl_iterator< FieldDecl > field_iterator
Definition: Decl.h:3960
SpecialMemberOverloadResult - The overloading result for a special member function.
Definition: Sema.h:1131
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
Definition: SemaExpr.cpp:100
void setImplicitCopyConstructorIsDeleted()
Set that we attempted to declare an implicit copy constructor, but overload resolution failed so we d...
Definition: DeclCXX.h:825
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:125
bool isInvalidType() const
Definition: DeclSpec.h:2530
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2399
UnsupportedSTLSelect
A defaulted &#39;operator<=>&#39; needed the comparison category.
DeclClass * getAsSingle() const
Definition: Lookup.h:507
void FindHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl< CXXMethodDecl *> &OverloadedMethods)
Check if a method overloads virtual methods in a base class without overriding any.
bool isFinalSpelledSealed() const
Definition: DeclSpec.h:2608
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr *> Exprs, SourceLocation RParenLoc)
Create a paren list.
Definition: Expr.cpp:4502
UnionParsedType DestructorName
When Kind == IK_DestructorName, the type referred to by the class-name.
Definition: DeclSpec.h:1004
Describes an C or C++ initializer list.
Definition: Expr.h:4403
Represents a C++ using-declaration.
Definition: DeclCXX.h:3369
The argument of this type can be passed directly in registers.
Definition: Decl.h:3759
BinaryOperatorKind
ArrayRef< BindingDecl * > bindings() const
Definition: DeclCXX.h:3903
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:960
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2815
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1817
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From, QualType T, APValue &Value, Sema::CCEKind CCE, bool RequireInt)
CheckConvertedConstantExpression - Check that the expression From is a converted constant expression ...
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization. ...
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
Definition: SemaLookup.cpp:475
NamespaceDecl * getOrCreateStdNamespace()
Retrieve the special "std" namespace, which may require us to implicitly define the namespace...
static void ReferenceDllExportedMembers(Sema &S, CXXRecordDecl *Class)
Represents the results of name lookup.
Definition: Lookup.h:46
PtrTy get() const
Definition: Ownership.h:170
bool isDelegatingConstructor() const
Determine whether this constructor is a delegating constructor.
Definition: DeclCXX.h:2537
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:2894
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
static InitializedEntity InitializeDelegation(QualType Type)
Create the initialization entity for a delegated constructor.
TagKind getTagKind() const
Definition: Decl.h:3398
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
Definition: SemaExpr.cpp:1866
Microsoft throw(...) extension.
Succeeded, but refers to a deleted function.
Definition: Overload.h:62
A convenient class for passing around template argument information.
Definition: TemplateBase.h:554
void setParamDestroyedInCallee(bool V)
Definition: Decl.h:3914
AccessSpecifier getAccessSpecifier() const
Returns the access specifier for this base specifier.
Definition: DeclCXX.h:225
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2289
CXXConstructorDecl * DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit move constructor for the given class.
bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method)
Check whether &#39;this&#39; shows up in the type of a static member function after the (naturally empty) cv-...
void setDefaultedFunctionInfo(DefaultedFunctionInfo *Info)
Definition: Decl.cpp:2846
Wrapper for source info for functions.
Definition: TypeLoc.h:1351
bool CheckUsingShadowDecl(UsingDecl *UD, NamedDecl *Target, const LookupResult &PreviousDecls, UsingShadowDecl *&PrevShadow)
Determines whether to create a using shadow decl for a particular decl, given the set of decls existi...
bool needsOverloadResolutionForCopyAssignment() const
Determine whether we need to eagerly declare a defaulted copy assignment operator for this class...
Definition: DeclCXX.h:882
bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS)
Determine whether the identifier II is a typo for the name of the class type currently being defined...
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3561
void DefineInheritingConstructor(SourceLocation UseLoc, CXXConstructorDecl *Constructor)
Define the specified inheriting constructor.
ArrayRef< NamedDecl * > chain() const
Definition: Decl.h:3002
An x-value expression is a reference to an object with independent storage but which can be "moved"...
Definition: Specifiers.h:134
A friend of a previously-undeclared entity.
Definition: DeclBase.h:1104
bool hasNonTrivialDestructorForCall() const
Definition: DeclCXX.h:1283
child_range children()
Definition: Stmt.cpp:224
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:2220
static bool BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, FieldDecl *Field, IndirectFieldDecl *Indirect, CXXCtorInitializer *&CXXMemberInit)
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
Definition: SemaExpr.cpp:17029
StmtResult StmtError()
Definition: Ownership.h:280
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:671
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1896
static void NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set, const QualType &Type)
Recursively add the bases of Type. Don&#39;t add Type itself.
semantics_iterator semantics_end()
Definition: Expr.h:5789
void ActOnBaseSpecifiers(Decl *ClassDecl, MutableArrayRef< CXXBaseSpecifier *> Bases)
ActOnBaseSpecifiers - Attach the given base specifiers to the class, after checking whether there are...
Represents a declaration of a type.
Definition: Decl.h:3029
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3434
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:6326
LangAS getAddressSpace() const
Definition: Type.h:359
A set of unresolved declarations.
Definition: UnresolvedSet.h:61
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
Definition: Sema.h:8082
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt *> Stmts, SourceLocation LB, SourceLocation RB)
Definition: Stmt.cpp:319
void CheckDelegatingCtorCycles()
QualType getExceptionObjectType(QualType T) const
QualType CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckDestructorDeclarator - Called by ActOnDeclarator to check the well-formednes of the destructor d...
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
Definition: Ownership.h:277
bool isRValueReferenceType() const
Definition: Type.h:6524
static void checkMoveAssignmentForRepeatedMove(Sema &S, CXXRecordDecl *Class, SourceLocation CurrentLocation)
Check if we&#39;re implicitly defining a move assignment operator for a class with virtual bases...
bool isNull() const
Definition: TypeLoc.h:120
child_range children()
Definition: Expr.h:4588
void setExceptionVariable(bool EV)
Definition: Decl.h:1340
The argument of this type cannot be passed directly in registers.
Definition: Decl.h:3773
llvm::Error Error
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1412
ActionResult< ParsedType > TypeResult
Definition: Ownership.h:265
DeclContextLookupResult slice(size_t N) const
Definition: DeclBase.h:1247
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:960
CanQualType LongDoubleTy
Definition: ASTContext.h:1028
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
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:7750
bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6256
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:492
field_iterator field_begin() const
Definition: Decl.cpp:4425
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Definition: DeclCXX.cpp:2073
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1166
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
Definition: Decl.h:1709
Identify whether this function satisfies the formal rules for constexpr functions in the current lanu...
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:2123
void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD)
Evaluate the implicit exception specification for a defaulted special member function.
ExprResult ActOnCXXThis(SourceLocation loc)
bool isAnyMemberInitializer() const
Definition: DeclCXX.h:2232
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
void setNumCtorInitializers(unsigned numCtorInitializers)
Definition: DeclCXX.h:2523
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:828
FieldDecl * getAnyMember() const
Definition: DeclCXX.h:2297
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1818
Preprocessor & PP
Definition: Sema.h:384
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1269
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1980
const LangOptions & getLangOpts() const
Definition: Sema.h:1324
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
Definition: DeclCXX.cpp:2826
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value &#39;V&#39; and type &#39;type&#39;.
Definition: Expr.cpp:928
TemplateArgumentLoc getArgLoc(unsigned i) const
Definition: TypeLoc.h:1616
void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don&#39;t have one.
bool isInstance() const
Definition: DeclCXX.h:1959
SourceLocation getConstSpecLoc() const
Definition: DeclSpec.h:551
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:176
bool CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM)
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:1910
static bool findCircularInheritance(const CXXRecordDecl *Class, const CXXRecordDecl *Current)
Determine whether the given class is a base class of the given class, including looking at dependent ...
const TemplateArgument * data() const
Retrieve a pointer to the template argument list.
Definition: DeclTemplate.h:302
An ordinary object is located at an address in memory.
Definition: Specifiers.h:141
bool Const(InterpState &S, CodePtr OpPC, const T &Arg)
Definition: Interp.h:294
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1770
Decl * ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc, Expr *LangStr, SourceLocation LBraceLoc)
ActOnStartLinkageSpecification - Parsed the beginning of a C++ linkage specification, including the language and (if present) the &#39;{&#39;.
Represents an ObjC class declaration.
Definition: DeclObjC.h:1186
const ValueInfo * getValueInfo(ComparisonCategoryResult ValueKind) const
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
Definition: DeclCXX.h:2291
Represents a linkage specification.
Definition: DeclCXX.h:2778
ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, ActOnMemberAccessExtraArgs *ExtraArgs=nullptr)
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Lookup.h:426
const ComparisonCategoryInfo & getInfoForType(QualType Ty) const
Return the comparison category information as specified by getCategoryForType(Ty).
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:3443
bool containsUnexpandedParameterPack() const
Determine whether this name contains an unexpanded parameter pack.
bool hasConstexprDefaultConstructor() const
Determine whether this class has a constexpr default constructor.
Definition: DeclCXX.h:1173
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:509
bool isAbstract() const
Determine whether this class has a pure virtual function.
Definition: DeclCXX.h:1124
void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc, Decl *TagDecl, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
Definition: SemaExpr.cpp:3034
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
Definition: CanonicalType.h:83
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.cpp:404
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:3823
void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init)
Check that the lifetime of the initializer (and its subobjects) is sufficient for initializing the en...
Definition: SemaInit.cpp:7323
A binding in a decomposition declaration.
Definition: DeclCXX.h:3812
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:142
void setKind(ExplicitSpecKind Kind)
Definition: DeclCXX.h:1820
bool hasConst() const
Definition: Type.h:260
init_iterator init_begin()
Retrieve an iterator to the first initializer.
Definition: DeclCXX.h:2481
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:2172
void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var)
Mark a variable referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3).
Definition: SemaExpr.cpp:16990
Ordinary names.
Definition: DeclBase.h:146
unsigned getLength() const
Efficiently return the length of this identifier info.
static bool CheckLiteralType(Sema &SemaRef, Sema::CheckConstexprKind Kind, SourceLocation Loc, QualType T, unsigned DiagID, Ts &&...DiagArgs)
Check that the given type is a literal type.
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:877
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location...
static TemplateArgumentLoc getTrivialIntegralTemplateArgument(Sema &S, SourceLocation Loc, QualType T, uint64_t I)
ArgPassingKind getArgPassingRestrictions() const
Definition: Decl.h:3902
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM, TrivialABIHandling TAH=TAH_IgnoreTrivialABI, bool Diagnose=false)
Determine whether a defaulted or deleted special member function is trivial, as specified in C++11 [c...
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
Definition: Decl.h:3821
param_iterator param_begin()
Definition: Decl.h:2411
Represents the this expression in C++.
Definition: ExprCXX.h:1097
UsingShadowDecl * BuildUsingShadowDecl(Scope *S, UsingDecl *UD, NamedDecl *Target, UsingShadowDecl *PrevDecl)
Builds a shadow declaration corresponding to a &#39;using&#39; declaration.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprCXX.h:2034
Language
The language for the input, used to select and validate the language standard and possible actions...
Definition: LangStandard.h:19
static bool isValidUDSuffix(const LangOptions &LangOpts, StringRef Suffix)
Determine whether a suffix is a valid ud-suffix.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1612
Class that aids in the construction of nested-name-specifiers along with source-location information ...
ExtInfo withCallingConv(CallingConv cc) const
Definition: Type.h:3638
static StmtResult buildSingleCopyAssign(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &To, const ExprBuilder &From, bool CopyingBaseSubobject, bool Copying)
SourceLocation LAngleLoc
The location of the &#39;<&#39; before the template argument list.
void removeInClassInitializer()
Remove the C++11 in-class initializer from this member.
Definition: Decl.h:2895
DefaultedFunctionInfo * getDefaultedFunctionInfo() const
Definition: Decl.cpp:2855
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3653
static bool canPassInRegisters(Sema &S, CXXRecordDecl *D, TargetInfo::CallingConvKind CCK)
Determine whether a type is permitted to be passed or returned in registers, per C++ [class...
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1328
static bool checkArrayDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const ConstantArrayType *CAT)
CXXSpecialMember asSpecialMember() const
Definition: Sema.h:2633
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited=InheritedConstructor(), Expr *TrailingRequiresClause=nullptr)
Definition: DeclCXX.cpp:2513
bool isFinalSpecified() const
Definition: DeclSpec.h:2607
void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an initializer for the declaratio...
void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD)
Produce notes explaining why a defaulted function was defined as deleted.
CXXSpecialMember
Kinds of C++ special members.
Definition: Sema.h:1240
NodeId Parent
Definition: ASTDiff.cpp:191
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:220
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.
QualType getDeclaredReturnType() const
Get the declared return type, which may differ from the actual return type if the return type is dedu...
Definition: Decl.h:2462
CXXConstructorDecl * findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor, ConstructorUsingShadowDecl *DerivedShadow)
Given a derived-class using shadow declaration for a constructor and the correspnding base class cons...
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
void setBases(CXXBaseSpecifier const *const *Bases, unsigned NumBases)
Sets the base classes of this struct or class.
Definition: DeclCXX.cpp:187
bool isDeclspecPropertyAttribute() const
Is this the Microsoft __declspec(property) attribute?
Definition: ParsedAttr.h:340
bool hasAttr() const
Definition: DeclBase.h:542
CXXConstructorDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2627
bool hasUserProvidedDefaultConstructor() const
Whether this class has a user-provided default constructor per C++11.
Definition: DeclCXX.h:753
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3732
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1902
bool isTriviallyCopyable() const
Determine whether this class is considered trivially copyable per (C++11 [class]p6).
Definition: DeclCXX.cpp:550
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:336
StringRef getString() const
Definition: Expr.h:1794
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3193
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl, bool ConsiderCudaAttrs=true, bool ConsiderRequiresClauses=true)
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1332
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1690
SourceLocation getUnalignedSpecLoc() const
Definition: DeclSpec.h:555
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3754
virtual CallingConvKind getCallingConvKind(bool ClangABICompat4) const
Definition: TargetInfo.cpp:415
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition: DeclSpec.cpp:118
bool hasConstexprSpecifier() const
Definition: DeclSpec.h:751
bool isDynamicClass() const
Definition: DeclCXX.h:553
void ClearConstexprSpec()
Definition: DeclSpec.h:755
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
Definition: Decl.h:2508
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:12918
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:1163
void ActOnFinishCXXMemberDecls()
Perform any semantic analysis which needs to be delayed until all pending class member declarations h...
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any...
Definition: Decl.cpp:3501
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1494
void DefineImplicitCopyAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared copy assignment operator.
bool isDeclarationOfFunction() const
Determine whether the declaration that will be produced from this declaration will be a function...
Definition: DeclSpec.cpp:312
A RAII object to enter scope of a compound statement.
Definition: Sema.h:4114
bool isMoreQualifiedThan(QualType Other) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
Definition: Type.h:6423
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:1700
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:671
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
Definition: Sema.h:2648
SourceRange getLocalSourceRange() const
Get the local source range.
Definition: TypeLoc.h:158
static StringRef getCategoryString(ComparisonCategoryType Kind)
static Sema::ImplicitExceptionSpecification ComputeDefaultedSpecialMemberExceptionSpec(Sema &S, SourceLocation Loc, CXXMethodDecl *MD, Sema::CXXSpecialMember CSM, Sema::InheritedConstructorInfo *ICI)
bool isDelegatingInitializer() const
Determine whether this initializer is creating a delegating constructor.
Definition: DeclCXX.h:2252
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1998
StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp)
Definition: SemaStmt.cpp:3601
ExplicitSpecifier getExplicitSpecifier()
Definition: DeclCXX.h:2456
DeclSpec * MethodQualifiers
DeclSpec for the function with the qualifier related info.
Definition: DeclSpec.h:1342
ExplicitSpecifier ActOnExplicitBoolSpecifier(Expr *E)
ActOnExplicitBoolSpecifier - Build an ExplicitSpecifier from an expression found in an explicit(bool)...
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:583
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1314
llvm::FoldingSet< SpecialMemberOverloadResultEntry > SpecialMemberCache
A cache of special member function overload resolution results for C++ records.
Definition: Sema.h:1165
bool hasTrivialMoveConstructorForCall() const
Definition: DeclCXX.h:1209
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:6331
void NoteHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl< CXXMethodDecl *> &OverloadedMethods)
bool mayHaveDecompositionDeclarator() const
Return true if the context permits a C++17 decomposition declarator.
Definition: DeclSpec.h:2055
static EmptyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
Definition: Decl.cpp:4898
A conversion function name, e.g., operator int.
SourceRange getRange() const
Definition: DeclSpec.h:68
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
bool isInlineSpecified() const
Definition: Decl.h:1397
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Definition: ASTConcept.h:29
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
static StaticAssertDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StaticAssertLoc, Expr *AssertExpr, StringLiteral *Message, SourceLocation RParenLoc, bool Failed)
Definition: DeclCXX.cpp:3050
bool isLiteral() const
Determine whether this class is a literal type.
Definition: DeclCXX.h:1357
void setInClassInitializer(Expr *Init)
Set the C++11 in-class initializer for this member.
Definition: Decl.h:2886
const CXXRecordDecl * getParent() const
Returns the parent of this using shadow declaration, which is the class in which this is declared...
Definition: DeclCXX.h:3319
void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param)
This is used to implement the constant expression evaluation part of the attribute enable_if extensio...
MemInitResult BuildMemberInitializer(ValueDecl *Member, Expr *Init, SourceLocation IdLoc)
TST getTypeSpecType() const
Definition: DeclSpec.h:479
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclCXX.h:189
static void diagnoseDeprecatedCopyOperation(Sema &S, CXXMethodDecl *CopyOp)
Diagnose an implicit copy operation for a class which is odr-used, but which is deprecated because th...
bool hasKeyFunctions() const
Does this ABI use key functions? If so, class data such as the vtable is emitted with strong linkage ...
Definition: TargetCXXABI.h:235
bool hasInheritedConstructor() const
Determine whether this class has a using-declaration that names a user-declared base class constructo...
Definition: DeclCXX.h:1317
static Sema::SpecialMemberOverloadResult lookupCallFromSpecialMember(Sema &S, CXXRecordDecl *Class, Sema::CXXSpecialMember CSM, unsigned FieldQuals, bool ConstRHS)
Look up the special member function that would be called by a special member function for a subobject...
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
Definition: Expr.cpp:3401
CheckConstexprKind
Definition: Sema.h:2218
llvm::PointerIntPair< CXXRecordDecl *, 3, CXXSpecialMember > SpecialMemberDecl
Definition: Sema.h:1251
bool isConsteval() const
Definition: Decl.h:2212
bool isMsStruct(const ASTContext &C) const
Get whether or not this is an ms_struct which can be turned on with an attribute, pragma...
Definition: Decl.cpp:4442
bool isUsualDeallocationFunction(const CXXMethodDecl *FD)
void setTrivialForCall(bool IT)
Definition: Decl.h:2126
static bool checkComplexDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const ComplexType *CT)
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:191
static bool checkArrayLikeDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType)
Allows QualTypes to be sorted and hence used in maps and sets.
Decl * ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *AssertMessageExpr, SourceLocation RParenLoc)
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:421
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition: DeclBase.h:1800
QualType getElementType() const
Definition: Type.h:2567
bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method)
Whether this&#39; shows up in the exception specification of a static member function.
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2499
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3263
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition: Decl.h:3375
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:619
This represents one expression.
Definition: Expr.h:108
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Definition: DeclCXX.cpp:2564
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3409
StringRef getKindName() const
Definition: Decl.h:3394
QualType getPointeeType() const
Definition: Type.h:2771
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:122
static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *Body, Sema::CheckConstexprKind Kind)
Check the body for the given constexpr function declaration only contains the permitted types of stat...
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2827
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2130
llvm::StringRef getAsString(SyncScope S)
Definition: SyncScope.h:50
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration...
Definition: Decl.h:2147
bool isDeclScope(Decl *D)
isDeclScope - Return true if this is the scope that the specified decl is declared in...
Definition: Scope.h:323
Helper class that collects exception specifications for implicitly-declared special member functions...
Definition: Sema.h:5233
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
static void DiagnoseBaseOrMemInitializerOrder(Sema &SemaRef, const CXXConstructorDecl *Constructor, ArrayRef< CXXCtorInitializer *> Inits)
bool isDecompositionDeclarator() const
Return whether this declarator is a decomposition declarator.
Definition: DeclSpec.h:2168
void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath)
StateNode * Previous
Declaration of a template type parameter.
unsigned getIndex() const
Definition: Type.h:4691
DeclContext * getEntity() const
Definition: Scope.h:327
bool defaultedMoveConstructorIsDeleted() const
true if a defaulted move constructor for this class would be deleted.
Definition: DeclCXX.h:685
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:3416
void setHideTags(bool Hide)
Sets whether tag declarations should be hidden by non-tag declarations during resolution.
Definition: Lookup.h:288
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:5732
This file defines the classes used to store parsed information about declaration-specifiers and decla...
IsTupleLike
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7067
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:5206
void getFinalOverriders(CXXFinalOverriderMap &FinaOverriders) const
Retrieve the final overriders for each virtual member function in the class hierarchy where this clas...
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
void setRBraceLoc(SourceLocation L)
Definition: Decl.h:603
Inits[]
Definition: OpenMPClause.h:150
static bool checkVectorDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const VectorType *VT)
bool defaultedDestructorIsConstexpr() const
Determine whether a defaulted default constructor for this class would be constexpr.
Definition: DeclCXX.h:1259
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
OpaquePtr< T > get() const
Definition: Ownership.h:104
static UnresolvedUsingValueDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, SourceLocation EllipsisLoc)
Definition: DeclCXX.cpp:3001
SourceLocation getLocation() const
Definition: ExprCXX.h:1112
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:88
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2649
void freeParams()
Reset the parameter list to having zero parameters.
Definition: DeclSpec.h:1374
void setInit(Expr *I)
Definition: Decl.cpp:2283
Expr * getCallee()
Definition: Expr.h:2663
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
std::string getAsString() const
Retrieve the human-readable string for this name.
unsigned getNumInits() const
Definition: Expr.h:4433
AccessResult CheckStructuredBindingMemberAccess(SourceLocation UseLoc, CXXRecordDecl *DecomposedClass, DeclAccessPair Field)
Checks implicit access to a member in a structured binding.
SourceLocation getVolatileSpecLoc() const
Definition: DeclSpec.h:553
SourceLocation getThreadStorageClassSpecLoc() const
Definition: DeclSpec.h:457
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:558
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
Definition: DeclCXX.cpp:1725
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3669
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir)
void setRBraceLoc(SourceLocation L)
Definition: DeclCXX.h:2824
Defines the clang::Preprocessor interface.
bool CheckInheritingConstructorUsingDecl(UsingDecl *UD)
Additional checks for a using declaration referring to a constructor name.
bool hasUserDeclaredMoveAssignment() const
Determine whether this class has had a move assignment declared by the user.
Definition: DeclCXX.h:903
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:15007
void ActOnFinishFunctionDeclarationDeclarator(Declarator &D)
Called after parsing a function declarator belonging to a function declaration.
field_iterator field_end() const
Definition: Decl.h:3966
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD)
overridden_method_range overridden_methods() const
Definition: DeclCXX.cpp:2327
bool isLocalExternDecl()
Determine whether this is a block-scope declaration with linkage.
Definition: DeclBase.h:1060
bool isFileContext() const
Definition: DeclBase.h:1854
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:72
DeclContext * getDeclContext()
Definition: DeclBase.h:438
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:533
Overload resolution succeeded.
Definition: Overload.h:53
A parsed C++17 decomposition declarator of the form &#39;[&#39; identifier-list &#39;]&#39;.
Definition: DeclSpec.h:1690
ExprResult BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, TypeSourceInfo *Ty, Expr *E, SourceRange AngleBrackets, SourceRange Parens)
Definition: SemaCast.cpp:258
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition: Type.cpp:2632
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, Expr *Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member, and after instantiating an in-class initializer in a class template.
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation...
Definition: DeclCXX.cpp:543
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
Decl * ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList, SourceLocation SemiLoc)
Handle a C++11 empty-declaration and attribute-declaration.
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:68
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2488
ExceptionSpecificationType getExceptionSpecType() const
Gets the ExceptionSpecificationType as declared.
Definition: Decl.h:2469
static void DefineImplicitSpecialMember(Sema &S, CXXMethodDecl *MD, SourceLocation DefaultLoc)
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Stencil access(llvm::StringRef BaseId, Stencil Member)
Constructs a MemberExpr that accesses the named member (Member) of the object bound to BaseId...
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Definition: DeclBase.h:2458
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack...
Definition: DeclBase.cpp:201
void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param)
ActOnDelayedCXXMethodParameter - We&#39;ve already started a delayed C++ method declaration.
Represents a C++ template name within the type system.
Definition: TemplateName.h:191
bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc, SourceLocation ColonLoc, const ParsedAttributesView &Attrs)
ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
const Expr * getExpr() const
Definition: DeclCXX.h:1796
bool needsImplicitDestructor() const
Determine whether this class needs an implicit destructor to be lazily declared.
Definition: DeclCXX.h:949
static DefaultedFunctionInfo * Create(ASTContext &Context, ArrayRef< DeclAccessPair > Lookups)
Definition: Decl.cpp:2834
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7919
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:456
Defines the clang::TypeLoc interface and its subclasses.
int Depth
Definition: ASTDiff.cpp:190
void ActOnStartTrailingRequiresClause(Scope *S, Declarator &D)
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:1042
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
void DiscardCleanupsInEvaluationContext()
Definition: SemaExpr.cpp:15344
The argument of this type cannot be passed directly in registers.
Definition: Decl.h:3768
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Definition: Decl.h:2589
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn&#39;t...
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined...
Definition: DeclBase.h:621
void propagateDLLAttrToBaseClassTemplate(CXXRecordDecl *Class, Attr *ClassAttr, ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc)
Perform propagation of DLL attributes from a derived class to a templated base class for MS compatibi...
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
Definition: DeclCXX.h:1117
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:3095
void setInheritConstructors(bool Inherit=true)
Set that this base class&#39;s constructors should be inherited.
Definition: DeclCXX.h:211
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Definition: Decl.cpp:2859
bool isInvalid() const
QualType getType() const
Definition: Expr.h:137
bool isFunctionOrMethod() const
Definition: DeclBase.h:1836
static bool isPotentialConstantExpr(const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExpr - Return true if this function&#39;s definition might be usable in a constant exp...
StorageClass
Storage classes.
Definition: Specifiers.h:235
bool hasNonTrivialDestructor() const
Determine whether this class has a non-trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1279
void DefineImplicitMoveAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared move assignment operator.
bool isIdentifier() const
Predicate functions for querying what type of name this is.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Lookup.h:308
InClassInitStyle
In-class initialization styles for non-static data members.
Definition: Specifiers.h:258
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
Get the name of the overloadable C++ operator corresponding to Op.
This declaration has an owning module, and is visible when that module is imported.
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:1784
static bool checkTrivialClassMembers(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM, bool ConstArg, Sema::TrivialABIHandling TAH, bool Diagnose)
Check whether the members of a class type allow a special member to be trivial.
For a defaulted function, the kind of defaulted function that it is.
Definition: Sema.h:2611
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
Definition: Stmt.h:2636
A boolean condition, from &#39;if&#39;, &#39;while&#39;, &#39;for&#39;, or &#39;do&#39;.
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc)
static bool specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, Sema::CXXSpecialMember CSM, unsigned Quals, bool ConstRHS, CXXConstructorDecl *InheritedCtor=nullptr, Sema::InheritedConstructorInfo *Inherited=nullptr)
Is the special member function which would be selected to perform the specified operation on the spec...
QualType getRecordType(const RecordDecl *Decl) const
bool isInvalid() const
Definition: Ownership.h:166
SourceLocation getEnd() const
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:2046
void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method)
Integrate another called method into the collected data.
CXXMethodDecl * getMethodDecl() const
Retrieve the declaration of the called method.
Definition: ExprCXX.cpp:738
void setHasTrivialSpecialMemberForCall()
Definition: DeclCXX.h:1287
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1401
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
Definition: SemaType.cpp:8273
Represents a GCC generic vector type.
Definition: Type.h:3235
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2797
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1091
bool isFriendSpecified() const
Definition: DeclSpec.h:740
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:6925
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2356
void addContextNote(SourceLocation UseLoc)
Definition: Sema.h:857
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class...
Definition: DeclCXX.h:1181
void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an initializer for the declaration ...
void setOperatorDelete(FunctionDecl *OD, Expr *ThisArg)
Definition: DeclCXX.cpp:2667
ValueDecl * getDecl()
Definition: Expr.h:1247
bool needsImplicitDefaultConstructor() const
Determine if we need to declare a default constructor for this class.
Definition: DeclCXX.h:738
bool isUsable() const
Definition: Ownership.h:167
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2713
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:1417
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:181
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2122
bool isUnionType() const
Definition: Type.cpp:527
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2164
static void PopulateKeysForFields(FieldDecl *Field, SmallVectorImpl< const void *> &IdealInits)
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
bool hasNonTrivialMoveAssignment() const
Determine whether this class has a non-trivial move assignment operator (C++11 [class.copy]p25)
Definition: DeclCXX.h:1251
bool isProvablyNotDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is provably not derived from the type Base.
void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM)
Diagnose why the specified class does not have a trivial special member of the given kind...
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:199
bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New, const CXXMethodDecl *Old)
The triviality of a method affected by "trivial_abi".
Definition: Sema.h:2603
void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitDefaultConstructor - Checks for feasibility of defining this constructor as the default...
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:265
void exclude(Decl *F)
Exclude a function from being considered by overload resolution.
Definition: Overload.h:1045
TypeLoc getReturnLoc() const
Definition: TypeLoc.h:1435
static bool RefersToRValueRef(Expr *MemRef)
bool hasValidIntValue() const
True iff we&#39;ve successfully evaluated the variable as a constant expression and extracted its integer...
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:1111
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:288
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:6289
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
#define CheckPolymorphic(Type)
CanQualType getCanonicalTypeUnqualified() const
SourceLocation getRefQualifierLoc() const
Retrieve the location of the ref-qualifier, if any.
Definition: DeclSpec.h:1442
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6315
bool hasGroupingParens() const
Definition: DeclSpec.h:2535
void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow)
Hides a using shadow declaration.
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
Definition: Type.h:4102
RecordDecl * getDecl() const
Definition: Type.h:4505
bool hasVariantMembers() const
Determine whether this class has any variant members.
Definition: DeclCXX.h:1139
noexcept(expression), evals to &#39;false&#39;
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet)
AddBuiltinOperatorCandidates - Add the appropriate built-in operator overloads to the candidate set (...
static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl, DeclStmt *DS, SourceLocation &Cxx1yLoc, Sema::CheckConstexprKind Kind)
Check the given declaration statement is legal within a constexpr function body.
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
Definition: Decl.cpp:4406
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
Definition: Expr.cpp:2056
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
Definition: Decl.h:747
unsigned size_overridden_methods() const
Definition: DeclCXX.cpp:2321
static void SearchForReturnInStmt(Sema &Self, Stmt *S)
Wrapper for source info for arrays.
Definition: TypeLoc.h:1484
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
static bool DiagnoseUnexpandedParameterPacks(Sema &S, TemplateTemplateParmDecl *TTP)
Check for unexpanded parameter packs within the template parameters of a template template parameter...
void checkClassLevelCodeSegAttribute(CXXRecordDecl *Class)
static bool CheckConstexprCtorInitializer(Sema &SemaRef, const FunctionDecl *Dcl, FieldDecl *Field, llvm::SmallSet< Decl *, 16 > &Inits, bool &Diagnosed, Sema::CheckConstexprKind Kind)
Check that the given field is initialized within a constexpr constructor.
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl, CXXConstructorDecl *Constructor, MultiExprArg Exprs, bool HadMultipleCandidates, bool IsListInitialization, bool IsStdInitListInitialization, bool RequiresZeroInit, unsigned ConstructKind, SourceRange ParenRange)
BuildCXXConstructExpr - Creates a complete call to a constructor, including handling of its default a...
bool containsUnexpandedParameterPack() const
Whether this nested-name-specifier contains an unexpanded parameter pack (for C++11 variadic template...
Decl::Kind getDeclKind() const
Definition: DeclBase.h:1777
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
static bool CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef, const FunctionDecl *FnDecl)
UnqualifiedIdKind Kind
Describes the kind of unqualified-id parsed.
Definition: DeclSpec.h:967
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:1075
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1802
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
We are declaring an implicit special member function.
Definition: Sema.h:8042
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition: Overload.h:1053
CXXSpecialMember SpecialMember
The special member being declared or defined.
Definition: Sema.h:8103
CanQualType BuiltinFnTy
Definition: ASTContext.h:1046
The "struct" keyword.
Definition: Type.h:5189
Kind
static CXXConstructorDecl * findUserDeclaredCtor(CXXRecordDecl *RD)
OverloadedOperatorKind getRewrittenOverloadedOperator(OverloadedOperatorKind Kind)
Get the other overloaded operator that the given operator can be rewritten into, if any such operator...
Definition: OperatorKinds.h:36
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1613
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:153
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3813
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:5715
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1151
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2695
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:203
ExtParameterInfo getExtParameterInfo(unsigned I) const
Definition: Type.h:4167
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3975
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:218
SCS getStorageClassSpec() const
Definition: DeclSpec.h:447
ASTContext & getASTContext() const
Definition: Sema.h:1331
SourceRange getSourceRange() const LLVM_READONLY
Determine the source range covering the entire initializer.
Definition: DeclCXX.cpp:2462
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, ArrayRef< TemplateParameterList *> FriendTypeTPLists=None)
Definition: DeclFriend.cpp:34
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:294
llvm::SmallPtrSet< QualType, 4 > IndirectBaseSet
Use small set to collect indirect bases.
bool hasTrivialCopyAssignment() const
Determine whether this class has a trivial copy assignment operator (C++ [class.copy]p11, C++11 [class.copy]p25)
Definition: DeclCXX.h:1231
Encodes a location in the source.
void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record)
body_range body()
Definition: Stmt.h:1365
QualType getReturnType() const
Definition: Type.h:3680
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
static Sema::ImplicitExceptionSpecification ComputeDefaultedComparisonExceptionSpec(Sema &S, SourceLocation Loc, FunctionDecl *FD, Sema::DefaultedComparisonKind DCK)
We are computing the exception specification for a defaulted special member function.
Definition: Sema.h:8028
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4521
bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange)
Mark the given method pure.
bool hasSameTemplateName(TemplateName X, TemplateName Y)
Determine whether the given template names refer to the same template.
llvm::APSInt APSInt
Decl * ActOnFinishLinkageSpecification(Scope *S, Decl *LinkageSpec, SourceLocation RBraceLoc)
ActOnFinishLinkageSpecification - Complete the definition of the C++ linkage specification LinkageSpe...
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
Definition: DeclBase.h:791
unsigned getNumHandlers() const
Definition: StmtCXX.h:106
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1388
Expr * getSubExpr() const
Definition: Expr.h:2076
bool hasErrorOccurred() const
Determine whether any errors have occurred since this object instance was created.
Definition: Diagnostic.h:1020
Decl * BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, StringLiteral *AssertMessageExpr, SourceLocation RParenLoc, bool Failed)
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:2166
void setTrivialForCallFlags(CXXMethodDecl *MD)
Definition: DeclCXX.cpp:1369
Attr * clone(ASTContext &C) const
enum clang::DeclaratorChunk::@219 Kind
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
Definition: DeclSpec.h:1914
CastKind getCastKind() const
Definition: Expr.h:3196
ComparisonCategoryUsage
Definition: Sema.h:5081
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition: Type.cpp:2383
bool isUnnamedBitfield() const
Determines whether this is an unnamed bitfield.
Definition: Decl.h:2810
bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method)
Check whether &#39;this&#39; shows up in the attributes of the given static member function.
DeclarationName getName() const
getName - Returns the embedded declaration name.
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3219
SourceLocation getUsingLoc() const
Return the source location of the &#39;using&#39; keyword.
Definition: DeclCXX.h:3402
void CalledStmt(Stmt *S)
Integrate an invoked statement into the collected data.
void referenceDLLExportedClassMethods()
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:273
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:171
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:377
FunctionTypeInfo Fun
Definition: DeclSpec.h:1546
bool isModulePrivateSpecified() const
Definition: DeclSpec.h:743
InheritedConstructorInfo(Sema &S, SourceLocation UseLoc, ConstructorUsingShadowDecl *Shadow)
Attempt to be ABI-compatible with code generated by Clang 4.0.x (SVN r291814).
static bool CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl, CanQualType ExpectedResultType, CanQualType ExpectedFirstParamType, unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag)
Requests that only tied-for-best candidates be shown.
Definition: Overload.h:74
const ComparisonCategoryInfo * lookupInfoForType(QualType Ty) const
Stmt * getElse()
Definition: Stmt.h:1930
QualType getElementType() const
Definition: Type.h:3270
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
Definition: SemaInternal.h:54
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:1225
void setReferenced(bool R=true)
Definition: DeclBase.h:588
void DeclareImplicitEqualityComparison(CXXRecordDecl *RD, FunctionDecl *Spaceship)
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:914
ParsedAttr - Represents a syntactic attribute.
Definition: ParsedAttr.h:117
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec and return false if there was no error...
Definition: DeclSpec.cpp:589
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:3588
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:4143
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set...
Definition: Decl.h:2876
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
Definition: Type.h:781
const DecompositionDeclarator & getDecompositionDeclarator() const
Definition: DeclSpec.h:1916
void removeShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:2938
void setCtorInitializers(CXXCtorInitializer **Initializers)
Definition: DeclCXX.h:2532
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1931
void setDefaulted(bool D=true)
Definition: Decl.h:2131
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2466
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3995
paths_iterator begin()
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:183
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
Definition: DeclTemplate.h:176
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:1087
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:590
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
No ref-qualifier was provided.
Definition: Type.h:1403
void setEntity(DeclContext *E)
Definition: Scope.h:328
bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckForFunctionMarkedFinal - Checks whether a virtual member function overrides a virtual member fun...
llvm::SmallPtrSet< const CXXRecordDecl *, 8 > RecordDeclSetTy
Definition: Sema.h:660
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2422
std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths)
Builds a string representing ambiguous paths from a specific derived class to different subobjects of...
void setImplicitMoveConstructorIsDeleted()
Set that we attempted to declare an implicit move constructor, but overload resolution failed so we d...
Definition: DeclCXX.h:834
SourceLocation getLocation() const
Definition: Attr.h:92
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4137
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition: Lookup.h:68
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
Qualifiers getMethodQuals() const
Definition: Type.h:4104
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
Definition: Type.h:4047
static CXXBaseSpecifier * findDirectBaseWithType(CXXRecordDecl *Derived, QualType DesiredBase, bool &AnyDependentBases)
Find the base specifier for a base class with the given type.
CanQualType VoidTy
Definition: ASTContext.h:1016
void actOnDelayedExceptionSpecification(Decl *Method, ExceptionSpecificationType EST, SourceRange SpecificationRange, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr)
Add an exception-specification to the given member function (or member function template).
bool isGenericLambda() const
Determine whether this class describes a generic lambda function object (i.e.
Definition: DeclCXX.cpp:1396
Describes the kind of initialization being performed, along with location information for tokens rela...
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:158
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, 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...
static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident)
AbstractDiagSelID
Definition: Sema.h:6793
arg_range arguments()
Definition: Expr.h:2739
AccessSpecifier getAccess() const
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
Definition: SemaType.cpp:1800
bool isObjCObjectPointerType() const
Definition: Type.h:6618
A class for iterating through a result set and possibly filtering out results.
Definition: Lookup.h:617
Direct list-initialization.
Definition: Specifiers.h:261
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2586
llvm::APInt APInt
Definition: Integral.h:27
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax...
Definition: Overload.h:907
static ConstructorUsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, UsingDecl *Using, NamedDecl *Target, bool IsVirtual)
Definition: DeclCXX.cpp:2910
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3274
bool isFunctionProtoType() const
Definition: Type.h:2013
static bool checkSimpleDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, ValueDecl *Src, QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType, llvm::function_ref< ExprResult(SourceLocation, Expr *, unsigned)> GetInit)
void setIsParsingBaseSpecifiers()
Definition: DeclCXX.h:569
Requests that all candidates be shown.
Definition: Overload.h:68
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1713
static FriendTemplateDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc, MutableArrayRef< TemplateParameterList *> Params, FriendUnion Friend, SourceLocation FriendLoc)
CXXRecordDecl * getOrigin() const
Retrieve the type from which this base-paths search began.
static bool BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, CXXBaseSpecifier *BaseSpec, bool IsInheritedVirtualBase, CXXCtorInitializer *&CXXBaseInit)
No entity found met the criteria.
Definition: Lookup.h:50
static bool CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl)
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
Definition: Decl.cpp:3263
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:193
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:178
bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Previous)
Checks that the given using declaration is not an invalid redeclaration.
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
Definition: SemaType.cpp:2081
SourceLocation getRAngleLoc() const
Definition: DeclTemplate.h:197
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted per C++0x.
Definition: Decl.h:2135
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
SourceLocation getInlineSpecLoc() const
Definition: DeclSpec.h:573
Optional< ComparisonCategoryType > getComparisonCategoryForBuiltinCmp(QualType T)
Get the comparison category that should be used when comparing values of type T.
DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD)
Determine the kind of defaulting that would be done for a given function.
QualType AutoDeductTy
Definition: ASTContext.h:1064
NamedDecl * next()
Definition: Lookup.h:643
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:896
void setHasInheritedDefaultArg(bool I=true)
Definition: Decl.h:1729
bool hasFlexibleArrayMember() const
Definition: Decl.h:3802
bool defaultedCopyConstructorIsDeleted() const
true if a defaulted copy constructor for this class would be deleted.
Definition: DeclCXX.h:676
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
static bool checkTupleLikeDecomposition(Sema &S, ArrayRef< BindingDecl *> Bindings, VarDecl *Src, QualType DecompType, const llvm::APSInt &TupleSize)
bool isTrivialForCall() const
Definition: Decl.h:2125
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2345
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:594
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Definition: Decl.cpp:99
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3989
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:224
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
TypeLoc getElementLoc() const
Definition: TypeLoc.h:1517
bool hasInClassInitializer() const
Whether this class has any in-class initializers for non-static data members (including those in anon...
Definition: DeclCXX.h:1061
SourceLocation getLastLocation() const
Definition: DeclSpec.h:2616
CXXDestructorDecl * DeclareImplicitDestructor(CXXRecordDecl *ClassDecl)
Declare the implicit destructor for the given class.
Expr * getLHS() const
Definition: Expr.h:3474
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:4853
A POD class for pairing a NamedDecl* with an access specifier.
bool isUndeducedAutoType() const
Definition: Type.h:6635
CXXConstructorDecl * getConstructor() const
Definition: DeclCXX.h:2370
StringRef getName() const
Return the actual identifier string.
MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, CXXRecordDecl *ClassDecl)
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1930
static void checkForMultipleExportedDefaultConstructors(Sema &S, CXXRecordDecl *Class)
Decl * ActOnExceptionDeclarator(Scope *S, Declarator &D)
ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch handler.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3071
const ComparisonCategoryInfo * lookupInfo(ComparisonCategoryType Kind) const
Return the cached comparison category information for the specified &#39;Kind&#39;.
ast_type_traits::DynTypedNode Node
CanQualType CharTy
Definition: ASTContext.h:1018
TLS with a dynamic initializer.
Definition: Decl.h:843
Represents a template argument.
Definition: TemplateBase.h:50
void setBody(Stmt *B)
Definition: Decl.cpp:2906
TagTypeKind
The kind of a tag type.
Definition: Type.h:5187
static bool isInvalid(LocType Loc, bool *Invalid)
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2454
bool hasNonTrivialCopyConstructorForCall() const
Definition: DeclCXX.h:1196
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2672
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LanguageIDs Lang, bool HasBraces)
Definition: DeclCXX.cpp:2715
Dataflow Directional Tag Classes.
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Definition: Decl.h:3211
static void DelegatingCycleHelper(CXXConstructorDecl *Ctor, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Valid, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Invalid, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Current, Sema &S)
bool isValid() const
Return true if this is a valid SourceLocation object.
CXXConstructorDecl * DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit copy constructor for the given class.
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.cpp:1808
MSPropertyDecl * HandleMSProperty(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS, const ParsedAttr &MSPropertyAttr)
HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:498
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:1271
void setExpr(Expr *E)
Definition: DeclCXX.h:1821
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:402
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:21
static const TST TST_auto
Definition: DeclSpec.h:303
method_iterator begin_overridden_methods() const
Definition: DeclCXX.cpp:2311
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:228
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type &#39;Type&#39;, insert an implicit cast.
Definition: Sema.cpp:529
static void AddMostOverridenMethods(const CXXMethodDecl *MD, llvm::SmallPtrSetImpl< const CXXMethodDecl *> &Methods)
Add the most overriden methods from MD to Methods.
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:132
StmtResult ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, ConditionResult Second, FullExprArg Third, SourceLocation RParenLoc, Stmt *Body)
Definition: SemaStmt.cpp:1763
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with &#39;,...)&#39;, this is true.
Definition: DeclSpec.h:1284
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3756
bool isImplicit() const
Definition: ExprCXX.h:1118
bool isRecord() const
Definition: DeclBase.h:1863
attr_range attrs() const
Definition: DeclBase.h:501
SourceLocation RAngleLoc
The location of the &#39;>&#39; after the template argument list.
static bool InitializationHasSideEffects(const FieldDecl &FD)
static bool CheckConstexprDestructorSubobjects(Sema &SemaRef, const CXXDestructorDecl *DD, Sema::CheckConstexprKind Kind)
Determine whether a destructor cannot be constexpr due to.
bool hasTrivialDestructorForCall() const
Definition: DeclCXX.h:1273
Qualifiers getMethodQualifiers() const
Definition: DeclCXX.h:2076
SourceLocation getBaseTypeLoc() const LLVM_READONLY
Get the location at which the base class type was written.
Definition: DeclCXX.h:193
Represents a field injected from an anonymous union/struct into the parent scope. ...
Definition: Decl.h:2980
void ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc, Expr *defarg)
ActOnParamDefaultArgument - Check whether the default argument provided for a function parameter is w...
bool isCopyConstructor(unsigned &TypeQuals) const
Whether this constructor is a copy constructor (C++ [class.copy]p2, which can be used to copy the cla...
Definition: DeclCXX.cpp:2553
SourceLocation getSourceLocation() const
Determine the source location of the initializer.
Definition: DeclCXX.cpp:2449
QualType getUnderlyingType() const
Definition: Decl.h:3126
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1027
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:118
AccessSpecifier getAccess() const
Definition: DeclBase.h:473
const Expr * getInit() const
Definition: Decl.h:1229
A decomposition declaration.
Definition: DeclCXX.h:3869
MapType::iterator iterator
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
Definition: DeclBase.cpp:1773
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:189
static NamespaceDecl * getNamespaceDecl(NamedDecl *D)
getNamespaceDecl - Returns the namespace a decl represents.
bool hasUserDeclaredConstructor() const
Determine whether this class has any user-declared constructors.
Definition: DeclCXX.h:747
unsigned getIndex() const
Retrieve the index of the template parameter.
void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD)
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3684
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Definition: DeclCXX.cpp:2732
bool areArgsDestroyedLeftToRightInCallee() const
Are arguments to a call destroyed left to right in the callee? This is a fundamental language change...
Definition: TargetCXXABI.h:217
void setWillHaveBody(bool V=true)
Definition: Decl.h:2348
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
The name of a declaration.
StmtClass getStmtClass() const
Definition: Stmt.h:1109
ArrayRef< QualType > exceptions() const
Definition: Type.h:4133
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Lookup.h:517
Expr * getDefaultArg()
Definition: Decl.cpp:2710
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Definition: Decl.h:328
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2046
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:2558
llvm::SmallPtrSet< SpecialMemberDecl, 4 > SpecialMembersBeingDeclared
The C++ special members which we are currently in the process of declaring.
Definition: Sema.h:1256
const Type * getBaseClass() const
If this is a base class initializer, returns the type of the base class.
Definition: DeclCXX.cpp:2442
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:6498
A set of unresolved declarations.
A mapping from each virtual member function to its set of final overriders.
unsigned getNumTemplateParameterLists() const
Definition: Decl.h:759
Represents an enum.
Definition: Decl.h:3481
CXXRecordDecl * Record
The declaration for the comparison category type from the standard library.
bool isAmbiguous(CanQualType BaseType)
Determine whether the path from the most-derived type to the given base type is ambiguous (i...
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2833
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack...
Definition: Decl.cpp:2464
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:175
semantics_iterator semantics_begin()
Definition: Expr.h:5783
bool isDestroyingOperatorDelete() const
Determine whether this is a destroying operator delete.
Definition: Decl.cpp:3057
Expr * get() const
Definition: Sema.h:4072
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:582
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
MemInitResult BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo, Expr *Init, CXXRecordDecl *ClassDecl, SourceLocation EllipsisLoc)
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1086
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:510
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
Definition: SemaDecl.cpp:11689
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 &#39;auto&#39; typ...
Definition: Type.h:6900
friend_range friends() const
Definition: DeclFriend.h:247
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:196
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:2995
void PushUsingDirective(UsingDirectiveDecl *UDir)
Definition: Scope.h:466
CXXConstructorDecl * DeclareImplicitDefaultConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit default constructor for the given class.
void addConst()
Definition: Type.h:263
std::pair< CXXConstructorDecl *, bool > findConstructorForBase(CXXRecordDecl *Base, CXXConstructorDecl *Ctor) const
Find the constructor to use for inherited construction of a base class, and whether that base class c...
We are declaring an implicit &#39;operator==&#39; for a defaulted &#39;operator<=>&#39;.
Definition: Sema.h:8046
void forEachQualifier(llvm::function_ref< void(TQ, StringRef, SourceLocation)> Handle)
This method calls the passed in handler on each qual being set.
Definition: DeclSpec.cpp:421
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
unsigned getNumParams() const
Definition: TypeLoc.h:1426
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2175
void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S, QualType T1, QualType T2, UnresolvedSetImpl &Functions)
SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D, CXXSpecialMember SM, bool ConstArg, bool VolatileArg, bool RValueThis, bool ConstThis, bool VolatileThis)
const FunctionDecl * getOperatorDelete() const
Definition: DeclCXX.h:2683
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:152
static FunctionProtoType::ExtProtoInfo getImplicitMethodEPI(Sema &S, CXXMethodDecl *MD)
UsingDecl * getUsingDecl() const
Gets the using declaration to which this declaration is tied.
Definition: DeclCXX.cpp:2899
void RemoveDecl(Decl *D)
Definition: Scope.h:293
Name lookup found a single declaration that met the criteria.
Definition: Lookup.h:59
bool needsOverloadResolutionForMoveConstructor() const
Determine whether we need to eagerly declare a defaulted move constructor for this class...
Definition: DeclCXX.h:862
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...
unsigned getIntWidth(QualType T) const
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2566
Not an overloaded operator.
Definition: OperatorKinds.h:22
static AccessSpecifier MergeAccess(AccessSpecifier PathAccess, AccessSpecifier DeclAccess)
Calculates the access of a decl that is reached along a path.
Definition: DeclCXX.h:1665
bool isIncompleteArrayType() const
Definition: Type.h:6578
bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths, bool LookupInDependent=false) const
Look for entities within the base classes of this C++ class, transitively searching all base class su...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4495
Complex values, per C99 6.2.5p11.
Definition: Type.h:2554
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:449
static bool CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl)
MapType::const_iterator const_iterator
void setUnparsedDefaultArg()
Specify that this parameter has an unparsed default argument.
Definition: Decl.h:1721
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:2752
bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl)
CheckLiteralOperatorDeclaration - Check whether the declaration of this literal operator function is ...
void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD, bool ConstexprOnly=false)
MarkVirtualMembersReferenced - Will mark all members of the given CXXRecordDecl referenced.
bool checkInitIsICE() const
Determine whether the value of the initializer attached to this declaration is an integral constant e...
Definition: Decl.cpp:2428
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:550
static void extendRight(SourceRange &R, SourceRange After)
QualType getCanonicalTypeInternal() const
Definition: Type.h:2429
SourceLocation getVirtualSpecLoc() const
Definition: DeclSpec.h:582
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2155
LanguageIDs
Represents the language in a linkage specification.
Definition: DeclCXX.h:2787
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6811
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:185
SourceRange getSourceRange() const LLVM_READONLY
getSourceRange - The range of the declaration name.
bool needsOverloadResolutionForMoveAssignment() const
Determine whether we need to eagerly declare a move assignment operator for this class.
Definition: DeclCXX.h:936
void setConstexprKind(ConstexprSpecKind CSK)
Definition: Decl.h:2203
bool hasNonTrivialObjCLifetime() const
Definition: Type.h:1084
IndirectFieldDecl * getIndirectMember() const
Definition: DeclCXX.h:2305
T * getAttr() const
Definition: DeclBase.h:538
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
type_object_range type_objects() const
Returns the range of type objects, from the identifier outwards.
Definition: DeclSpec.h:2237
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
const llvm::APInt & getSize() const
Definition: Type.h:2958
CanQualType DependentTy
Definition: ASTContext.h:1045
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, NonOdrUseReason NOUR=NOUR_None)
Definition: Expr.cpp:545
bool isFunctionType() const
Definition: Type.h:6500
ArrayRef< TemplateParameterList * > getTemplateParameterLists() const
The template parameter lists that preceded the declarator.
Definition: DeclSpec.h:2462
TrivialSubobjectKind
The kind of subobject we are checking for triviality.
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1069
NamedDecl * ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, Expr *BitfieldWidth, const VirtSpecifiers &VS, InClassInitStyle InitStyle)
ActOnCXXMemberDeclarator - This is invoked when a C++ class member declarator is parsed.
static const void * GetKeyForBase(ASTContext &Context, QualType BaseType)
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:700
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
CXXBasePath & front()
Opcode getOpcode() const
Definition: Expr.h:2071
static bool CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S, SmallVectorImpl< SourceLocation > &ReturnStmts, SourceLocation &Cxx1yLoc, SourceLocation &Cxx2aLoc, Sema::CheckConstexprKind Kind)
Check the provided statement is allowed in a constexpr function definition.
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1573
bool isImplicitlyDeleted(FunctionDecl *FD)
Determine whether the given function is an implicitly-deleted special member function.
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2750
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1747
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2321
decl_range decls()
Definition: Stmt.h:1273
static UsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, UsingDecl *Using, NamedDecl *Target)
Definition: DeclCXX.h:3197
QualType getAutoDeductType() const
C++11 deduction pattern for &#39;auto&#39; type.
TypeLocClass getTypeLocClass() const
Definition: TypeLoc.h:115
ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, FieldDecl *Field, DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo)
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr)
Definition: SemaExpr.cpp:13576
The template argument is a type.
Definition: TemplateBase.h:59
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
Holds information about the various types of exception specification.
Definition: Type.h:3811
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:92
const LinkageSpecDecl * getExternCContext() const
Retrieve the nearest enclosing C linkage specification context.
Definition: DeclBase.cpp:1146
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause=nullptr)
Definition: DeclCXX.cpp:2653
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1524
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
void setInherited(bool I)
Definition: Attr.h:149
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:253
The "class" keyword.
Definition: Type.h:5198
Represents a base class of a C++ class.
Definition: DeclCXX.h:145
bool hasTypename() const
Return true if the using declaration has &#39;typename&#39;.
Definition: DeclCXX.h:3424
bool isInitListConstructor(const FunctionDecl *Ctor)
Determine whether Ctor is an initializer-list constructor, as defined in [dcl.init.list]p2.
void checkClassLevelDLLAttribute(CXXRecordDecl *Class)
Check class-level dllimport/dllexport attribute.
QualType CheckComparisonCategoryType(ComparisonCategoryType Kind, SourceLocation Loc, ComparisonCategoryUsage Usage)
Lookup the specified comparison category types in the standard library, an check the VarDecls possibl...
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
Definition: DeclBase.cpp:413
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2104
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3816
This is a scope that can contain a declaration.
Definition: Scope.h:59
bool isObjCObjectType() const
Definition: Type.h:6622
static BindingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id)
Definition: DeclCXX.cpp:3068
CanQualType Char8Ty
Definition: ASTContext.h:1022
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2513
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:2178
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2305
TrivialABIHandling
Definition: Sema.h:2598
static const void * GetKeyForMember(ASTContext &Context, CXXCtorInitializer *Member)
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1279
EnumDecl * getStdAlignValT() const
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
bool isLValueReferenceType() const
Definition: Type.h:6520
bool needsImplicitCopyConstructor() const
Determine whether this class needs an implicit copy constructor to be lazily declared.
Definition: DeclCXX.h:766
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:244
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1692
void setInvalidType(bool Val=true)
Definition: DeclSpec.h:2529
Reading or writing from this object requires a barrier call.
Definition: Type.h:174
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Definition: Type.h:3819
void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc)
ActOnParamDefaultArgumentError - Parsing or semantic analysis of the default argument for the paramet...
void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a block pointer.
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:234
unsigned getDepth() const
Definition: Type.h:4690
static void BuildBasePathArray(const CXXBasePath &Path, CXXCastPath &BasePathArray)
QualType getParamType(unsigned i) const
Definition: Type.h:3966
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups, surround it with a ExprWithCleanups node.
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\, const ASTContext *Context=nullptr) const
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1009
void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc, CXXRecordDecl *Record)
MarkBaseAndMemberDestructorsReferenced - Given a record decl, mark all the non-trivial destructors of...
void Deallocate(void *Ptr) const
Definition: ASTContext.h:692
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2836
static bool functionDeclHasDefaultArgument(const FunctionDecl *FD)
void CheckOverrideControl(NamedDecl *D)
CheckOverrideControl - Check C++11 override control semantics.
CallingConv getCallConv() const
Definition: Type.h:3690
ThreadStorageClassSpecifier
Thread storage-class-specifier.
Definition: Specifiers.h:222
void setImplicitMoveAssignmentIsDeleted()
Set that we attempted to declare an implicit move assignment operator, but overload resolution failed...
Definition: DeclCXX.h:915
Describes the sequence of initializations required to initialize a given object or reference with a s...
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
ArrayRef< DeclAccessPair > pairs() const
Definition: UnresolvedSet.h:89
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
ActionResult< Expr * > ExprResult
Definition: Ownership.h:263
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:6336
SourceLocation getRestrictSpecLoc() const
Definition: DeclSpec.h:552
void setDefaultArg(Expr *defarg)
Definition: Decl.cpp:2722
bool isMutable() const
Determines whether this field is mutable (C++ only).
Definition: Decl.h:2804
void setEnd(SourceLocation e)
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn&#39;t on...
Represents a C++ struct/union/class.
Definition: DeclCXX.h:253
static bool CheckConstexprParameterTypes(Sema &SemaRef, const FunctionDecl *FD, Sema::CheckConstexprKind Kind)
Check whether a function&#39;s parameter types are all literal types.
static bool isCompoundAssignmentOp(Opcode Opc)
Definition: Expr.h:3565
void setIvarInitializers(ASTContext &C, CXXCtorInitializer **initializers, unsigned numInitializers)
Definition: DeclObjC.cpp:2195
bool isValid() const
bool hasUserDeclaredMoveConstructor() const
Determine whether this class has had a move constructor declared by the user.
Definition: DeclCXX.h:813
bool CompleteConstructorCall(CXXConstructorDecl *Constructor, MultiExprArg ArgsPtr, SourceLocation Loc, SmallVectorImpl< Expr *> &ConvertedArgs, bool AllowExplicit=false, bool IsListInitialization=false)
Given a constructor and the set of arguments provided for the constructor, convert the arguments and ...
void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc)
bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, ArrayRef< CXXCtorInitializer *> Initializers=None)
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
bool isVoidType() const
Definition: Type.h:6777
bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier *> Bases)
Performs the actual work of attaching the given base class specifiers to a C++ class.
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:3808
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:28
bool LE(InterpState &S, CodePtr OpPC)
Definition: Interp.h:237
void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6283
void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc, SourceLocation ArgLoc)
ActOnParamUnparsedDefaultArgument - We&#39;ve seen a default argument for a function parameter, but we can&#39;t parse it yet because we&#39;re inside a class definition.
static IsTupleLike isTupleLike(Sema &S, SourceLocation Loc, QualType T, llvm::APSInt &Size)
void setParam(unsigned i, ParmVarDecl *VD)
Definition: TypeLoc.h:1433
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:191
CanQualType Char16Ty
Definition: ASTContext.h:1023
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that&#39;s ...
bool isInherited() const
Definition: Attr.h:94
static bool hasOneRealArgument(MultiExprArg Args)
Determine whether the given list arguments contains exactly one "real" (non-default) argument...
AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, QualType Derived, const CXXBasePath &Path, unsigned DiagID, bool ForceCheck=false, bool ForceUnprivileged=false)
Checks access for a hierarchy conversion.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1895
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:397
void setUnsupportedFriend(bool Unsupported)
Definition: DeclFriend.h:177
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
Definition: DeclCXX.cpp:2959
bool isRValue() const
Definition: Expr.h:259
Declaration of a class template.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
bool isVirtualSpecified() const
Definition: DeclSpec.h:581
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
void setInventedTemplateParameterList(TemplateParameterList *Invented)
Sets the template parameter list generated from the explicit template parameters along with any inven...
Definition: DeclSpec.h:2469
void addAttr(Attr *A)
Definition: DeclBase.cpp:832
bool lambdaIsDefaultConstructibleAndAssignable() const
Determine whether this lambda should have an implicit default constructor and copy and move assignmen...
Definition: DeclCXX.cpp:653
NamedDecl * getAcceptableDecl(NamedDecl *D) const
Retrieve the accepted (re)declaration of the given declaration, if there is one.
Definition: Lookup.h:361
void CheckExplicitlyDefaultedFunction(Scope *S, FunctionDecl *MD)
SourceManager & getSourceManager() const
Definition: Sema.h:1329
SourceRange getDefaultArgRange() const
Retrieve the source range that covers the entire default argument.
Definition: Decl.cpp:2727
iterator end() const
Definition: Lookup.h:336
A template-id, e.g., f<int>.
bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionReturnType - Checks whether the return types are covariant, according to C++ [class.virtual]p5.
bool hasInheritedAssignment() const
Determine whether this class has a using-declaration that names a base class assignment operator...
Definition: DeclCXX.h:1323
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:263
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1327
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1711
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2546
AccessSpecifier Access
The access along this inheritance path.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:160
bool isInlineSpecified() const
Definition: DeclSpec.h:570
static bool defaultedSpecialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, Sema::CXXSpecialMember CSM, bool ConstArg, CXXConstructorDecl *InheritedCtor=nullptr, Sema::InheritedConstructorInfo *Inherited=nullptr)
Determine whether the specified special member function would be constexpr if it were implicitly defi...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3868
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
Definition: Decl.h:2078
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:91
SourceLocation getAtomicSpecLoc() const
Definition: DeclSpec.h:554
ExprResult ExprError()
Definition: Ownership.h:279
bool hasVolatile() const
Definition: Type.h:265
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated, or computed.
FriendDecl * CheckFriendTypeDecl(SourceLocation LocStart, SourceLocation FriendLoc, TypeSourceInfo *TSInfo)
Perform semantic analysis of the given friend type declaration.
capture_iterator capture_begin() const
Retrieve an iterator pointing to the first lambda capture.
Definition: ExprCXX.cpp:1245
static void CheckAbstractClassUsage(AbstractUsageInfo &Info, CXXMethodDecl *MD)
Check for invalid uses of an abstract type in a method declaration.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name.
Definition: DeclCXX.h:3412
NameKind getKind() const
CanQualType IntTy
Definition: ASTContext.h:1025
unsigned getNumElements() const
Definition: Type.h:3271
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:225
The top declaration context.
Definition: Decl.h:82
Microsoft __declspec(nothrow) extension.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2150
SourceLocation getConstexprSpecLoc() const
Definition: DeclSpec.h:750
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:256
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1171
void CheckConversionDeclarator(Declarator &D, QualType &R, StorageClass &SC)
CheckConversionDeclarator - Called by ActOnDeclarator to check the well-formednes of the conversion f...
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
Definition: Scope.h:232
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
Definition: DeclSpec.h:1471
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:825
bool isUnion() const
Definition: Decl.h:3407
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4996
NamedDecl * getMostRecentDecl()
Definition: Decl.h:428
Expr * getRHS() const
Definition: Expr.h:3476
void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD)
Diagnose methods which overload virtual methods in a base class without overriding any...
CXXMethodDecl * DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl)
Declare the implicit copy assignment operator for the given class.
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2259
bool isPointerType() const
Definition: Type.h:6504
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:3517
bool implicitCopyConstructorHasConstParam() const
Determine whether an implicit copy constructor for this type would have a parameter with a const-qual...
Definition: DeclCXX.h:787
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:18
void addAddressSpace(LangAS space)
Definition: Type.h:385
void setBaseObjectType(QualType T)
Sets the base object type for this lookup.
Definition: Lookup.h:420
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:66
bool needsImplicitMoveConstructor() const
Determine whether this class should get an implicit move constructor or if any existing special membe...
Definition: DeclCXX.h:852
No viable function found.
Definition: Overload.h:56
ArrayRef< Binding > bindings() const
Definition: DeclSpec.h:1727
bool CheckDestructor(CXXDestructorDecl *Destructor)
CheckDestructor - Checks a fully-formed destructor definition for well-formedness, issuing any diagnostics required.
DeclaratorContext getContext() const
Definition: DeclSpec.h:1920
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1144
SourceLocation getInnerLocStart() const
Return SourceLocation representing start of source range ignoring outer template declarations.
Definition: Decl.h:3305
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:583
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace nested inside this namespace, if any.
Definition: Decl.h:580
bool hasDirectFields() const
Determine whether this class has direct non-static data members.
Definition: DeclCXX.h:1110
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:3940
void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD, DefaultedComparisonKind DCK)
IdentifierInfo * getCXXLiteralIdentifier() const
If this name is the name of a literal operator, retrieve the identifier associated with it...
QualType getType() const
Definition: Decl.h:630
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:129
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:339
A trivial tuple used to represent a source range.
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:299
ASTContext & Context
Definition: Sema.h:385
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3158
paths_iterator end()
This represents a decl that may have a name.
Definition: Decl.h:223
virtual void diagnose(Sema &S, SourceLocation Loc, QualType T)=0
void dropAttr()
Definition: DeclBase.h:513
bool isTranslationUnit() const
Definition: DeclBase.h:1859
Expr * getRepAsExpr() const
Definition: DeclSpec.h:497
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:77
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:468
bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec)
tryResolveExplicitSpecifier - Attempt to resolve the explict specifier.
CanQualType BoolTy
Definition: ASTContext.h:1017
Represents a C++ namespace alias.
Definition: DeclCXX.h:2967
Decl * ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc, unsigned TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, MultiTemplateParamsArg TempParamLists)
Handle a friend tag declaration where the scope specifier was templated.
No keyword precedes the qualified type name.
Definition: Type.h:5227
SourceRange getSourceRange() const LLVM_READONLY
Retrieves the source range that contains the entire base specifier.
Definition: DeclCXX.h:188
FullExprArg MakeFullDiscardedValueExpr(Expr *Arg)
Definition: Sema.h:4095
iterator begin() const
Definition: Lookup.h:335
Represents C++ using-directive.
Definition: DeclCXX.h:2863
void DiagnoseAbstractType(const CXXRecordDecl *RD)
static Expr * CastForMoving(Sema &SemaRef, Expr *E, QualType T=QualType())
bool isAggregate() const
Determine whether this class is an aggregate (C++ [dcl.init.aggr]), which is a class with no user-dec...
Definition: DeclCXX.h:1056
Describes an entity that is being initialized.
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
attr::Kind getKind() const
Definition: Attr.h:85
MemInitResult ActOnMemInitializer(Decl *ConstructorD, Scope *S, CXXScopeSpec &SS, IdentifierInfo *MemberOrBase, ParsedType TemplateTypeTy, const DeclSpec &DS, SourceLocation IdLoc, SourceLocation LParenLoc, ArrayRef< Expr *> Args, SourceLocation RParenLoc, SourceLocation EllipsisLoc)
Handle a C++ member initializer using parentheses syntax.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Lookup.h:524
ComparisonCategoryType
An enumeration representing the different comparison categories types.
The global specifier &#39;::&#39;. There is no stored value.
NestedNameSpecifier * getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
NamedDecl * ActOnDecompositionDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists)
The object is actually the complete object.
FunctionTypeLoc getFunctionTypeLoc() const
Find the source location information for how the type of this function was written.
Definition: Decl.cpp:3389
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:3242
void setType(QualType newType)
Definition: Decl.h:631
ctor_range ctors() const
Definition: DeclCXX.h:649
Decl * ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS, MultiTemplateParamsArg TemplateParams, SourceLocation UsingLoc, UnqualifiedId &Name, const ParsedAttributesView &AttrList, TypeResult Type, Decl *DeclFromDeclSpec)
bool hasInit() const
Definition: Decl.cpp:2226
Wrapper for source info for pointers.
Definition: TypeLoc.h:1226
SourceLocation getBegin() const
ParsedAttributes - A collection of parsed attributes.
Definition: ParsedAttr.h:824
StmtResult ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr, Stmt *InitStmt, ConditionResult Cond, Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal)
Definition: SemaStmt.cpp:563
SourceLocation ColonLoc
Location of &#39;:&#39;.
Definition: OpenMPClause.h:107
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclTemplate.h:199
const LangOptions & getLangOpts() const
Definition: ASTContext.h:724
void WillReplaceSpecifier(bool ForceReplacement)
Wrapper for source info for block pointers.
Definition: TypeLoc.h:1239
void setDeletedAsWritten(bool D=true)
Definition: Decl.h:2267
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).
ComparisonCategoryType commonComparisonType(ComparisonCategoryType A, ComparisonCategoryType B)
Determine the common comparison type, as defined in C++2a [class.spaceship]p4.
An implicit &#39;self&#39; parameter.
void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation)
SetIvarInitializers - This routine builds initialization ASTs for the Objective-C implementation whos...
No in-class initializer.
Definition: Specifiers.h:259
base_class_range vbases()
Definition: DeclCXX.h:604
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2935
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3843
static InitializedEntity InitializeBinding(VarDecl *Binding)
Create the initialization entity for a structured binding.
A deduction-guide name (a template-name)
Declaration of a template function.
Definition: DeclTemplate.h:977
Decl * ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList)
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:5117
bool SetDelegatingInitializer(CXXConstructorDecl *Constructor, CXXCtorInitializer *Initializer)
void DiagnoseAbsenceOfOverrideControl(NamedDecl *D)
DiagnoseAbsenceOfOverrideControl - Diagnose if &#39;override&#39; keyword was not used in the declaration of ...
ParamInfo * Params
Params - This is a pointer to a new[]&#39;d array of ParamInfo objects that describe the parameters speci...
Definition: DeclSpec.h:1339
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2096
Comparison
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:645
static bool checkLiteralOperatorTemplateParameterList(Sema &SemaRef, FunctionTemplateDecl *TpDecl)
static const ParsedAttr * getMSPropertyAttr(const ParsedAttributesView &list)
Attr - This represents one attribute.
Definition: Attr.h:45
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:787
SourceLocation getLocation() const
Definition: DeclBase.h:429
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3162
bool isExternallyVisible() const
Definition: Decl.h:362
LangStandard::Kind Std
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:6238
A single template declaration.
Definition: TemplateName.h:204
bool isBeingDefined() const
Return true if this decl is currently being defined.
Definition: Decl.h:3344
ConstructorUsingShadowDecl * getShadowDecl() const
Definition: DeclCXX.h:2369
noexcept(expression), evals to &#39;true&#39;
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1364
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2991
Decl * ActOnConversionDeclarator(CXXConversionDecl *Conversion)
ActOnConversionDeclarator - Called by ActOnDeclarator to complete the declaration of the given C++ co...
decl_iterator decls_end() const
Definition: DeclBase.h:2035
The triviality of a method unaffected by "trivial_abi".
Definition: Sema.h:2600
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1080
static bool isVisible(Sema &SemaRef, NamedDecl *D)
Determine whether the given declaration is visible to the program.
Definition: Lookup.h:349
NamedDecl * ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams)
static void lookupOperatorsForDefaultedComparison(Sema &Self, Scope *S, UnresolvedSetImpl &Operators, OverloadedOperatorKind Op)
Perform the unqualified lookups that might be needed to form a defaulted comparison function for the ...
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:1123
unsigned ActOnReenterTemplateScope(Scope *S, Decl *Template)
static void DiagnoseNamespaceInlineMismatch(Sema &S, SourceLocation KeywordLoc, SourceLocation Loc, IdentifierInfo *II, bool *IsInline, NamespaceDecl *PrevNS)
Diagnose a mismatch in &#39;inline&#39; qualifiers when a namespace is reopened.
A RAII object to temporarily push a declaration context.
Definition: Sema.h:797
method_range methods() const
Definition: DeclCXX.h:629
The subobject is a non-static data member.
bool isNoDestroy(const ASTContext &) const
Is destruction of this variable entirely suppressed? If so, the variable need not have a usable destr...
Definition: Decl.cpp:2606
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:244
ComparisonCategories CompCategories
Types and expressions required to build C++2a three-way comparisons using operator<=>, including the values return by builtin <=> operators.
Definition: ASTContext.h:2055
bool defaultedDestructorIsDeleted() const
true if a defaulted destructor for this class would be deleted.
Definition: DeclCXX.h:693