• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file implements semantic analysis for C++ declarations.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Sema/SemaInternal.h"
15 #include "clang/AST/ASTConsumer.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/ASTLambda.h"
18 #include "clang/AST/ASTMutationListener.h"
19 #include "clang/AST/CXXInheritance.h"
20 #include "clang/AST/CharUnits.h"
21 #include "clang/AST/EvaluatedExprVisitor.h"
22 #include "clang/AST/ExprCXX.h"
23 #include "clang/AST/RecordLayout.h"
24 #include "clang/AST/RecursiveASTVisitor.h"
25 #include "clang/AST/StmtVisitor.h"
26 #include "clang/AST/TypeLoc.h"
27 #include "clang/AST/TypeOrdering.h"
28 #include "clang/Basic/PartialDiagnostic.h"
29 #include "clang/Basic/TargetInfo.h"
30 #include "clang/Lex/LiteralSupport.h"
31 #include "clang/Lex/Preprocessor.h"
32 #include "clang/Sema/CXXFieldCollector.h"
33 #include "clang/Sema/DeclSpec.h"
34 #include "clang/Sema/Initialization.h"
35 #include "clang/Sema/Lookup.h"
36 #include "clang/Sema/ParsedTemplate.h"
37 #include "clang/Sema/Scope.h"
38 #include "clang/Sema/ScopeInfo.h"
39 #include "clang/Sema/Template.h"
40 #include "llvm/ADT/STLExtras.h"
41 #include "llvm/ADT/SmallString.h"
42 #include <map>
43 #include <set>
44 
45 using namespace clang;
46 
47 //===----------------------------------------------------------------------===//
48 // CheckDefaultArgumentVisitor
49 //===----------------------------------------------------------------------===//
50 
51 namespace {
52   /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
53   /// the default argument of a parameter to determine whether it
54   /// contains any ill-formed subexpressions. For example, this will
55   /// diagnose the use of local variables or parameters within the
56   /// default argument expression.
57   class CheckDefaultArgumentVisitor
58     : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
59     Expr *DefaultArg;
60     Sema *S;
61 
62   public:
CheckDefaultArgumentVisitor(Expr * defarg,Sema * s)63     CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
64       : DefaultArg(defarg), S(s) {}
65 
66     bool VisitExpr(Expr *Node);
67     bool VisitDeclRefExpr(DeclRefExpr *DRE);
68     bool VisitCXXThisExpr(CXXThisExpr *ThisE);
69     bool VisitLambdaExpr(LambdaExpr *Lambda);
70     bool VisitPseudoObjectExpr(PseudoObjectExpr *POE);
71   };
72 
73   /// VisitExpr - Visit all of the children of this expression.
VisitExpr(Expr * Node)74   bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
75     bool IsInvalid = false;
76     for (Stmt *SubStmt : Node->children())
77       IsInvalid |= Visit(SubStmt);
78     return IsInvalid;
79   }
80 
81   /// VisitDeclRefExpr - Visit a reference to a declaration, to
82   /// determine whether this declaration can be used in the default
83   /// argument expression.
VisitDeclRefExpr(DeclRefExpr * DRE)84   bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
85     NamedDecl *Decl = DRE->getDecl();
86     if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
87       // C++ [dcl.fct.default]p9
88       //   Default arguments are evaluated each time the function is
89       //   called. The order of evaluation of function arguments is
90       //   unspecified. Consequently, parameters of a function shall not
91       //   be used in default argument expressions, even if they are not
92       //   evaluated. Parameters of a function declared before a default
93       //   argument expression are in scope and can hide namespace and
94       //   class member names.
95       return S->Diag(DRE->getLocStart(),
96                      diag::err_param_default_argument_references_param)
97          << Param->getDeclName() << DefaultArg->getSourceRange();
98     } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
99       // C++ [dcl.fct.default]p7
100       //   Local variables shall not be used in default argument
101       //   expressions.
102       if (VDecl->isLocalVarDecl())
103         return S->Diag(DRE->getLocStart(),
104                        diag::err_param_default_argument_references_local)
105           << VDecl->getDeclName() << DefaultArg->getSourceRange();
106     }
107 
108     return false;
109   }
110 
111   /// VisitCXXThisExpr - Visit a C++ "this" expression.
VisitCXXThisExpr(CXXThisExpr * ThisE)112   bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
113     // C++ [dcl.fct.default]p8:
114     //   The keyword this shall not be used in a default argument of a
115     //   member function.
116     return S->Diag(ThisE->getLocStart(),
117                    diag::err_param_default_argument_references_this)
118                << ThisE->getSourceRange();
119   }
120 
VisitPseudoObjectExpr(PseudoObjectExpr * POE)121   bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(PseudoObjectExpr *POE) {
122     bool Invalid = false;
123     for (PseudoObjectExpr::semantics_iterator
124            i = POE->semantics_begin(), e = POE->semantics_end(); i != e; ++i) {
125       Expr *E = *i;
126 
127       // Look through bindings.
128       if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
129         E = OVE->getSourceExpr();
130         assert(E && "pseudo-object binding without source expression?");
131       }
132 
133       Invalid |= Visit(E);
134     }
135     return Invalid;
136   }
137 
VisitLambdaExpr(LambdaExpr * Lambda)138   bool CheckDefaultArgumentVisitor::VisitLambdaExpr(LambdaExpr *Lambda) {
139     // C++11 [expr.lambda.prim]p13:
140     //   A lambda-expression appearing in a default argument shall not
141     //   implicitly or explicitly capture any entity.
142     if (Lambda->capture_begin() == Lambda->capture_end())
143       return false;
144 
145     return S->Diag(Lambda->getLocStart(),
146                    diag::err_lambda_capture_default_arg);
147   }
148 }
149 
150 void
CalledDecl(SourceLocation CallLoc,const CXXMethodDecl * Method)151 Sema::ImplicitExceptionSpecification::CalledDecl(SourceLocation CallLoc,
152                                                  const CXXMethodDecl *Method) {
153   // If we have an MSAny spec already, don't bother.
154   if (!Method || ComputedEST == EST_MSAny)
155     return;
156 
157   const FunctionProtoType *Proto
158     = Method->getType()->getAs<FunctionProtoType>();
159   Proto = Self->ResolveExceptionSpec(CallLoc, Proto);
160   if (!Proto)
161     return;
162 
163   ExceptionSpecificationType EST = Proto->getExceptionSpecType();
164 
165   // If we have a throw-all spec at this point, ignore the function.
166   if (ComputedEST == EST_None)
167     return;
168 
169   switch(EST) {
170   // If this function can throw any exceptions, make a note of that.
171   case EST_MSAny:
172   case EST_None:
173     ClearExceptions();
174     ComputedEST = EST;
175     return;
176   // FIXME: If the call to this decl is using any of its default arguments, we
177   // need to search them for potentially-throwing calls.
178   // If this function has a basic noexcept, it doesn't affect the outcome.
179   case EST_BasicNoexcept:
180     return;
181   // If we're still at noexcept(true) and there's a nothrow() callee,
182   // change to that specification.
183   case EST_DynamicNone:
184     if (ComputedEST == EST_BasicNoexcept)
185       ComputedEST = EST_DynamicNone;
186     return;
187   // Check out noexcept specs.
188   case EST_ComputedNoexcept:
189   {
190     FunctionProtoType::NoexceptResult NR =
191         Proto->getNoexceptSpec(Self->Context);
192     assert(NR != FunctionProtoType::NR_NoNoexcept &&
193            "Must have noexcept result for EST_ComputedNoexcept.");
194     assert(NR != FunctionProtoType::NR_Dependent &&
195            "Should not generate implicit declarations for dependent cases, "
196            "and don't know how to handle them anyway.");
197     // noexcept(false) -> no spec on the new function
198     if (NR == FunctionProtoType::NR_Throw) {
199       ClearExceptions();
200       ComputedEST = EST_None;
201     }
202     // noexcept(true) won't change anything either.
203     return;
204   }
205   default:
206     break;
207   }
208   assert(EST == EST_Dynamic && "EST case not considered earlier.");
209   assert(ComputedEST != EST_None &&
210          "Shouldn't collect exceptions when throw-all is guaranteed.");
211   ComputedEST = EST_Dynamic;
212   // Record the exceptions in this function's exception specification.
213   for (const auto &E : Proto->exceptions())
214     if (ExceptionsSeen.insert(Self->Context.getCanonicalType(E)).second)
215       Exceptions.push_back(E);
216 }
217 
CalledExpr(Expr * E)218 void Sema::ImplicitExceptionSpecification::CalledExpr(Expr *E) {
219   if (!E || ComputedEST == EST_MSAny)
220     return;
221 
222   // FIXME:
223   //
224   // C++0x [except.spec]p14:
225   //   [An] implicit exception-specification specifies the type-id T if and
226   // only if T is allowed by the exception-specification of a function directly
227   // invoked by f's implicit definition; f shall allow all exceptions if any
228   // function it directly invokes allows all exceptions, and f shall allow no
229   // exceptions if every function it directly invokes allows no exceptions.
230   //
231   // Note in particular that if an implicit exception-specification is generated
232   // for a function containing a throw-expression, that specification can still
233   // be noexcept(true).
234   //
235   // Note also that 'directly invoked' is not defined in the standard, and there
236   // is no indication that we should only consider potentially-evaluated calls.
237   //
238   // Ultimately we should implement the intent of the standard: the exception
239   // specification should be the set of exceptions which can be thrown by the
240   // implicit definition. For now, we assume that any non-nothrow expression can
241   // throw any exception.
242 
243   if (Self->canThrow(E))
244     ComputedEST = EST_None;
245 }
246 
247 bool
SetParamDefaultArgument(ParmVarDecl * Param,Expr * Arg,SourceLocation EqualLoc)248 Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,
249                               SourceLocation EqualLoc) {
250   if (RequireCompleteType(Param->getLocation(), Param->getType(),
251                           diag::err_typecheck_decl_incomplete_type)) {
252     Param->setInvalidDecl();
253     return true;
254   }
255 
256   // C++ [dcl.fct.default]p5
257   //   A default argument expression is implicitly converted (clause
258   //   4) to the parameter type. The default argument expression has
259   //   the same semantic constraints as the initializer expression in
260   //   a declaration of a variable of the parameter type, using the
261   //   copy-initialization semantics (8.5).
262   InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
263                                                                     Param);
264   InitializationKind Kind = InitializationKind::CreateCopy(Param->getLocation(),
265                                                            EqualLoc);
266   InitializationSequence InitSeq(*this, Entity, Kind, Arg);
267   ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg);
268   if (Result.isInvalid())
269     return true;
270   Arg = Result.getAs<Expr>();
271 
272   CheckCompletedExpr(Arg, EqualLoc);
273   Arg = MaybeCreateExprWithCleanups(Arg);
274 
275   // Okay: add the default argument to the parameter
276   Param->setDefaultArg(Arg);
277 
278   // We have already instantiated this parameter; provide each of the
279   // instantiations with the uninstantiated default argument.
280   UnparsedDefaultArgInstantiationsMap::iterator InstPos
281     = UnparsedDefaultArgInstantiations.find(Param);
282   if (InstPos != UnparsedDefaultArgInstantiations.end()) {
283     for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
284       InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
285 
286     // We're done tracking this parameter's instantiations.
287     UnparsedDefaultArgInstantiations.erase(InstPos);
288   }
289 
290   return false;
291 }
292 
293 /// ActOnParamDefaultArgument - Check whether the default argument
294 /// provided for a function parameter is well-formed. If so, attach it
295 /// to the parameter declaration.
296 void
ActOnParamDefaultArgument(Decl * param,SourceLocation EqualLoc,Expr * DefaultArg)297 Sema::ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc,
298                                 Expr *DefaultArg) {
299   if (!param || !DefaultArg)
300     return;
301 
302   ParmVarDecl *Param = cast<ParmVarDecl>(param);
303   UnparsedDefaultArgLocs.erase(Param);
304 
305   // Default arguments are only permitted in C++
306   if (!getLangOpts().CPlusPlus) {
307     Diag(EqualLoc, diag::err_param_default_argument)
308       << DefaultArg->getSourceRange();
309     Param->setInvalidDecl();
310     return;
311   }
312 
313   // Check for unexpanded parameter packs.
314   if (DiagnoseUnexpandedParameterPack(DefaultArg, UPPC_DefaultArgument)) {
315     Param->setInvalidDecl();
316     return;
317   }
318 
319   // C++11 [dcl.fct.default]p3
320   //   A default argument expression [...] shall not be specified for a
321   //   parameter pack.
322   if (Param->isParameterPack()) {
323     Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
324         << DefaultArg->getSourceRange();
325     return;
326   }
327 
328   // Check that the default argument is well-formed
329   CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg, this);
330   if (DefaultArgChecker.Visit(DefaultArg)) {
331     Param->setInvalidDecl();
332     return;
333   }
334 
335   SetParamDefaultArgument(Param, DefaultArg, EqualLoc);
336 }
337 
338 /// ActOnParamUnparsedDefaultArgument - We've seen a default
339 /// argument for a function parameter, but we can't parse it yet
340 /// because we're inside a class definition. Note that this default
341 /// argument will be parsed later.
ActOnParamUnparsedDefaultArgument(Decl * param,SourceLocation EqualLoc,SourceLocation ArgLoc)342 void Sema::ActOnParamUnparsedDefaultArgument(Decl *param,
343                                              SourceLocation EqualLoc,
344                                              SourceLocation ArgLoc) {
345   if (!param)
346     return;
347 
348   ParmVarDecl *Param = cast<ParmVarDecl>(param);
349   Param->setUnparsedDefaultArg();
350   UnparsedDefaultArgLocs[Param] = ArgLoc;
351 }
352 
353 /// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
354 /// the default argument for the parameter param failed.
ActOnParamDefaultArgumentError(Decl * param,SourceLocation EqualLoc)355 void Sema::ActOnParamDefaultArgumentError(Decl *param,
356                                           SourceLocation EqualLoc) {
357   if (!param)
358     return;
359 
360   ParmVarDecl *Param = cast<ParmVarDecl>(param);
361   Param->setInvalidDecl();
362   UnparsedDefaultArgLocs.erase(Param);
363   Param->setDefaultArg(new(Context)
364                        OpaqueValueExpr(EqualLoc,
365                                        Param->getType().getNonReferenceType(),
366                                        VK_RValue));
367 }
368 
369 /// CheckExtraCXXDefaultArguments - Check for any extra default
370 /// arguments in the declarator, which is not a function declaration
371 /// or definition and therefore is not permitted to have default
372 /// arguments. This routine should be invoked for every declarator
373 /// that is not a function declaration or definition.
CheckExtraCXXDefaultArguments(Declarator & D)374 void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {
375   // C++ [dcl.fct.default]p3
376   //   A default argument expression shall be specified only in the
377   //   parameter-declaration-clause of a function declaration or in a
378   //   template-parameter (14.1). It shall not be specified for a
379   //   parameter pack. If it is specified in a
380   //   parameter-declaration-clause, it shall not occur within a
381   //   declarator or abstract-declarator of a parameter-declaration.
382   bool MightBeFunction = D.isFunctionDeclarationContext();
383   for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
384     DeclaratorChunk &chunk = D.getTypeObject(i);
385     if (chunk.Kind == DeclaratorChunk::Function) {
386       if (MightBeFunction) {
387         // This is a function declaration. It can have default arguments, but
388         // keep looking in case its return type is a function type with default
389         // arguments.
390         MightBeFunction = false;
391         continue;
392       }
393       for (unsigned argIdx = 0, e = chunk.Fun.NumParams; argIdx != e;
394            ++argIdx) {
395         ParmVarDecl *Param = cast<ParmVarDecl>(chunk.Fun.Params[argIdx].Param);
396         if (Param->hasUnparsedDefaultArg()) {
397           CachedTokens *Toks = chunk.Fun.Params[argIdx].DefaultArgTokens;
398           SourceRange SR;
399           if (Toks->size() > 1)
400             SR = SourceRange((*Toks)[1].getLocation(),
401                              Toks->back().getLocation());
402           else
403             SR = UnparsedDefaultArgLocs[Param];
404           Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
405             << SR;
406           delete Toks;
407           chunk.Fun.Params[argIdx].DefaultArgTokens = nullptr;
408         } else if (Param->getDefaultArg()) {
409           Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
410             << Param->getDefaultArg()->getSourceRange();
411           Param->setDefaultArg(nullptr);
412         }
413       }
414     } else if (chunk.Kind != DeclaratorChunk::Paren) {
415       MightBeFunction = false;
416     }
417   }
418 }
419 
functionDeclHasDefaultArgument(const FunctionDecl * FD)420 static bool functionDeclHasDefaultArgument(const FunctionDecl *FD) {
421   for (unsigned NumParams = FD->getNumParams(); NumParams > 0; --NumParams) {
422     const ParmVarDecl *PVD = FD->getParamDecl(NumParams-1);
423     if (!PVD->hasDefaultArg())
424       return false;
425     if (!PVD->hasInheritedDefaultArg())
426       return true;
427   }
428   return false;
429 }
430 
431 /// MergeCXXFunctionDecl - Merge two declarations of the same C++
432 /// function, once we already know that they have the same
433 /// type. Subroutine of MergeFunctionDecl. Returns true if there was an
434 /// error, false otherwise.
MergeCXXFunctionDecl(FunctionDecl * New,FunctionDecl * Old,Scope * S)435 bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old,
436                                 Scope *S) {
437   bool Invalid = false;
438 
439   // The declaration context corresponding to the scope is the semantic
440   // parent, unless this is a local function declaration, in which case
441   // it is that surrounding function.
442   DeclContext *ScopeDC = New->isLocalExternDecl()
443                              ? New->getLexicalDeclContext()
444                              : New->getDeclContext();
445 
446   // Find the previous declaration for the purpose of default arguments.
447   FunctionDecl *PrevForDefaultArgs = Old;
448   for (/**/; PrevForDefaultArgs;
449        // Don't bother looking back past the latest decl if this is a local
450        // extern declaration; nothing else could work.
451        PrevForDefaultArgs = New->isLocalExternDecl()
452                                 ? nullptr
453                                 : PrevForDefaultArgs->getPreviousDecl()) {
454     // Ignore hidden declarations.
455     if (!LookupResult::isVisible(*this, PrevForDefaultArgs))
456       continue;
457 
458     if (S && !isDeclInScope(PrevForDefaultArgs, ScopeDC, S) &&
459         !New->isCXXClassMember()) {
460       // Ignore default arguments of old decl if they are not in
461       // the same scope and this is not an out-of-line definition of
462       // a member function.
463       continue;
464     }
465 
466     if (PrevForDefaultArgs->isLocalExternDecl() != New->isLocalExternDecl()) {
467       // If only one of these is a local function declaration, then they are
468       // declared in different scopes, even though isDeclInScope may think
469       // they're in the same scope. (If both are local, the scope check is
470       // sufficent, and if neither is local, then they are in the same scope.)
471       continue;
472     }
473 
474     // We found the right previous declaration.
475     break;
476   }
477 
478   // C++ [dcl.fct.default]p4:
479   //   For non-template functions, default arguments can be added in
480   //   later declarations of a function in the same
481   //   scope. Declarations in different scopes have completely
482   //   distinct sets of default arguments. That is, declarations in
483   //   inner scopes do not acquire default arguments from
484   //   declarations in outer scopes, and vice versa. In a given
485   //   function declaration, all parameters subsequent to a
486   //   parameter with a default argument shall have default
487   //   arguments supplied in this or previous declarations. A
488   //   default argument shall not be redefined by a later
489   //   declaration (not even to the same value).
490   //
491   // C++ [dcl.fct.default]p6:
492   //   Except for member functions of class templates, the default arguments
493   //   in a member function definition that appears outside of the class
494   //   definition are added to the set of default arguments provided by the
495   //   member function declaration in the class definition.
496   for (unsigned p = 0, NumParams = PrevForDefaultArgs
497                                        ? PrevForDefaultArgs->getNumParams()
498                                        : 0;
499        p < NumParams; ++p) {
500     ParmVarDecl *OldParam = PrevForDefaultArgs->getParamDecl(p);
501     ParmVarDecl *NewParam = New->getParamDecl(p);
502 
503     bool OldParamHasDfl = OldParam ? OldParam->hasDefaultArg() : false;
504     bool NewParamHasDfl = NewParam->hasDefaultArg();
505 
506     if (OldParamHasDfl && NewParamHasDfl) {
507       unsigned DiagDefaultParamID =
508         diag::err_param_default_argument_redefinition;
509 
510       // MSVC accepts that default parameters be redefined for member functions
511       // of template class. The new default parameter's value is ignored.
512       Invalid = true;
513       if (getLangOpts().MicrosoftExt) {
514         CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(New);
515         if (MD && MD->getParent()->getDescribedClassTemplate()) {
516           // Merge the old default argument into the new parameter.
517           NewParam->setHasInheritedDefaultArg();
518           if (OldParam->hasUninstantiatedDefaultArg())
519             NewParam->setUninstantiatedDefaultArg(
520                                       OldParam->getUninstantiatedDefaultArg());
521           else
522             NewParam->setDefaultArg(OldParam->getInit());
523           DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
524           Invalid = false;
525         }
526       }
527 
528       // FIXME: If we knew where the '=' was, we could easily provide a fix-it
529       // hint here. Alternatively, we could walk the type-source information
530       // for NewParam to find the last source location in the type... but it
531       // isn't worth the effort right now. This is the kind of test case that
532       // is hard to get right:
533       //   int f(int);
534       //   void g(int (*fp)(int) = f);
535       //   void g(int (*fp)(int) = &f);
536       Diag(NewParam->getLocation(), DiagDefaultParamID)
537         << NewParam->getDefaultArgRange();
538 
539       // Look for the function declaration where the default argument was
540       // actually written, which may be a declaration prior to Old.
541       for (auto Older = PrevForDefaultArgs;
542            OldParam->hasInheritedDefaultArg(); /**/) {
543         Older = Older->getPreviousDecl();
544         OldParam = Older->getParamDecl(p);
545       }
546 
547       Diag(OldParam->getLocation(), diag::note_previous_definition)
548         << OldParam->getDefaultArgRange();
549     } else if (OldParamHasDfl) {
550       // Merge the old default argument into the new parameter.
551       // It's important to use getInit() here;  getDefaultArg()
552       // strips off any top-level ExprWithCleanups.
553       NewParam->setHasInheritedDefaultArg();
554       if (OldParam->hasUnparsedDefaultArg())
555         NewParam->setUnparsedDefaultArg();
556       else if (OldParam->hasUninstantiatedDefaultArg())
557         NewParam->setUninstantiatedDefaultArg(
558                                       OldParam->getUninstantiatedDefaultArg());
559       else
560         NewParam->setDefaultArg(OldParam->getInit());
561     } else if (NewParamHasDfl) {
562       if (New->getDescribedFunctionTemplate()) {
563         // Paragraph 4, quoted above, only applies to non-template functions.
564         Diag(NewParam->getLocation(),
565              diag::err_param_default_argument_template_redecl)
566           << NewParam->getDefaultArgRange();
567         Diag(PrevForDefaultArgs->getLocation(),
568              diag::note_template_prev_declaration)
569             << false;
570       } else if (New->getTemplateSpecializationKind()
571                    != TSK_ImplicitInstantiation &&
572                  New->getTemplateSpecializationKind() != TSK_Undeclared) {
573         // C++ [temp.expr.spec]p21:
574         //   Default function arguments shall not be specified in a declaration
575         //   or a definition for one of the following explicit specializations:
576         //     - the explicit specialization of a function template;
577         //     - the explicit specialization of a member function template;
578         //     - the explicit specialization of a member function of a class
579         //       template where the class template specialization to which the
580         //       member function specialization belongs is implicitly
581         //       instantiated.
582         Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
583           << (New->getTemplateSpecializationKind() ==TSK_ExplicitSpecialization)
584           << New->getDeclName()
585           << NewParam->getDefaultArgRange();
586       } else if (New->getDeclContext()->isDependentContext()) {
587         // C++ [dcl.fct.default]p6 (DR217):
588         //   Default arguments for a member function of a class template shall
589         //   be specified on the initial declaration of the member function
590         //   within the class template.
591         //
592         // Reading the tea leaves a bit in DR217 and its reference to DR205
593         // leads me to the conclusion that one cannot add default function
594         // arguments for an out-of-line definition of a member function of a
595         // dependent type.
596         int WhichKind = 2;
597         if (CXXRecordDecl *Record
598               = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
599           if (Record->getDescribedClassTemplate())
600             WhichKind = 0;
601           else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
602             WhichKind = 1;
603           else
604             WhichKind = 2;
605         }
606 
607         Diag(NewParam->getLocation(),
608              diag::err_param_default_argument_member_template_redecl)
609           << WhichKind
610           << NewParam->getDefaultArgRange();
611       }
612     }
613   }
614 
615   // DR1344: If a default argument is added outside a class definition and that
616   // default argument makes the function a special member function, the program
617   // is ill-formed. This can only happen for constructors.
618   if (isa<CXXConstructorDecl>(New) &&
619       New->getMinRequiredArguments() < Old->getMinRequiredArguments()) {
620     CXXSpecialMember NewSM = getSpecialMember(cast<CXXMethodDecl>(New)),
621                      OldSM = getSpecialMember(cast<CXXMethodDecl>(Old));
622     if (NewSM != OldSM) {
623       ParmVarDecl *NewParam = New->getParamDecl(New->getMinRequiredArguments());
624       assert(NewParam->hasDefaultArg());
625       Diag(NewParam->getLocation(), diag::err_default_arg_makes_ctor_special)
626         << NewParam->getDefaultArgRange() << NewSM;
627       Diag(Old->getLocation(), diag::note_previous_declaration);
628     }
629   }
630 
631   const FunctionDecl *Def;
632   // C++11 [dcl.constexpr]p1: If any declaration of a function or function
633   // template has a constexpr specifier then all its declarations shall
634   // contain the constexpr specifier.
635   if (New->isConstexpr() != Old->isConstexpr()) {
636     Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
637       << New << New->isConstexpr();
638     Diag(Old->getLocation(), diag::note_previous_declaration);
639     Invalid = true;
640   } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
641              Old->isDefined(Def)) {
642     // C++11 [dcl.fcn.spec]p4:
643     //   If the definition of a function appears in a translation unit before its
644     //   first declaration as inline, the program is ill-formed.
645     Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
646     Diag(Def->getLocation(), diag::note_previous_definition);
647     Invalid = true;
648   }
649 
650   // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
651   // argument expression, that declaration shall be a definition and shall be
652   // the only declaration of the function or function template in the
653   // translation unit.
654   if (Old->getFriendObjectKind() == Decl::FOK_Undeclared &&
655       functionDeclHasDefaultArgument(Old)) {
656     Diag(New->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
657     Diag(Old->getLocation(), diag::note_previous_declaration);
658     Invalid = true;
659   }
660 
661   if (CheckEquivalentExceptionSpec(Old, New))
662     Invalid = true;
663 
664   return Invalid;
665 }
666 
667 /// \brief Merge the exception specifications of two variable declarations.
668 ///
669 /// This is called when there's a redeclaration of a VarDecl. The function
670 /// checks if the redeclaration might have an exception specification and
671 /// validates compatibility and merges the specs if necessary.
MergeVarDeclExceptionSpecs(VarDecl * New,VarDecl * Old)672 void Sema::MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old) {
673   // Shortcut if exceptions are disabled.
674   if (!getLangOpts().CXXExceptions)
675     return;
676 
677   assert(Context.hasSameType(New->getType(), Old->getType()) &&
678          "Should only be called if types are otherwise the same.");
679 
680   QualType NewType = New->getType();
681   QualType OldType = Old->getType();
682 
683   // We're only interested in pointers and references to functions, as well
684   // as pointers to member functions.
685   if (const ReferenceType *R = NewType->getAs<ReferenceType>()) {
686     NewType = R->getPointeeType();
687     OldType = OldType->getAs<ReferenceType>()->getPointeeType();
688   } else if (const PointerType *P = NewType->getAs<PointerType>()) {
689     NewType = P->getPointeeType();
690     OldType = OldType->getAs<PointerType>()->getPointeeType();
691   } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) {
692     NewType = M->getPointeeType();
693     OldType = OldType->getAs<MemberPointerType>()->getPointeeType();
694   }
695 
696   if (!NewType->isFunctionProtoType())
697     return;
698 
699   // There's lots of special cases for functions. For function pointers, system
700   // libraries are hopefully not as broken so that we don't need these
701   // workarounds.
702   if (CheckEquivalentExceptionSpec(
703         OldType->getAs<FunctionProtoType>(), Old->getLocation(),
704         NewType->getAs<FunctionProtoType>(), New->getLocation())) {
705     New->setInvalidDecl();
706   }
707 }
708 
709 /// CheckCXXDefaultArguments - Verify that the default arguments for a
710 /// function declaration are well-formed according to C++
711 /// [dcl.fct.default].
CheckCXXDefaultArguments(FunctionDecl * FD)712 void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
713   unsigned NumParams = FD->getNumParams();
714   unsigned p;
715 
716   // Find first parameter with a default argument
717   for (p = 0; p < NumParams; ++p) {
718     ParmVarDecl *Param = FD->getParamDecl(p);
719     if (Param->hasDefaultArg())
720       break;
721   }
722 
723   // C++11 [dcl.fct.default]p4:
724   //   In a given function declaration, each parameter subsequent to a parameter
725   //   with a default argument shall have a default argument supplied in this or
726   //   a previous declaration or shall be a function parameter pack. A default
727   //   argument shall not be redefined by a later declaration (not even to the
728   //   same value).
729   unsigned LastMissingDefaultArg = 0;
730   for (; p < NumParams; ++p) {
731     ParmVarDecl *Param = FD->getParamDecl(p);
732     if (!Param->hasDefaultArg() && !Param->isParameterPack()) {
733       if (Param->isInvalidDecl())
734         /* We already complained about this parameter. */;
735       else if (Param->getIdentifier())
736         Diag(Param->getLocation(),
737              diag::err_param_default_argument_missing_name)
738           << Param->getIdentifier();
739       else
740         Diag(Param->getLocation(),
741              diag::err_param_default_argument_missing);
742 
743       LastMissingDefaultArg = p;
744     }
745   }
746 
747   if (LastMissingDefaultArg > 0) {
748     // Some default arguments were missing. Clear out all of the
749     // default arguments up to (and including) the last missing
750     // default argument, so that we leave the function parameters
751     // in a semantically valid state.
752     for (p = 0; p <= LastMissingDefaultArg; ++p) {
753       ParmVarDecl *Param = FD->getParamDecl(p);
754       if (Param->hasDefaultArg()) {
755         Param->setDefaultArg(nullptr);
756       }
757     }
758   }
759 }
760 
761 // CheckConstexprParameterTypes - Check whether a function's parameter types
762 // are all literal types. If so, return true. If not, produce a suitable
763 // diagnostic and return false.
CheckConstexprParameterTypes(Sema & SemaRef,const FunctionDecl * FD)764 static bool CheckConstexprParameterTypes(Sema &SemaRef,
765                                          const FunctionDecl *FD) {
766   unsigned ArgIndex = 0;
767   const FunctionProtoType *FT = FD->getType()->getAs<FunctionProtoType>();
768   for (FunctionProtoType::param_type_iterator i = FT->param_type_begin(),
769                                               e = FT->param_type_end();
770        i != e; ++i, ++ArgIndex) {
771     const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
772     SourceLocation ParamLoc = PD->getLocation();
773     if (!(*i)->isDependentType() &&
774         SemaRef.RequireLiteralType(ParamLoc, *i,
775                                    diag::err_constexpr_non_literal_param,
776                                    ArgIndex+1, PD->getSourceRange(),
777                                    isa<CXXConstructorDecl>(FD)))
778       return false;
779   }
780   return true;
781 }
782 
783 /// \brief Get diagnostic %select index for tag kind for
784 /// record diagnostic message.
785 /// WARNING: Indexes apply to particular diagnostics only!
786 ///
787 /// \returns diagnostic %select index.
getRecordDiagFromTagKind(TagTypeKind Tag)788 static unsigned getRecordDiagFromTagKind(TagTypeKind Tag) {
789   switch (Tag) {
790   case TTK_Struct: return 0;
791   case TTK_Interface: return 1;
792   case TTK_Class:  return 2;
793   default: llvm_unreachable("Invalid tag kind for record diagnostic!");
794   }
795 }
796 
797 // CheckConstexprFunctionDecl - Check whether a function declaration satisfies
798 // the requirements of a constexpr function definition or a constexpr
799 // constructor definition. If so, return true. If not, produce appropriate
800 // diagnostics and return false.
801 //
802 // This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360.
CheckConstexprFunctionDecl(const FunctionDecl * NewFD)803 bool Sema::CheckConstexprFunctionDecl(const FunctionDecl *NewFD) {
804   const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
805   if (MD && MD->isInstance()) {
806     // C++11 [dcl.constexpr]p4:
807     //  The definition of a constexpr constructor shall satisfy the following
808     //  constraints:
809     //  - the class shall not have any virtual base classes;
810     const CXXRecordDecl *RD = MD->getParent();
811     if (RD->getNumVBases()) {
812       Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base)
813         << isa<CXXConstructorDecl>(NewFD)
814         << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getNumVBases();
815       for (const auto &I : RD->vbases())
816         Diag(I.getLocStart(),
817              diag::note_constexpr_virtual_base_here) << I.getSourceRange();
818       return false;
819     }
820   }
821 
822   if (!isa<CXXConstructorDecl>(NewFD)) {
823     // C++11 [dcl.constexpr]p3:
824     //  The definition of a constexpr function shall satisfy the following
825     //  constraints:
826     // - it shall not be virtual;
827     const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
828     if (Method && Method->isVirtual()) {
829       Method = Method->getCanonicalDecl();
830       Diag(Method->getLocation(), diag::err_constexpr_virtual);
831 
832       // If it's not obvious why this function is virtual, find an overridden
833       // function which uses the 'virtual' keyword.
834       const CXXMethodDecl *WrittenVirtual = Method;
835       while (!WrittenVirtual->isVirtualAsWritten())
836         WrittenVirtual = *WrittenVirtual->begin_overridden_methods();
837       if (WrittenVirtual != Method)
838         Diag(WrittenVirtual->getLocation(),
839              diag::note_overridden_virtual_function);
840       return false;
841     }
842 
843     // - its return type shall be a literal type;
844     QualType RT = NewFD->getReturnType();
845     if (!RT->isDependentType() &&
846         RequireLiteralType(NewFD->getLocation(), RT,
847                            diag::err_constexpr_non_literal_return))
848       return false;
849   }
850 
851   // - each of its parameter types shall be a literal type;
852   if (!CheckConstexprParameterTypes(*this, NewFD))
853     return false;
854 
855   return true;
856 }
857 
858 /// Check the given declaration statement is legal within a constexpr function
859 /// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.
860 ///
861 /// \return true if the body is OK (maybe only as an extension), false if we
862 ///         have diagnosed a problem.
CheckConstexprDeclStmt(Sema & SemaRef,const FunctionDecl * Dcl,DeclStmt * DS,SourceLocation & Cxx1yLoc)863 static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
864                                    DeclStmt *DS, SourceLocation &Cxx1yLoc) {
865   // C++11 [dcl.constexpr]p3 and p4:
866   //  The definition of a constexpr function(p3) or constructor(p4) [...] shall
867   //  contain only
868   for (const auto *DclIt : DS->decls()) {
869     switch (DclIt->getKind()) {
870     case Decl::StaticAssert:
871     case Decl::Using:
872     case Decl::UsingShadow:
873     case Decl::UsingDirective:
874     case Decl::UnresolvedUsingTypename:
875     case Decl::UnresolvedUsingValue:
876       //   - static_assert-declarations
877       //   - using-declarations,
878       //   - using-directives,
879       continue;
880 
881     case Decl::Typedef:
882     case Decl::TypeAlias: {
883       //   - typedef declarations and alias-declarations that do not define
884       //     classes or enumerations,
885       const auto *TN = cast<TypedefNameDecl>(DclIt);
886       if (TN->getUnderlyingType()->isVariablyModifiedType()) {
887         // Don't allow variably-modified types in constexpr functions.
888         TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
889         SemaRef.Diag(TL.getBeginLoc(), diag::err_constexpr_vla)
890           << TL.getSourceRange() << TL.getType()
891           << isa<CXXConstructorDecl>(Dcl);
892         return false;
893       }
894       continue;
895     }
896 
897     case Decl::Enum:
898     case Decl::CXXRecord:
899       // C++1y allows types to be defined, not just declared.
900       if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition())
901         SemaRef.Diag(DS->getLocStart(),
902                      SemaRef.getLangOpts().CPlusPlus14
903                        ? diag::warn_cxx11_compat_constexpr_type_definition
904                        : diag::ext_constexpr_type_definition)
905           << isa<CXXConstructorDecl>(Dcl);
906       continue;
907 
908     case Decl::EnumConstant:
909     case Decl::IndirectField:
910     case Decl::ParmVar:
911       // These can only appear with other declarations which are banned in
912       // C++11 and permitted in C++1y, so ignore them.
913       continue;
914 
915     case Decl::Var: {
916       // C++1y [dcl.constexpr]p3 allows anything except:
917       //   a definition of a variable of non-literal type or of static or
918       //   thread storage duration or for which no initialization is performed.
919       const auto *VD = cast<VarDecl>(DclIt);
920       if (VD->isThisDeclarationADefinition()) {
921         if (VD->isStaticLocal()) {
922           SemaRef.Diag(VD->getLocation(),
923                        diag::err_constexpr_local_var_static)
924             << isa<CXXConstructorDecl>(Dcl)
925             << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
926           return false;
927         }
928         if (!VD->getType()->isDependentType() &&
929             SemaRef.RequireLiteralType(
930               VD->getLocation(), VD->getType(),
931               diag::err_constexpr_local_var_non_literal_type,
932               isa<CXXConstructorDecl>(Dcl)))
933           return false;
934         if (!VD->getType()->isDependentType() &&
935             !VD->hasInit() && !VD->isCXXForRangeDecl()) {
936           SemaRef.Diag(VD->getLocation(),
937                        diag::err_constexpr_local_var_no_init)
938             << isa<CXXConstructorDecl>(Dcl);
939           return false;
940         }
941       }
942       SemaRef.Diag(VD->getLocation(),
943                    SemaRef.getLangOpts().CPlusPlus14
944                     ? diag::warn_cxx11_compat_constexpr_local_var
945                     : diag::ext_constexpr_local_var)
946         << isa<CXXConstructorDecl>(Dcl);
947       continue;
948     }
949 
950     case Decl::NamespaceAlias:
951     case Decl::Function:
952       // These are disallowed in C++11 and permitted in C++1y. Allow them
953       // everywhere as an extension.
954       if (!Cxx1yLoc.isValid())
955         Cxx1yLoc = DS->getLocStart();
956       continue;
957 
958     default:
959       SemaRef.Diag(DS->getLocStart(), diag::err_constexpr_body_invalid_stmt)
960         << isa<CXXConstructorDecl>(Dcl);
961       return false;
962     }
963   }
964 
965   return true;
966 }
967 
968 /// Check that the given field is initialized within a constexpr constructor.
969 ///
970 /// \param Dcl The constexpr constructor being checked.
971 /// \param Field The field being checked. This may be a member of an anonymous
972 ///        struct or union nested within the class being checked.
973 /// \param Inits All declarations, including anonymous struct/union members and
974 ///        indirect members, for which any initialization was provided.
975 /// \param Diagnosed Set to true if an error is produced.
CheckConstexprCtorInitializer(Sema & SemaRef,const FunctionDecl * Dcl,FieldDecl * Field,llvm::SmallSet<Decl *,16> & Inits,bool & Diagnosed)976 static void CheckConstexprCtorInitializer(Sema &SemaRef,
977                                           const FunctionDecl *Dcl,
978                                           FieldDecl *Field,
979                                           llvm::SmallSet<Decl*, 16> &Inits,
980                                           bool &Diagnosed) {
981   if (Field->isInvalidDecl())
982     return;
983 
984   if (Field->isUnnamedBitfield())
985     return;
986 
987   // Anonymous unions with no variant members and empty anonymous structs do not
988   // need to be explicitly initialized. FIXME: Anonymous structs that contain no
989   // indirect fields don't need initializing.
990   if (Field->isAnonymousStructOrUnion() &&
991       (Field->getType()->isUnionType()
992            ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
993            : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
994     return;
995 
996   if (!Inits.count(Field)) {
997     if (!Diagnosed) {
998       SemaRef.Diag(Dcl->getLocation(), diag::err_constexpr_ctor_missing_init);
999       Diagnosed = true;
1000     }
1001     SemaRef.Diag(Field->getLocation(), diag::note_constexpr_ctor_missing_init);
1002   } else if (Field->isAnonymousStructOrUnion()) {
1003     const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
1004     for (auto *I : RD->fields())
1005       // If an anonymous union contains an anonymous struct of which any member
1006       // is initialized, all members must be initialized.
1007       if (!RD->isUnion() || Inits.count(I))
1008         CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed);
1009   }
1010 }
1011 
1012 /// Check the provided statement is allowed in a constexpr function
1013 /// definition.
1014 static bool
CheckConstexprFunctionStmt(Sema & SemaRef,const FunctionDecl * Dcl,Stmt * S,SmallVectorImpl<SourceLocation> & ReturnStmts,SourceLocation & Cxx1yLoc)1015 CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S,
1016                            SmallVectorImpl<SourceLocation> &ReturnStmts,
1017                            SourceLocation &Cxx1yLoc) {
1018   // - its function-body shall be [...] a compound-statement that contains only
1019   switch (S->getStmtClass()) {
1020   case Stmt::NullStmtClass:
1021     //   - null statements,
1022     return true;
1023 
1024   case Stmt::DeclStmtClass:
1025     //   - static_assert-declarations
1026     //   - using-declarations,
1027     //   - using-directives,
1028     //   - typedef declarations and alias-declarations that do not define
1029     //     classes or enumerations,
1030     if (!CheckConstexprDeclStmt(SemaRef, Dcl, cast<DeclStmt>(S), Cxx1yLoc))
1031       return false;
1032     return true;
1033 
1034   case Stmt::ReturnStmtClass:
1035     //   - and exactly one return statement;
1036     if (isa<CXXConstructorDecl>(Dcl)) {
1037       // C++1y allows return statements in constexpr constructors.
1038       if (!Cxx1yLoc.isValid())
1039         Cxx1yLoc = S->getLocStart();
1040       return true;
1041     }
1042 
1043     ReturnStmts.push_back(S->getLocStart());
1044     return true;
1045 
1046   case Stmt::CompoundStmtClass: {
1047     // C++1y allows compound-statements.
1048     if (!Cxx1yLoc.isValid())
1049       Cxx1yLoc = S->getLocStart();
1050 
1051     CompoundStmt *CompStmt = cast<CompoundStmt>(S);
1052     for (auto *BodyIt : CompStmt->body()) {
1053       if (!CheckConstexprFunctionStmt(SemaRef, Dcl, BodyIt, ReturnStmts,
1054                                       Cxx1yLoc))
1055         return false;
1056     }
1057     return true;
1058   }
1059 
1060   case Stmt::AttributedStmtClass:
1061     if (!Cxx1yLoc.isValid())
1062       Cxx1yLoc = S->getLocStart();
1063     return true;
1064 
1065   case Stmt::IfStmtClass: {
1066     // C++1y allows if-statements.
1067     if (!Cxx1yLoc.isValid())
1068       Cxx1yLoc = S->getLocStart();
1069 
1070     IfStmt *If = cast<IfStmt>(S);
1071     if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
1072                                     Cxx1yLoc))
1073       return false;
1074     if (If->getElse() &&
1075         !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
1076                                     Cxx1yLoc))
1077       return false;
1078     return true;
1079   }
1080 
1081   case Stmt::WhileStmtClass:
1082   case Stmt::DoStmtClass:
1083   case Stmt::ForStmtClass:
1084   case Stmt::CXXForRangeStmtClass:
1085   case Stmt::ContinueStmtClass:
1086     // C++1y allows all of these. We don't allow them as extensions in C++11,
1087     // because they don't make sense without variable mutation.
1088     if (!SemaRef.getLangOpts().CPlusPlus14)
1089       break;
1090     if (!Cxx1yLoc.isValid())
1091       Cxx1yLoc = S->getLocStart();
1092     for (Stmt *SubStmt : S->children())
1093       if (SubStmt &&
1094           !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
1095                                       Cxx1yLoc))
1096         return false;
1097     return true;
1098 
1099   case Stmt::SwitchStmtClass:
1100   case Stmt::CaseStmtClass:
1101   case Stmt::DefaultStmtClass:
1102   case Stmt::BreakStmtClass:
1103     // C++1y allows switch-statements, and since they don't need variable
1104     // mutation, we can reasonably allow them in C++11 as an extension.
1105     if (!Cxx1yLoc.isValid())
1106       Cxx1yLoc = S->getLocStart();
1107     for (Stmt *SubStmt : S->children())
1108       if (SubStmt &&
1109           !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
1110                                       Cxx1yLoc))
1111         return false;
1112     return true;
1113 
1114   default:
1115     if (!isa<Expr>(S))
1116       break;
1117 
1118     // C++1y allows expression-statements.
1119     if (!Cxx1yLoc.isValid())
1120       Cxx1yLoc = S->getLocStart();
1121     return true;
1122   }
1123 
1124   SemaRef.Diag(S->getLocStart(), diag::err_constexpr_body_invalid_stmt)
1125     << isa<CXXConstructorDecl>(Dcl);
1126   return false;
1127 }
1128 
1129 /// Check the body for the given constexpr function declaration only contains
1130 /// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.
1131 ///
1132 /// \return true if the body is OK, false if we have diagnosed a problem.
CheckConstexprFunctionBody(const FunctionDecl * Dcl,Stmt * Body)1133 bool Sema::CheckConstexprFunctionBody(const FunctionDecl *Dcl, Stmt *Body) {
1134   if (isa<CXXTryStmt>(Body)) {
1135     // C++11 [dcl.constexpr]p3:
1136     //  The definition of a constexpr function shall satisfy the following
1137     //  constraints: [...]
1138     // - its function-body shall be = delete, = default, or a
1139     //   compound-statement
1140     //
1141     // C++11 [dcl.constexpr]p4:
1142     //  In the definition of a constexpr constructor, [...]
1143     // - its function-body shall not be a function-try-block;
1144     Diag(Body->getLocStart(), diag::err_constexpr_function_try_block)
1145       << isa<CXXConstructorDecl>(Dcl);
1146     return false;
1147   }
1148 
1149   SmallVector<SourceLocation, 4> ReturnStmts;
1150 
1151   // - its function-body shall be [...] a compound-statement that contains only
1152   //   [... list of cases ...]
1153   CompoundStmt *CompBody = cast<CompoundStmt>(Body);
1154   SourceLocation Cxx1yLoc;
1155   for (auto *BodyIt : CompBody->body()) {
1156     if (!CheckConstexprFunctionStmt(*this, Dcl, BodyIt, ReturnStmts, Cxx1yLoc))
1157       return false;
1158   }
1159 
1160   if (Cxx1yLoc.isValid())
1161     Diag(Cxx1yLoc,
1162          getLangOpts().CPlusPlus14
1163            ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
1164            : diag::ext_constexpr_body_invalid_stmt)
1165       << isa<CXXConstructorDecl>(Dcl);
1166 
1167   if (const CXXConstructorDecl *Constructor
1168         = dyn_cast<CXXConstructorDecl>(Dcl)) {
1169     const CXXRecordDecl *RD = Constructor->getParent();
1170     // DR1359:
1171     // - every non-variant non-static data member and base class sub-object
1172     //   shall be initialized;
1173     // DR1460:
1174     // - if the class is a union having variant members, exactly one of them
1175     //   shall be initialized;
1176     if (RD->isUnion()) {
1177       if (Constructor->getNumCtorInitializers() == 0 &&
1178           RD->hasVariantMembers()) {
1179         Diag(Dcl->getLocation(), diag::err_constexpr_union_ctor_no_init);
1180         return false;
1181       }
1182     } else if (!Constructor->isDependentContext() &&
1183                !Constructor->isDelegatingConstructor()) {
1184       assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases");
1185 
1186       // Skip detailed checking if we have enough initializers, and we would
1187       // allow at most one initializer per member.
1188       bool AnyAnonStructUnionMembers = false;
1189       unsigned Fields = 0;
1190       for (CXXRecordDecl::field_iterator I = RD->field_begin(),
1191            E = RD->field_end(); I != E; ++I, ++Fields) {
1192         if (I->isAnonymousStructOrUnion()) {
1193           AnyAnonStructUnionMembers = true;
1194           break;
1195         }
1196       }
1197       // DR1460:
1198       // - if the class is a union-like class, but is not a union, for each of
1199       //   its anonymous union members having variant members, exactly one of
1200       //   them shall be initialized;
1201       if (AnyAnonStructUnionMembers ||
1202           Constructor->getNumCtorInitializers() != RD->getNumBases() + Fields) {
1203         // Check initialization of non-static data members. Base classes are
1204         // always initialized so do not need to be checked. Dependent bases
1205         // might not have initializers in the member initializer list.
1206         llvm::SmallSet<Decl*, 16> Inits;
1207         for (const auto *I: Constructor->inits()) {
1208           if (FieldDecl *FD = I->getMember())
1209             Inits.insert(FD);
1210           else if (IndirectFieldDecl *ID = I->getIndirectMember())
1211             Inits.insert(ID->chain_begin(), ID->chain_end());
1212         }
1213 
1214         bool Diagnosed = false;
1215         for (auto *I : RD->fields())
1216           CheckConstexprCtorInitializer(*this, Dcl, I, Inits, Diagnosed);
1217         if (Diagnosed)
1218           return false;
1219       }
1220     }
1221   } else {
1222     if (ReturnStmts.empty()) {
1223       // C++1y doesn't require constexpr functions to contain a 'return'
1224       // statement. We still do, unless the return type might be void, because
1225       // otherwise if there's no return statement, the function cannot
1226       // be used in a core constant expression.
1227       bool OK = getLangOpts().CPlusPlus14 &&
1228                 (Dcl->getReturnType()->isVoidType() ||
1229                  Dcl->getReturnType()->isDependentType());
1230       Diag(Dcl->getLocation(),
1231            OK ? diag::warn_cxx11_compat_constexpr_body_no_return
1232               : diag::err_constexpr_body_no_return);
1233       if (!OK)
1234         return false;
1235     } else if (ReturnStmts.size() > 1) {
1236       Diag(ReturnStmts.back(),
1237            getLangOpts().CPlusPlus14
1238              ? diag::warn_cxx11_compat_constexpr_body_multiple_return
1239              : diag::ext_constexpr_body_multiple_return);
1240       for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
1241         Diag(ReturnStmts[I], diag::note_constexpr_body_previous_return);
1242     }
1243   }
1244 
1245   // C++11 [dcl.constexpr]p5:
1246   //   if no function argument values exist such that the function invocation
1247   //   substitution would produce a constant expression, the program is
1248   //   ill-formed; no diagnostic required.
1249   // C++11 [dcl.constexpr]p3:
1250   //   - every constructor call and implicit conversion used in initializing the
1251   //     return value shall be one of those allowed in a constant expression.
1252   // C++11 [dcl.constexpr]p4:
1253   //   - every constructor involved in initializing non-static data members and
1254   //     base class sub-objects shall be a constexpr constructor.
1255   SmallVector<PartialDiagnosticAt, 8> Diags;
1256   if (!Expr::isPotentialConstantExpr(Dcl, Diags)) {
1257     Diag(Dcl->getLocation(), diag::ext_constexpr_function_never_constant_expr)
1258       << isa<CXXConstructorDecl>(Dcl);
1259     for (size_t I = 0, N = Diags.size(); I != N; ++I)
1260       Diag(Diags[I].first, Diags[I].second);
1261     // Don't return false here: we allow this for compatibility in
1262     // system headers.
1263   }
1264 
1265   return true;
1266 }
1267 
1268 /// isCurrentClassName - Determine whether the identifier II is the
1269 /// name of the class type currently being defined. In the case of
1270 /// nested classes, this will only return true if II is the name of
1271 /// the innermost class.
isCurrentClassName(const IdentifierInfo & II,Scope *,const CXXScopeSpec * SS)1272 bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
1273                               const CXXScopeSpec *SS) {
1274   assert(getLangOpts().CPlusPlus && "No class names in C!");
1275 
1276   CXXRecordDecl *CurDecl;
1277   if (SS && SS->isSet() && !SS->isInvalid()) {
1278     DeclContext *DC = computeDeclContext(*SS, true);
1279     CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
1280   } else
1281     CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
1282 
1283   if (CurDecl && CurDecl->getIdentifier())
1284     return &II == CurDecl->getIdentifier();
1285   return false;
1286 }
1287 
1288 /// \brief Determine whether the identifier II is a typo for the name of
1289 /// the class type currently being defined. If so, update it to the identifier
1290 /// that should have been used.
isCurrentClassNameTypo(IdentifierInfo * & II,const CXXScopeSpec * SS)1291 bool Sema::isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS) {
1292   assert(getLangOpts().CPlusPlus && "No class names in C!");
1293 
1294   if (!getLangOpts().SpellChecking)
1295     return false;
1296 
1297   CXXRecordDecl *CurDecl;
1298   if (SS && SS->isSet() && !SS->isInvalid()) {
1299     DeclContext *DC = computeDeclContext(*SS, true);
1300     CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
1301   } else
1302     CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
1303 
1304   if (CurDecl && CurDecl->getIdentifier() && II != CurDecl->getIdentifier() &&
1305       3 * II->getName().edit_distance(CurDecl->getIdentifier()->getName())
1306           < II->getLength()) {
1307     II = CurDecl->getIdentifier();
1308     return true;
1309   }
1310 
1311   return false;
1312 }
1313 
1314 /// \brief Determine whether the given class is a base class of the given
1315 /// class, including looking at dependent bases.
findCircularInheritance(const CXXRecordDecl * Class,const CXXRecordDecl * Current)1316 static bool findCircularInheritance(const CXXRecordDecl *Class,
1317                                     const CXXRecordDecl *Current) {
1318   SmallVector<const CXXRecordDecl*, 8> Queue;
1319 
1320   Class = Class->getCanonicalDecl();
1321   while (true) {
1322     for (const auto &I : Current->bases()) {
1323       CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl();
1324       if (!Base)
1325         continue;
1326 
1327       Base = Base->getDefinition();
1328       if (!Base)
1329         continue;
1330 
1331       if (Base->getCanonicalDecl() == Class)
1332         return true;
1333 
1334       Queue.push_back(Base);
1335     }
1336 
1337     if (Queue.empty())
1338       return false;
1339 
1340     Current = Queue.pop_back_val();
1341   }
1342 
1343   return false;
1344 }
1345 
1346 /// \brief Check the validity of a C++ base class specifier.
1347 ///
1348 /// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
1349 /// and returns NULL otherwise.
1350 CXXBaseSpecifier *
CheckBaseSpecifier(CXXRecordDecl * Class,SourceRange SpecifierRange,bool Virtual,AccessSpecifier Access,TypeSourceInfo * TInfo,SourceLocation EllipsisLoc)1351 Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
1352                          SourceRange SpecifierRange,
1353                          bool Virtual, AccessSpecifier Access,
1354                          TypeSourceInfo *TInfo,
1355                          SourceLocation EllipsisLoc) {
1356   QualType BaseType = TInfo->getType();
1357 
1358   // C++ [class.union]p1:
1359   //   A union shall not have base classes.
1360   if (Class->isUnion()) {
1361     Diag(Class->getLocation(), diag::err_base_clause_on_union)
1362       << SpecifierRange;
1363     return nullptr;
1364   }
1365 
1366   if (EllipsisLoc.isValid() &&
1367       !TInfo->getType()->containsUnexpandedParameterPack()) {
1368     Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
1369       << TInfo->getTypeLoc().getSourceRange();
1370     EllipsisLoc = SourceLocation();
1371   }
1372 
1373   SourceLocation BaseLoc = TInfo->getTypeLoc().getBeginLoc();
1374 
1375   if (BaseType->isDependentType()) {
1376     // Make sure that we don't have circular inheritance among our dependent
1377     // bases. For non-dependent bases, the check for completeness below handles
1378     // this.
1379     if (CXXRecordDecl *BaseDecl = BaseType->getAsCXXRecordDecl()) {
1380       if (BaseDecl->getCanonicalDecl() == Class->getCanonicalDecl() ||
1381           ((BaseDecl = BaseDecl->getDefinition()) &&
1382            findCircularInheritance(Class, BaseDecl))) {
1383         Diag(BaseLoc, diag::err_circular_inheritance)
1384           << BaseType << Context.getTypeDeclType(Class);
1385 
1386         if (BaseDecl->getCanonicalDecl() != Class->getCanonicalDecl())
1387           Diag(BaseDecl->getLocation(), diag::note_previous_decl)
1388             << BaseType;
1389 
1390         return nullptr;
1391       }
1392     }
1393 
1394     return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
1395                                           Class->getTagKind() == TTK_Class,
1396                                           Access, TInfo, EllipsisLoc);
1397   }
1398 
1399   // Base specifiers must be record types.
1400   if (!BaseType->isRecordType()) {
1401     Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
1402     return nullptr;
1403   }
1404 
1405   // C++ [class.union]p1:
1406   //   A union shall not be used as a base class.
1407   if (BaseType->isUnionType()) {
1408     Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
1409     return nullptr;
1410   }
1411 
1412   // For the MS ABI, propagate DLL attributes to base class templates.
1413   if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
1414     if (Attr *ClassAttr = getDLLAttr(Class)) {
1415       if (auto *BaseTemplate = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
1416               BaseType->getAsCXXRecordDecl())) {
1417         propagateDLLAttrToBaseClassTemplate(Class, ClassAttr, BaseTemplate,
1418                                             BaseLoc);
1419       }
1420     }
1421   }
1422 
1423   // C++ [class.derived]p2:
1424   //   The class-name in a base-specifier shall not be an incompletely
1425   //   defined class.
1426   if (RequireCompleteType(BaseLoc, BaseType,
1427                           diag::err_incomplete_base_class, SpecifierRange)) {
1428     Class->setInvalidDecl();
1429     return nullptr;
1430   }
1431 
1432   // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
1433   RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl();
1434   assert(BaseDecl && "Record type has no declaration");
1435   BaseDecl = BaseDecl->getDefinition();
1436   assert(BaseDecl && "Base type is not incomplete, but has no definition");
1437   CXXRecordDecl *CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
1438   assert(CXXBaseDecl && "Base type is not a C++ type");
1439 
1440   // A class which contains a flexible array member is not suitable for use as a
1441   // base class:
1442   //   - If the layout determines that a base comes before another base,
1443   //     the flexible array member would index into the subsequent base.
1444   //   - If the layout determines that base comes before the derived class,
1445   //     the flexible array member would index into the derived class.
1446   if (CXXBaseDecl->hasFlexibleArrayMember()) {
1447     Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
1448       << CXXBaseDecl->getDeclName();
1449     return nullptr;
1450   }
1451 
1452   // C++ [class]p3:
1453   //   If a class is marked final and it appears as a base-type-specifier in
1454   //   base-clause, the program is ill-formed.
1455   if (FinalAttr *FA = CXXBaseDecl->getAttr<FinalAttr>()) {
1456     Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
1457       << CXXBaseDecl->getDeclName()
1458       << FA->isSpelledAsSealed();
1459     Diag(CXXBaseDecl->getLocation(), diag::note_entity_declared_at)
1460         << CXXBaseDecl->getDeclName() << FA->getRange();
1461     return nullptr;
1462   }
1463 
1464   if (BaseDecl->isInvalidDecl())
1465     Class->setInvalidDecl();
1466 
1467   // Create the base specifier.
1468   return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
1469                                         Class->getTagKind() == TTK_Class,
1470                                         Access, TInfo, EllipsisLoc);
1471 }
1472 
1473 /// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
1474 /// one entry in the base class list of a class specifier, for
1475 /// example:
1476 ///    class foo : public bar, virtual private baz {
1477 /// 'public bar' and 'virtual private baz' are each base-specifiers.
1478 BaseResult
ActOnBaseSpecifier(Decl * classdecl,SourceRange SpecifierRange,ParsedAttributes & Attributes,bool Virtual,AccessSpecifier Access,ParsedType basetype,SourceLocation BaseLoc,SourceLocation EllipsisLoc)1479 Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange,
1480                          ParsedAttributes &Attributes,
1481                          bool Virtual, AccessSpecifier Access,
1482                          ParsedType basetype, SourceLocation BaseLoc,
1483                          SourceLocation EllipsisLoc) {
1484   if (!classdecl)
1485     return true;
1486 
1487   AdjustDeclIfTemplate(classdecl);
1488   CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl);
1489   if (!Class)
1490     return true;
1491 
1492   // We haven't yet attached the base specifiers.
1493   Class->setIsParsingBaseSpecifiers();
1494 
1495   // We do not support any C++11 attributes on base-specifiers yet.
1496   // Diagnose any attributes we see.
1497   if (!Attributes.empty()) {
1498     for (AttributeList *Attr = Attributes.getList(); Attr;
1499          Attr = Attr->getNext()) {
1500       if (Attr->isInvalid() ||
1501           Attr->getKind() == AttributeList::IgnoredAttribute)
1502         continue;
1503       Diag(Attr->getLoc(),
1504            Attr->getKind() == AttributeList::UnknownAttribute
1505              ? diag::warn_unknown_attribute_ignored
1506              : diag::err_base_specifier_attribute)
1507         << Attr->getName();
1508     }
1509   }
1510 
1511   TypeSourceInfo *TInfo = nullptr;
1512   GetTypeFromParser(basetype, &TInfo);
1513 
1514   if (EllipsisLoc.isInvalid() &&
1515       DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo,
1516                                       UPPC_BaseType))
1517     return true;
1518 
1519   if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
1520                                                       Virtual, Access, TInfo,
1521                                                       EllipsisLoc))
1522     return BaseSpec;
1523   else
1524     Class->setInvalidDecl();
1525 
1526   return true;
1527 }
1528 
1529 /// Use small set to collect indirect bases.  As this is only used
1530 /// locally, there's no need to abstract the small size parameter.
1531 typedef llvm::SmallPtrSet<QualType, 4> IndirectBaseSet;
1532 
1533 /// \brief Recursively add the bases of Type.  Don't add Type itself.
1534 static void
NoteIndirectBases(ASTContext & Context,IndirectBaseSet & Set,const QualType & Type)1535 NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set,
1536                   const QualType &Type)
1537 {
1538   // Even though the incoming type is a base, it might not be
1539   // a class -- it could be a template parm, for instance.
1540   if (auto Rec = Type->getAs<RecordType>()) {
1541     auto Decl = Rec->getAsCXXRecordDecl();
1542 
1543     // Iterate over its bases.
1544     for (const auto &BaseSpec : Decl->bases()) {
1545       QualType Base = Context.getCanonicalType(BaseSpec.getType())
1546         .getUnqualifiedType();
1547       if (Set.insert(Base).second)
1548         // If we've not already seen it, recurse.
1549         NoteIndirectBases(Context, Set, Base);
1550     }
1551   }
1552 }
1553 
1554 /// \brief Performs the actual work of attaching the given base class
1555 /// specifiers to a C++ class.
AttachBaseSpecifiers(CXXRecordDecl * Class,MutableArrayRef<CXXBaseSpecifier * > Bases)1556 bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class,
1557                                 MutableArrayRef<CXXBaseSpecifier *> Bases) {
1558  if (Bases.empty())
1559     return false;
1560 
1561   // Used to keep track of which base types we have already seen, so
1562   // that we can properly diagnose redundant direct base types. Note
1563   // that the key is always the unqualified canonical type of the base
1564   // class.
1565   std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
1566 
1567   // Used to track indirect bases so we can see if a direct base is
1568   // ambiguous.
1569   IndirectBaseSet IndirectBaseTypes;
1570 
1571   // Copy non-redundant base specifiers into permanent storage.
1572   unsigned NumGoodBases = 0;
1573   bool Invalid = false;
1574   for (unsigned idx = 0; idx < Bases.size(); ++idx) {
1575     QualType NewBaseType
1576       = Context.getCanonicalType(Bases[idx]->getType());
1577     NewBaseType = NewBaseType.getLocalUnqualifiedType();
1578 
1579     CXXBaseSpecifier *&KnownBase = KnownBaseTypes[NewBaseType];
1580     if (KnownBase) {
1581       // C++ [class.mi]p3:
1582       //   A class shall not be specified as a direct base class of a
1583       //   derived class more than once.
1584       Diag(Bases[idx]->getLocStart(),
1585            diag::err_duplicate_base_class)
1586         << KnownBase->getType()
1587         << Bases[idx]->getSourceRange();
1588 
1589       // Delete the duplicate base class specifier; we're going to
1590       // overwrite its pointer later.
1591       Context.Deallocate(Bases[idx]);
1592 
1593       Invalid = true;
1594     } else {
1595       // Okay, add this new base class.
1596       KnownBase = Bases[idx];
1597       Bases[NumGoodBases++] = Bases[idx];
1598 
1599       // Note this base's direct & indirect bases, if there could be ambiguity.
1600       if (Bases.size() > 1)
1601         NoteIndirectBases(Context, IndirectBaseTypes, NewBaseType);
1602 
1603       if (const RecordType *Record = NewBaseType->getAs<RecordType>()) {
1604         const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
1605         if (Class->isInterface() &&
1606               (!RD->isInterface() ||
1607                KnownBase->getAccessSpecifier() != AS_public)) {
1608           // The Microsoft extension __interface does not permit bases that
1609           // are not themselves public interfaces.
1610           Diag(KnownBase->getLocStart(), diag::err_invalid_base_in_interface)
1611             << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getName()
1612             << RD->getSourceRange();
1613           Invalid = true;
1614         }
1615         if (RD->hasAttr<WeakAttr>())
1616           Class->addAttr(WeakAttr::CreateImplicit(Context));
1617       }
1618     }
1619   }
1620 
1621   // Attach the remaining base class specifiers to the derived class.
1622   Class->setBases(Bases.data(), NumGoodBases);
1623 
1624   for (unsigned idx = 0; idx < NumGoodBases; ++idx) {
1625     // Check whether this direct base is inaccessible due to ambiguity.
1626     QualType BaseType = Bases[idx]->getType();
1627     CanQualType CanonicalBase = Context.getCanonicalType(BaseType)
1628       .getUnqualifiedType();
1629 
1630     if (IndirectBaseTypes.count(CanonicalBase)) {
1631       CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1632                          /*DetectVirtual=*/true);
1633       bool found
1634         = Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
1635       assert(found);
1636       (void)found;
1637 
1638       if (Paths.isAmbiguous(CanonicalBase))
1639         Diag(Bases[idx]->getLocStart (), diag::warn_inaccessible_base_class)
1640           << BaseType << getAmbiguousPathsDisplayString(Paths)
1641           << Bases[idx]->getSourceRange();
1642       else
1643         assert(Bases[idx]->isVirtual());
1644     }
1645 
1646     // Delete the base class specifier, since its data has been copied
1647     // into the CXXRecordDecl.
1648     Context.Deallocate(Bases[idx]);
1649   }
1650 
1651   return Invalid;
1652 }
1653 
1654 /// ActOnBaseSpecifiers - Attach the given base specifiers to the
1655 /// class, after checking whether there are any duplicate base
1656 /// classes.
ActOnBaseSpecifiers(Decl * ClassDecl,MutableArrayRef<CXXBaseSpecifier * > Bases)1657 void Sema::ActOnBaseSpecifiers(Decl *ClassDecl,
1658                                MutableArrayRef<CXXBaseSpecifier *> Bases) {
1659   if (!ClassDecl || Bases.empty())
1660     return;
1661 
1662   AdjustDeclIfTemplate(ClassDecl);
1663   AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), Bases);
1664 }
1665 
1666 /// \brief Determine whether the type \p Derived is a C++ class that is
1667 /// derived from the type \p Base.
IsDerivedFrom(SourceLocation Loc,QualType Derived,QualType Base)1668 bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base) {
1669   if (!getLangOpts().CPlusPlus)
1670     return false;
1671 
1672   CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
1673   if (!DerivedRD)
1674     return false;
1675 
1676   CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
1677   if (!BaseRD)
1678     return false;
1679 
1680   // If either the base or the derived type is invalid, don't try to
1681   // check whether one is derived from the other.
1682   if (BaseRD->isInvalidDecl() || DerivedRD->isInvalidDecl())
1683     return false;
1684 
1685   // FIXME: In a modules build, do we need the entire path to be visible for us
1686   // to be able to use the inheritance relationship?
1687   if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
1688     return false;
1689 
1690   return DerivedRD->isDerivedFrom(BaseRD);
1691 }
1692 
1693 /// \brief Determine whether the type \p Derived is a C++ class that is
1694 /// derived from the type \p Base.
IsDerivedFrom(SourceLocation Loc,QualType Derived,QualType Base,CXXBasePaths & Paths)1695 bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
1696                          CXXBasePaths &Paths) {
1697   if (!getLangOpts().CPlusPlus)
1698     return false;
1699 
1700   CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
1701   if (!DerivedRD)
1702     return false;
1703 
1704   CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
1705   if (!BaseRD)
1706     return false;
1707 
1708   if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
1709     return false;
1710 
1711   return DerivedRD->isDerivedFrom(BaseRD, Paths);
1712 }
1713 
BuildBasePathArray(const CXXBasePaths & Paths,CXXCastPath & BasePathArray)1714 void Sema::BuildBasePathArray(const CXXBasePaths &Paths,
1715                               CXXCastPath &BasePathArray) {
1716   assert(BasePathArray.empty() && "Base path array must be empty!");
1717   assert(Paths.isRecordingPaths() && "Must record paths!");
1718 
1719   const CXXBasePath &Path = Paths.front();
1720 
1721   // We first go backward and check if we have a virtual base.
1722   // FIXME: It would be better if CXXBasePath had the base specifier for
1723   // the nearest virtual base.
1724   unsigned Start = 0;
1725   for (unsigned I = Path.size(); I != 0; --I) {
1726     if (Path[I - 1].Base->isVirtual()) {
1727       Start = I - 1;
1728       break;
1729     }
1730   }
1731 
1732   // Now add all bases.
1733   for (unsigned I = Start, E = Path.size(); I != E; ++I)
1734     BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
1735 }
1736 
1737 /// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
1738 /// conversion (where Derived and Base are class types) is
1739 /// well-formed, meaning that the conversion is unambiguous (and
1740 /// that all of the base classes are accessible). Returns true
1741 /// and emits a diagnostic if the code is ill-formed, returns false
1742 /// otherwise. Loc is the location where this routine should point to
1743 /// if there is an error, and Range is the source range to highlight
1744 /// if there is an error.
1745 ///
1746 /// If either InaccessibleBaseID or AmbigiousBaseConvID are 0, then the
1747 /// diagnostic for the respective type of error will be suppressed, but the
1748 /// check for ill-formed code will still be performed.
1749 bool
CheckDerivedToBaseConversion(QualType Derived,QualType Base,unsigned InaccessibleBaseID,unsigned AmbigiousBaseConvID,SourceLocation Loc,SourceRange Range,DeclarationName Name,CXXCastPath * BasePath,bool IgnoreAccess)1750 Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
1751                                    unsigned InaccessibleBaseID,
1752                                    unsigned AmbigiousBaseConvID,
1753                                    SourceLocation Loc, SourceRange Range,
1754                                    DeclarationName Name,
1755                                    CXXCastPath *BasePath,
1756                                    bool IgnoreAccess) {
1757   // First, determine whether the path from Derived to Base is
1758   // ambiguous. This is slightly more expensive than checking whether
1759   // the Derived to Base conversion exists, because here we need to
1760   // explore multiple paths to determine if there is an ambiguity.
1761   CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1762                      /*DetectVirtual=*/false);
1763   bool DerivationOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
1764   assert(DerivationOkay &&
1765          "Can only be used with a derived-to-base conversion");
1766   (void)DerivationOkay;
1767 
1768   if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType())) {
1769     if (!IgnoreAccess) {
1770       // Check that the base class can be accessed.
1771       switch (CheckBaseClassAccess(Loc, Base, Derived, Paths.front(),
1772                                    InaccessibleBaseID)) {
1773         case AR_inaccessible:
1774           return true;
1775         case AR_accessible:
1776         case AR_dependent:
1777         case AR_delayed:
1778           break;
1779       }
1780     }
1781 
1782     // Build a base path if necessary.
1783     if (BasePath)
1784       BuildBasePathArray(Paths, *BasePath);
1785     return false;
1786   }
1787 
1788   if (AmbigiousBaseConvID) {
1789     // We know that the derived-to-base conversion is ambiguous, and
1790     // we're going to produce a diagnostic. Perform the derived-to-base
1791     // search just one more time to compute all of the possible paths so
1792     // that we can print them out. This is more expensive than any of
1793     // the previous derived-to-base checks we've done, but at this point
1794     // performance isn't as much of an issue.
1795     Paths.clear();
1796     Paths.setRecordingPaths(true);
1797     bool StillOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
1798     assert(StillOkay && "Can only be used with a derived-to-base conversion");
1799     (void)StillOkay;
1800 
1801     // Build up a textual representation of the ambiguous paths, e.g.,
1802     // D -> B -> A, that will be used to illustrate the ambiguous
1803     // conversions in the diagnostic. We only print one of the paths
1804     // to each base class subobject.
1805     std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
1806 
1807     Diag(Loc, AmbigiousBaseConvID)
1808     << Derived << Base << PathDisplayStr << Range << Name;
1809   }
1810   return true;
1811 }
1812 
1813 bool
CheckDerivedToBaseConversion(QualType Derived,QualType Base,SourceLocation Loc,SourceRange Range,CXXCastPath * BasePath,bool IgnoreAccess)1814 Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
1815                                    SourceLocation Loc, SourceRange Range,
1816                                    CXXCastPath *BasePath,
1817                                    bool IgnoreAccess) {
1818   return CheckDerivedToBaseConversion(
1819       Derived, Base, diag::err_upcast_to_inaccessible_base,
1820       diag::err_ambiguous_derived_to_base_conv, Loc, Range, DeclarationName(),
1821       BasePath, IgnoreAccess);
1822 }
1823 
1824 
1825 /// @brief Builds a string representing ambiguous paths from a
1826 /// specific derived class to different subobjects of the same base
1827 /// class.
1828 ///
1829 /// This function builds a string that can be used in error messages
1830 /// to show the different paths that one can take through the
1831 /// inheritance hierarchy to go from the derived class to different
1832 /// subobjects of a base class. The result looks something like this:
1833 /// @code
1834 /// struct D -> struct B -> struct A
1835 /// struct D -> struct C -> struct A
1836 /// @endcode
getAmbiguousPathsDisplayString(CXXBasePaths & Paths)1837 std::string Sema::getAmbiguousPathsDisplayString(CXXBasePaths &Paths) {
1838   std::string PathDisplayStr;
1839   std::set<unsigned> DisplayedPaths;
1840   for (CXXBasePaths::paths_iterator Path = Paths.begin();
1841        Path != Paths.end(); ++Path) {
1842     if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
1843       // We haven't displayed a path to this particular base
1844       // class subobject yet.
1845       PathDisplayStr += "\n    ";
1846       PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
1847       for (CXXBasePath::const_iterator Element = Path->begin();
1848            Element != Path->end(); ++Element)
1849         PathDisplayStr += " -> " + Element->Base->getType().getAsString();
1850     }
1851   }
1852 
1853   return PathDisplayStr;
1854 }
1855 
1856 //===----------------------------------------------------------------------===//
1857 // C++ class member Handling
1858 //===----------------------------------------------------------------------===//
1859 
1860 /// ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
ActOnAccessSpecifier(AccessSpecifier Access,SourceLocation ASLoc,SourceLocation ColonLoc,AttributeList * Attrs)1861 bool Sema::ActOnAccessSpecifier(AccessSpecifier Access,
1862                                 SourceLocation ASLoc,
1863                                 SourceLocation ColonLoc,
1864                                 AttributeList *Attrs) {
1865   assert(Access != AS_none && "Invalid kind for syntactic access specifier!");
1866   AccessSpecDecl *ASDecl = AccessSpecDecl::Create(Context, Access, CurContext,
1867                                                   ASLoc, ColonLoc);
1868   CurContext->addHiddenDecl(ASDecl);
1869   return ProcessAccessDeclAttributeList(ASDecl, Attrs);
1870 }
1871 
1872 /// CheckOverrideControl - Check C++11 override control semantics.
CheckOverrideControl(NamedDecl * D)1873 void Sema::CheckOverrideControl(NamedDecl *D) {
1874   if (D->isInvalidDecl())
1875     return;
1876 
1877   // We only care about "override" and "final" declarations.
1878   if (!D->hasAttr<OverrideAttr>() && !D->hasAttr<FinalAttr>())
1879     return;
1880 
1881   CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
1882 
1883   // We can't check dependent instance methods.
1884   if (MD && MD->isInstance() &&
1885       (MD->getParent()->hasAnyDependentBases() ||
1886        MD->getType()->isDependentType()))
1887     return;
1888 
1889   if (MD && !MD->isVirtual()) {
1890     // If we have a non-virtual method, check if if hides a virtual method.
1891     // (In that case, it's most likely the method has the wrong type.)
1892     SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
1893     FindHiddenVirtualMethods(MD, OverloadedMethods);
1894 
1895     if (!OverloadedMethods.empty()) {
1896       if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
1897         Diag(OA->getLocation(),
1898              diag::override_keyword_hides_virtual_member_function)
1899           << "override" << (OverloadedMethods.size() > 1);
1900       } else if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
1901         Diag(FA->getLocation(),
1902              diag::override_keyword_hides_virtual_member_function)
1903           << (FA->isSpelledAsSealed() ? "sealed" : "final")
1904           << (OverloadedMethods.size() > 1);
1905       }
1906       NoteHiddenVirtualMethods(MD, OverloadedMethods);
1907       MD->setInvalidDecl();
1908       return;
1909     }
1910     // Fall through into the general case diagnostic.
1911     // FIXME: We might want to attempt typo correction here.
1912   }
1913 
1914   if (!MD || !MD->isVirtual()) {
1915     if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
1916       Diag(OA->getLocation(),
1917            diag::override_keyword_only_allowed_on_virtual_member_functions)
1918         << "override" << FixItHint::CreateRemoval(OA->getLocation());
1919       D->dropAttr<OverrideAttr>();
1920     }
1921     if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
1922       Diag(FA->getLocation(),
1923            diag::override_keyword_only_allowed_on_virtual_member_functions)
1924         << (FA->isSpelledAsSealed() ? "sealed" : "final")
1925         << FixItHint::CreateRemoval(FA->getLocation());
1926       D->dropAttr<FinalAttr>();
1927     }
1928     return;
1929   }
1930 
1931   // C++11 [class.virtual]p5:
1932   //   If a function is marked with the virt-specifier override and
1933   //   does not override a member function of a base class, the program is
1934   //   ill-formed.
1935   bool HasOverriddenMethods =
1936     MD->begin_overridden_methods() != MD->end_overridden_methods();
1937   if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)
1938     Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding)
1939       << MD->getDeclName();
1940 }
1941 
DiagnoseAbsenceOfOverrideControl(NamedDecl * D)1942 void Sema::DiagnoseAbsenceOfOverrideControl(NamedDecl *D) {
1943   if (D->isInvalidDecl() || D->hasAttr<OverrideAttr>())
1944     return;
1945   CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
1946   if (!MD || MD->isImplicit() || MD->hasAttr<FinalAttr>() ||
1947       isa<CXXDestructorDecl>(MD))
1948     return;
1949 
1950   SourceLocation Loc = MD->getLocation();
1951   SourceLocation SpellingLoc = Loc;
1952   if (getSourceManager().isMacroArgExpansion(Loc))
1953     SpellingLoc = getSourceManager().getImmediateExpansionRange(Loc).first;
1954   SpellingLoc = getSourceManager().getSpellingLoc(SpellingLoc);
1955   if (SpellingLoc.isValid() && getSourceManager().isInSystemHeader(SpellingLoc))
1956       return;
1957 
1958   if (MD->size_overridden_methods() > 0) {
1959     Diag(MD->getLocation(), diag::warn_function_marked_not_override_overriding)
1960       << MD->getDeclName();
1961     const CXXMethodDecl *OMD = *MD->begin_overridden_methods();
1962     Diag(OMD->getLocation(), diag::note_overridden_virtual_function);
1963   }
1964 }
1965 
1966 /// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member
1967 /// function overrides a virtual member function marked 'final', according to
1968 /// C++11 [class.virtual]p4.
CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl * New,const CXXMethodDecl * Old)1969 bool Sema::CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
1970                                                   const CXXMethodDecl *Old) {
1971   FinalAttr *FA = Old->getAttr<FinalAttr>();
1972   if (!FA)
1973     return false;
1974 
1975   Diag(New->getLocation(), diag::err_final_function_overridden)
1976     << New->getDeclName()
1977     << FA->isSpelledAsSealed();
1978   Diag(Old->getLocation(), diag::note_overridden_virtual_function);
1979   return true;
1980 }
1981 
InitializationHasSideEffects(const FieldDecl & FD)1982 static bool InitializationHasSideEffects(const FieldDecl &FD) {
1983   const Type *T = FD.getType()->getBaseElementTypeUnsafe();
1984   // FIXME: Destruction of ObjC lifetime types has side-effects.
1985   if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1986     return !RD->isCompleteDefinition() ||
1987            !RD->hasTrivialDefaultConstructor() ||
1988            !RD->hasTrivialDestructor();
1989   return false;
1990 }
1991 
getMSPropertyAttr(AttributeList * list)1992 static AttributeList *getMSPropertyAttr(AttributeList *list) {
1993   for (AttributeList *it = list; it != nullptr; it = it->getNext())
1994     if (it->isDeclspecPropertyAttribute())
1995       return it;
1996   return nullptr;
1997 }
1998 
1999 /// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
2000 /// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
2001 /// bitfield width if there is one, 'InitExpr' specifies the initializer if
2002 /// one has been parsed, and 'InitStyle' is set if an in-class initializer is
2003 /// present (but parsing it has been deferred).
2004 NamedDecl *
ActOnCXXMemberDeclarator(Scope * S,AccessSpecifier AS,Declarator & D,MultiTemplateParamsArg TemplateParameterLists,Expr * BW,const VirtSpecifiers & VS,InClassInitStyle InitStyle)2005 Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
2006                                MultiTemplateParamsArg TemplateParameterLists,
2007                                Expr *BW, const VirtSpecifiers &VS,
2008                                InClassInitStyle InitStyle) {
2009   const DeclSpec &DS = D.getDeclSpec();
2010   DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
2011   DeclarationName Name = NameInfo.getName();
2012   SourceLocation Loc = NameInfo.getLoc();
2013 
2014   // For anonymous bitfields, the location should point to the type.
2015   if (Loc.isInvalid())
2016     Loc = D.getLocStart();
2017 
2018   Expr *BitWidth = static_cast<Expr*>(BW);
2019 
2020   assert(isa<CXXRecordDecl>(CurContext));
2021   assert(!DS.isFriendSpecified());
2022 
2023   bool isFunc = D.isDeclarationOfFunction();
2024 
2025   if (cast<CXXRecordDecl>(CurContext)->isInterface()) {
2026     // The Microsoft extension __interface only permits public member functions
2027     // and prohibits constructors, destructors, operators, non-public member
2028     // functions, static methods and data members.
2029     unsigned InvalidDecl;
2030     bool ShowDeclName = true;
2031     if (!isFunc)
2032       InvalidDecl = (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) ? 0 : 1;
2033     else if (AS != AS_public)
2034       InvalidDecl = 2;
2035     else if (DS.getStorageClassSpec() == DeclSpec::SCS_static)
2036       InvalidDecl = 3;
2037     else switch (Name.getNameKind()) {
2038       case DeclarationName::CXXConstructorName:
2039         InvalidDecl = 4;
2040         ShowDeclName = false;
2041         break;
2042 
2043       case DeclarationName::CXXDestructorName:
2044         InvalidDecl = 5;
2045         ShowDeclName = false;
2046         break;
2047 
2048       case DeclarationName::CXXOperatorName:
2049       case DeclarationName::CXXConversionFunctionName:
2050         InvalidDecl = 6;
2051         break;
2052 
2053       default:
2054         InvalidDecl = 0;
2055         break;
2056     }
2057 
2058     if (InvalidDecl) {
2059       if (ShowDeclName)
2060         Diag(Loc, diag::err_invalid_member_in_interface)
2061           << (InvalidDecl-1) << Name;
2062       else
2063         Diag(Loc, diag::err_invalid_member_in_interface)
2064           << (InvalidDecl-1) << "";
2065       return nullptr;
2066     }
2067   }
2068 
2069   // C++ 9.2p6: A member shall not be declared to have automatic storage
2070   // duration (auto, register) or with the extern storage-class-specifier.
2071   // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
2072   // data members and cannot be applied to names declared const or static,
2073   // and cannot be applied to reference members.
2074   switch (DS.getStorageClassSpec()) {
2075   case DeclSpec::SCS_unspecified:
2076   case DeclSpec::SCS_typedef:
2077   case DeclSpec::SCS_static:
2078     break;
2079   case DeclSpec::SCS_mutable:
2080     if (isFunc) {
2081       Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
2082 
2083       // FIXME: It would be nicer if the keyword was ignored only for this
2084       // declarator. Otherwise we could get follow-up errors.
2085       D.getMutableDeclSpec().ClearStorageClassSpecs();
2086     }
2087     break;
2088   default:
2089     Diag(DS.getStorageClassSpecLoc(),
2090          diag::err_storageclass_invalid_for_member);
2091     D.getMutableDeclSpec().ClearStorageClassSpecs();
2092     break;
2093   }
2094 
2095   bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
2096                        DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
2097                       !isFunc);
2098 
2099   if (DS.isConstexprSpecified() && isInstField) {
2100     SemaDiagnosticBuilder B =
2101         Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr_member);
2102     SourceLocation ConstexprLoc = DS.getConstexprSpecLoc();
2103     if (InitStyle == ICIS_NoInit) {
2104       B << 0 << 0;
2105       if (D.getDeclSpec().getTypeQualifiers() & DeclSpec::TQ_const)
2106         B << FixItHint::CreateRemoval(ConstexprLoc);
2107       else {
2108         B << FixItHint::CreateReplacement(ConstexprLoc, "const");
2109         D.getMutableDeclSpec().ClearConstexprSpec();
2110         const char *PrevSpec;
2111         unsigned DiagID;
2112         bool Failed = D.getMutableDeclSpec().SetTypeQual(
2113             DeclSpec::TQ_const, ConstexprLoc, PrevSpec, DiagID, getLangOpts());
2114         (void)Failed;
2115         assert(!Failed && "Making a constexpr member const shouldn't fail");
2116       }
2117     } else {
2118       B << 1;
2119       const char *PrevSpec;
2120       unsigned DiagID;
2121       if (D.getMutableDeclSpec().SetStorageClassSpec(
2122           *this, DeclSpec::SCS_static, ConstexprLoc, PrevSpec, DiagID,
2123           Context.getPrintingPolicy())) {
2124         assert(DS.getStorageClassSpec() == DeclSpec::SCS_mutable &&
2125                "This is the only DeclSpec that should fail to be applied");
2126         B << 1;
2127       } else {
2128         B << 0 << FixItHint::CreateInsertion(ConstexprLoc, "static ");
2129         isInstField = false;
2130       }
2131     }
2132   }
2133 
2134   NamedDecl *Member;
2135   if (isInstField) {
2136     CXXScopeSpec &SS = D.getCXXScopeSpec();
2137 
2138     // Data members must have identifiers for names.
2139     if (!Name.isIdentifier()) {
2140       Diag(Loc, diag::err_bad_variable_name)
2141         << Name;
2142       return nullptr;
2143     }
2144 
2145     IdentifierInfo *II = Name.getAsIdentifierInfo();
2146 
2147     // Member field could not be with "template" keyword.
2148     // So TemplateParameterLists should be empty in this case.
2149     if (TemplateParameterLists.size()) {
2150       TemplateParameterList* TemplateParams = TemplateParameterLists[0];
2151       if (TemplateParams->size()) {
2152         // There is no such thing as a member field template.
2153         Diag(D.getIdentifierLoc(), diag::err_template_member)
2154             << II
2155             << SourceRange(TemplateParams->getTemplateLoc(),
2156                 TemplateParams->getRAngleLoc());
2157       } else {
2158         // There is an extraneous 'template<>' for this member.
2159         Diag(TemplateParams->getTemplateLoc(),
2160             diag::err_template_member_noparams)
2161             << II
2162             << SourceRange(TemplateParams->getTemplateLoc(),
2163                 TemplateParams->getRAngleLoc());
2164       }
2165       return nullptr;
2166     }
2167 
2168     if (SS.isSet() && !SS.isInvalid()) {
2169       // The user provided a superfluous scope specifier inside a class
2170       // definition:
2171       //
2172       // class X {
2173       //   int X::member;
2174       // };
2175       if (DeclContext *DC = computeDeclContext(SS, false))
2176         diagnoseQualifiedDeclaration(SS, DC, Name, D.getIdentifierLoc());
2177       else
2178         Diag(D.getIdentifierLoc(), diag::err_member_qualification)
2179           << Name << SS.getRange();
2180 
2181       SS.clear();
2182     }
2183 
2184     AttributeList *MSPropertyAttr =
2185       getMSPropertyAttr(D.getDeclSpec().getAttributes().getList());
2186     if (MSPropertyAttr) {
2187       Member = HandleMSProperty(S, cast<CXXRecordDecl>(CurContext), Loc, D,
2188                                 BitWidth, InitStyle, AS, MSPropertyAttr);
2189       if (!Member)
2190         return nullptr;
2191       isInstField = false;
2192     } else {
2193       Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D,
2194                                 BitWidth, InitStyle, AS);
2195       assert(Member && "HandleField never returns null");
2196     }
2197   } else {
2198     Member = HandleDeclarator(S, D, TemplateParameterLists);
2199     if (!Member)
2200       return nullptr;
2201 
2202     // Non-instance-fields can't have a bitfield.
2203     if (BitWidth) {
2204       if (Member->isInvalidDecl()) {
2205         // don't emit another diagnostic.
2206       } else if (isa<VarDecl>(Member) || isa<VarTemplateDecl>(Member)) {
2207         // C++ 9.6p3: A bit-field shall not be a static member.
2208         // "static member 'A' cannot be a bit-field"
2209         Diag(Loc, diag::err_static_not_bitfield)
2210           << Name << BitWidth->getSourceRange();
2211       } else if (isa<TypedefDecl>(Member)) {
2212         // "typedef member 'x' cannot be a bit-field"
2213         Diag(Loc, diag::err_typedef_not_bitfield)
2214           << Name << BitWidth->getSourceRange();
2215       } else {
2216         // A function typedef ("typedef int f(); f a;").
2217         // C++ 9.6p3: A bit-field shall have integral or enumeration type.
2218         Diag(Loc, diag::err_not_integral_type_bitfield)
2219           << Name << cast<ValueDecl>(Member)->getType()
2220           << BitWidth->getSourceRange();
2221       }
2222 
2223       BitWidth = nullptr;
2224       Member->setInvalidDecl();
2225     }
2226 
2227     Member->setAccess(AS);
2228 
2229     // If we have declared a member function template or static data member
2230     // template, set the access of the templated declaration as well.
2231     if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
2232       FunTmpl->getTemplatedDecl()->setAccess(AS);
2233     else if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(Member))
2234       VarTmpl->getTemplatedDecl()->setAccess(AS);
2235   }
2236 
2237   if (VS.isOverrideSpecified())
2238     Member->addAttr(new (Context) OverrideAttr(VS.getOverrideLoc(), Context, 0));
2239   if (VS.isFinalSpecified())
2240     Member->addAttr(new (Context) FinalAttr(VS.getFinalLoc(), Context,
2241                                             VS.isFinalSpelledSealed()));
2242 
2243   if (VS.getLastLocation().isValid()) {
2244     // Update the end location of a method that has a virt-specifiers.
2245     if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member))
2246       MD->setRangeEnd(VS.getLastLocation());
2247   }
2248 
2249   CheckOverrideControl(Member);
2250 
2251   assert((Name || isInstField) && "No identifier for non-field ?");
2252 
2253   if (isInstField) {
2254     FieldDecl *FD = cast<FieldDecl>(Member);
2255     FieldCollector->Add(FD);
2256 
2257     if (!Diags.isIgnored(diag::warn_unused_private_field, FD->getLocation())) {
2258       // Remember all explicit private FieldDecls that have a name, no side
2259       // effects and are not part of a dependent type declaration.
2260       if (!FD->isImplicit() && FD->getDeclName() &&
2261           FD->getAccess() == AS_private &&
2262           !FD->hasAttr<UnusedAttr>() &&
2263           !FD->getParent()->isDependentContext() &&
2264           !InitializationHasSideEffects(*FD))
2265         UnusedPrivateFields.insert(FD);
2266     }
2267   }
2268 
2269   return Member;
2270 }
2271 
2272 namespace {
2273   class UninitializedFieldVisitor
2274       : public EvaluatedExprVisitor<UninitializedFieldVisitor> {
2275     Sema &S;
2276     // List of Decls to generate a warning on.  Also remove Decls that become
2277     // initialized.
2278     llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
2279     // List of base classes of the record.  Classes are removed after their
2280     // initializers.
2281     llvm::SmallPtrSetImpl<QualType> &BaseClasses;
2282     // Vector of decls to be removed from the Decl set prior to visiting the
2283     // nodes.  These Decls may have been initialized in the prior initializer.
2284     llvm::SmallVector<ValueDecl*, 4> DeclsToRemove;
2285     // If non-null, add a note to the warning pointing back to the constructor.
2286     const CXXConstructorDecl *Constructor;
2287     // Variables to hold state when processing an initializer list.  When
2288     // InitList is true, special case initialization of FieldDecls matching
2289     // InitListFieldDecl.
2290     bool InitList;
2291     FieldDecl *InitListFieldDecl;
2292     llvm::SmallVector<unsigned, 4> InitFieldIndex;
2293 
2294   public:
2295     typedef EvaluatedExprVisitor<UninitializedFieldVisitor> Inherited;
UninitializedFieldVisitor(Sema & S,llvm::SmallPtrSetImpl<ValueDecl * > & Decls,llvm::SmallPtrSetImpl<QualType> & BaseClasses)2296     UninitializedFieldVisitor(Sema &S,
2297                               llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
2298                               llvm::SmallPtrSetImpl<QualType> &BaseClasses)
2299       : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
2300         Constructor(nullptr), InitList(false), InitListFieldDecl(nullptr) {}
2301 
2302     // Returns true if the use of ME is not an uninitialized use.
IsInitListMemberExprInitialized(MemberExpr * ME,bool CheckReferenceOnly)2303     bool IsInitListMemberExprInitialized(MemberExpr *ME,
2304                                          bool CheckReferenceOnly) {
2305       llvm::SmallVector<FieldDecl*, 4> Fields;
2306       bool ReferenceField = false;
2307       while (ME) {
2308         FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
2309         if (!FD)
2310           return false;
2311         Fields.push_back(FD);
2312         if (FD->getType()->isReferenceType())
2313           ReferenceField = true;
2314         ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParenImpCasts());
2315       }
2316 
2317       // Binding a reference to an unintialized field is not an
2318       // uninitialized use.
2319       if (CheckReferenceOnly && !ReferenceField)
2320         return true;
2321 
2322       llvm::SmallVector<unsigned, 4> UsedFieldIndex;
2323       // Discard the first field since it is the field decl that is being
2324       // initialized.
2325       for (auto I = Fields.rbegin() + 1, E = Fields.rend(); I != E; ++I) {
2326         UsedFieldIndex.push_back((*I)->getFieldIndex());
2327       }
2328 
2329       for (auto UsedIter = UsedFieldIndex.begin(),
2330                 UsedEnd = UsedFieldIndex.end(),
2331                 OrigIter = InitFieldIndex.begin(),
2332                 OrigEnd = InitFieldIndex.end();
2333            UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
2334         if (*UsedIter < *OrigIter)
2335           return true;
2336         if (*UsedIter > *OrigIter)
2337           break;
2338       }
2339 
2340       return false;
2341     }
2342 
HandleMemberExpr(MemberExpr * ME,bool CheckReferenceOnly,bool AddressOf)2343     void HandleMemberExpr(MemberExpr *ME, bool CheckReferenceOnly,
2344                           bool AddressOf) {
2345       if (isa<EnumConstantDecl>(ME->getMemberDecl()))
2346         return;
2347 
2348       // FieldME is the inner-most MemberExpr that is not an anonymous struct
2349       // or union.
2350       MemberExpr *FieldME = ME;
2351 
2352       bool AllPODFields = FieldME->getType().isPODType(S.Context);
2353 
2354       Expr *Base = ME;
2355       while (MemberExpr *SubME =
2356                  dyn_cast<MemberExpr>(Base->IgnoreParenImpCasts())) {
2357 
2358         if (isa<VarDecl>(SubME->getMemberDecl()))
2359           return;
2360 
2361         if (FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
2362           if (!FD->isAnonymousStructOrUnion())
2363             FieldME = SubME;
2364 
2365         if (!FieldME->getType().isPODType(S.Context))
2366           AllPODFields = false;
2367 
2368         Base = SubME->getBase();
2369       }
2370 
2371       if (!isa<CXXThisExpr>(Base->IgnoreParenImpCasts()))
2372         return;
2373 
2374       if (AddressOf && AllPODFields)
2375         return;
2376 
2377       ValueDecl* FoundVD = FieldME->getMemberDecl();
2378 
2379       if (ImplicitCastExpr *BaseCast = dyn_cast<ImplicitCastExpr>(Base)) {
2380         while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
2381           BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
2382         }
2383 
2384         if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
2385           QualType T = BaseCast->getType();
2386           if (T->isPointerType() &&
2387               BaseClasses.count(T->getPointeeType())) {
2388             S.Diag(FieldME->getExprLoc(), diag::warn_base_class_is_uninit)
2389                 << T->getPointeeType() << FoundVD;
2390           }
2391         }
2392       }
2393 
2394       if (!Decls.count(FoundVD))
2395         return;
2396 
2397       const bool IsReference = FoundVD->getType()->isReferenceType();
2398 
2399       if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
2400         // Special checking for initializer lists.
2401         if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
2402           return;
2403         }
2404       } else {
2405         // Prevent double warnings on use of unbounded references.
2406         if (CheckReferenceOnly && !IsReference)
2407           return;
2408       }
2409 
2410       unsigned diag = IsReference
2411           ? diag::warn_reference_field_is_uninit
2412           : diag::warn_field_is_uninit;
2413       S.Diag(FieldME->getExprLoc(), diag) << FoundVD;
2414       if (Constructor)
2415         S.Diag(Constructor->getLocation(),
2416                diag::note_uninit_in_this_constructor)
2417           << (Constructor->isDefaultConstructor() && Constructor->isImplicit());
2418 
2419     }
2420 
HandleValue(Expr * E,bool AddressOf)2421     void HandleValue(Expr *E, bool AddressOf) {
2422       E = E->IgnoreParens();
2423 
2424       if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
2425         HandleMemberExpr(ME, false /*CheckReferenceOnly*/,
2426                          AddressOf /*AddressOf*/);
2427         return;
2428       }
2429 
2430       if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
2431         Visit(CO->getCond());
2432         HandleValue(CO->getTrueExpr(), AddressOf);
2433         HandleValue(CO->getFalseExpr(), AddressOf);
2434         return;
2435       }
2436 
2437       if (BinaryConditionalOperator *BCO =
2438               dyn_cast<BinaryConditionalOperator>(E)) {
2439         Visit(BCO->getCond());
2440         HandleValue(BCO->getFalseExpr(), AddressOf);
2441         return;
2442       }
2443 
2444       if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
2445         HandleValue(OVE->getSourceExpr(), AddressOf);
2446         return;
2447       }
2448 
2449       if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
2450         switch (BO->getOpcode()) {
2451         default:
2452           break;
2453         case(BO_PtrMemD):
2454         case(BO_PtrMemI):
2455           HandleValue(BO->getLHS(), AddressOf);
2456           Visit(BO->getRHS());
2457           return;
2458         case(BO_Comma):
2459           Visit(BO->getLHS());
2460           HandleValue(BO->getRHS(), AddressOf);
2461           return;
2462         }
2463       }
2464 
2465       Visit(E);
2466     }
2467 
CheckInitListExpr(InitListExpr * ILE)2468     void CheckInitListExpr(InitListExpr *ILE) {
2469       InitFieldIndex.push_back(0);
2470       for (auto Child : ILE->children()) {
2471         if (InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
2472           CheckInitListExpr(SubList);
2473         } else {
2474           Visit(Child);
2475         }
2476         ++InitFieldIndex.back();
2477       }
2478       InitFieldIndex.pop_back();
2479     }
2480 
CheckInitializer(Expr * E,const CXXConstructorDecl * FieldConstructor,FieldDecl * Field,const Type * BaseClass)2481     void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor,
2482                           FieldDecl *Field, const Type *BaseClass) {
2483       // Remove Decls that may have been initialized in the previous
2484       // initializer.
2485       for (ValueDecl* VD : DeclsToRemove)
2486         Decls.erase(VD);
2487       DeclsToRemove.clear();
2488 
2489       Constructor = FieldConstructor;
2490       InitListExpr *ILE = dyn_cast<InitListExpr>(E);
2491 
2492       if (ILE && Field) {
2493         InitList = true;
2494         InitListFieldDecl = Field;
2495         InitFieldIndex.clear();
2496         CheckInitListExpr(ILE);
2497       } else {
2498         InitList = false;
2499         Visit(E);
2500       }
2501 
2502       if (Field)
2503         Decls.erase(Field);
2504       if (BaseClass)
2505         BaseClasses.erase(BaseClass->getCanonicalTypeInternal());
2506     }
2507 
VisitMemberExpr(MemberExpr * ME)2508     void VisitMemberExpr(MemberExpr *ME) {
2509       // All uses of unbounded reference fields will warn.
2510       HandleMemberExpr(ME, true /*CheckReferenceOnly*/, false /*AddressOf*/);
2511     }
2512 
VisitImplicitCastExpr(ImplicitCastExpr * E)2513     void VisitImplicitCastExpr(ImplicitCastExpr *E) {
2514       if (E->getCastKind() == CK_LValueToRValue) {
2515         HandleValue(E->getSubExpr(), false /*AddressOf*/);
2516         return;
2517       }
2518 
2519       Inherited::VisitImplicitCastExpr(E);
2520     }
2521 
VisitCXXConstructExpr(CXXConstructExpr * E)2522     void VisitCXXConstructExpr(CXXConstructExpr *E) {
2523       if (E->getConstructor()->isCopyConstructor()) {
2524         Expr *ArgExpr = E->getArg(0);
2525         if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
2526           if (ILE->getNumInits() == 1)
2527             ArgExpr = ILE->getInit(0);
2528         if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
2529           if (ICE->getCastKind() == CK_NoOp)
2530             ArgExpr = ICE->getSubExpr();
2531         HandleValue(ArgExpr, false /*AddressOf*/);
2532         return;
2533       }
2534       Inherited::VisitCXXConstructExpr(E);
2535     }
2536 
VisitCXXMemberCallExpr(CXXMemberCallExpr * E)2537     void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
2538       Expr *Callee = E->getCallee();
2539       if (isa<MemberExpr>(Callee)) {
2540         HandleValue(Callee, false /*AddressOf*/);
2541         for (auto Arg : E->arguments())
2542           Visit(Arg);
2543         return;
2544       }
2545 
2546       Inherited::VisitCXXMemberCallExpr(E);
2547     }
2548 
VisitCallExpr(CallExpr * E)2549     void VisitCallExpr(CallExpr *E) {
2550       // Treat std::move as a use.
2551       if (E->getNumArgs() == 1) {
2552         if (FunctionDecl *FD = E->getDirectCallee()) {
2553           if (FD->isInStdNamespace() && FD->getIdentifier() &&
2554               FD->getIdentifier()->isStr("move")) {
2555             HandleValue(E->getArg(0), false /*AddressOf*/);
2556             return;
2557           }
2558         }
2559       }
2560 
2561       Inherited::VisitCallExpr(E);
2562     }
2563 
VisitCXXOperatorCallExpr(CXXOperatorCallExpr * E)2564     void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
2565       Expr *Callee = E->getCallee();
2566 
2567       if (isa<UnresolvedLookupExpr>(Callee))
2568         return Inherited::VisitCXXOperatorCallExpr(E);
2569 
2570       Visit(Callee);
2571       for (auto Arg : E->arguments())
2572         HandleValue(Arg->IgnoreParenImpCasts(), false /*AddressOf*/);
2573     }
2574 
VisitBinaryOperator(BinaryOperator * E)2575     void VisitBinaryOperator(BinaryOperator *E) {
2576       // If a field assignment is detected, remove the field from the
2577       // uninitiailized field set.
2578       if (E->getOpcode() == BO_Assign)
2579         if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getLHS()))
2580           if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
2581             if (!FD->getType()->isReferenceType())
2582               DeclsToRemove.push_back(FD);
2583 
2584       if (E->isCompoundAssignmentOp()) {
2585         HandleValue(E->getLHS(), false /*AddressOf*/);
2586         Visit(E->getRHS());
2587         return;
2588       }
2589 
2590       Inherited::VisitBinaryOperator(E);
2591     }
2592 
VisitUnaryOperator(UnaryOperator * E)2593     void VisitUnaryOperator(UnaryOperator *E) {
2594       if (E->isIncrementDecrementOp()) {
2595         HandleValue(E->getSubExpr(), false /*AddressOf*/);
2596         return;
2597       }
2598       if (E->getOpcode() == UO_AddrOf) {
2599         if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getSubExpr())) {
2600           HandleValue(ME->getBase(), true /*AddressOf*/);
2601           return;
2602         }
2603       }
2604 
2605       Inherited::VisitUnaryOperator(E);
2606     }
2607   };
2608 
2609   // Diagnose value-uses of fields to initialize themselves, e.g.
2610   //   foo(foo)
2611   // where foo is not also a parameter to the constructor.
2612   // Also diagnose across field uninitialized use such as
2613   //   x(y), y(x)
2614   // TODO: implement -Wuninitialized and fold this into that framework.
DiagnoseUninitializedFields(Sema & SemaRef,const CXXConstructorDecl * Constructor)2615   static void DiagnoseUninitializedFields(
2616       Sema &SemaRef, const CXXConstructorDecl *Constructor) {
2617 
2618     if (SemaRef.getDiagnostics().isIgnored(diag::warn_field_is_uninit,
2619                                            Constructor->getLocation())) {
2620       return;
2621     }
2622 
2623     if (Constructor->isInvalidDecl())
2624       return;
2625 
2626     const CXXRecordDecl *RD = Constructor->getParent();
2627 
2628     if (RD->getDescribedClassTemplate())
2629       return;
2630 
2631     // Holds fields that are uninitialized.
2632     llvm::SmallPtrSet<ValueDecl*, 4> UninitializedFields;
2633 
2634     // At the beginning, all fields are uninitialized.
2635     for (auto *I : RD->decls()) {
2636       if (auto *FD = dyn_cast<FieldDecl>(I)) {
2637         UninitializedFields.insert(FD);
2638       } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
2639         UninitializedFields.insert(IFD->getAnonField());
2640       }
2641     }
2642 
2643     llvm::SmallPtrSet<QualType, 4> UninitializedBaseClasses;
2644     for (auto I : RD->bases())
2645       UninitializedBaseClasses.insert(I.getType().getCanonicalType());
2646 
2647     if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
2648       return;
2649 
2650     UninitializedFieldVisitor UninitializedChecker(SemaRef,
2651                                                    UninitializedFields,
2652                                                    UninitializedBaseClasses);
2653 
2654     for (const auto *FieldInit : Constructor->inits()) {
2655       if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
2656         break;
2657 
2658       Expr *InitExpr = FieldInit->getInit();
2659       if (!InitExpr)
2660         continue;
2661 
2662       if (CXXDefaultInitExpr *Default =
2663               dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
2664         InitExpr = Default->getExpr();
2665         if (!InitExpr)
2666           continue;
2667         // In class initializers will point to the constructor.
2668         UninitializedChecker.CheckInitializer(InitExpr, Constructor,
2669                                               FieldInit->getAnyMember(),
2670                                               FieldInit->getBaseClass());
2671       } else {
2672         UninitializedChecker.CheckInitializer(InitExpr, nullptr,
2673                                               FieldInit->getAnyMember(),
2674                                               FieldInit->getBaseClass());
2675       }
2676     }
2677   }
2678 } // namespace
2679 
2680 /// \brief Enter a new C++ default initializer scope. After calling this, the
2681 /// caller must call \ref ActOnFinishCXXInClassMemberInitializer, even if
2682 /// parsing or instantiating the initializer failed.
ActOnStartCXXInClassMemberInitializer()2683 void Sema::ActOnStartCXXInClassMemberInitializer() {
2684   // Create a synthetic function scope to represent the call to the constructor
2685   // that notionally surrounds a use of this initializer.
2686   PushFunctionScope();
2687 }
2688 
2689 /// \brief This is invoked after parsing an in-class initializer for a
2690 /// non-static C++ class member, and after instantiating an in-class initializer
2691 /// in a class template. Such actions are deferred until the class is complete.
ActOnFinishCXXInClassMemberInitializer(Decl * D,SourceLocation InitLoc,Expr * InitExpr)2692 void Sema::ActOnFinishCXXInClassMemberInitializer(Decl *D,
2693                                                   SourceLocation InitLoc,
2694                                                   Expr *InitExpr) {
2695   // Pop the notional constructor scope we created earlier.
2696   PopFunctionScopeInfo(nullptr, D);
2697 
2698   FieldDecl *FD = dyn_cast<FieldDecl>(D);
2699   assert((isa<MSPropertyDecl>(D) || FD->getInClassInitStyle() != ICIS_NoInit) &&
2700          "must set init style when field is created");
2701 
2702   if (!InitExpr) {
2703     D->setInvalidDecl();
2704     if (FD)
2705       FD->removeInClassInitializer();
2706     return;
2707   }
2708 
2709   if (DiagnoseUnexpandedParameterPack(InitExpr, UPPC_Initializer)) {
2710     FD->setInvalidDecl();
2711     FD->removeInClassInitializer();
2712     return;
2713   }
2714 
2715   ExprResult Init = InitExpr;
2716   if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent()) {
2717     InitializedEntity Entity = InitializedEntity::InitializeMember(FD);
2718     InitializationKind Kind = FD->getInClassInitStyle() == ICIS_ListInit
2719         ? InitializationKind::CreateDirectList(InitExpr->getLocStart())
2720         : InitializationKind::CreateCopy(InitExpr->getLocStart(), InitLoc);
2721     InitializationSequence Seq(*this, Entity, Kind, InitExpr);
2722     Init = Seq.Perform(*this, Entity, Kind, InitExpr);
2723     if (Init.isInvalid()) {
2724       FD->setInvalidDecl();
2725       return;
2726     }
2727   }
2728 
2729   // C++11 [class.base.init]p7:
2730   //   The initialization of each base and member constitutes a
2731   //   full-expression.
2732   Init = ActOnFinishFullExpr(Init.get(), InitLoc);
2733   if (Init.isInvalid()) {
2734     FD->setInvalidDecl();
2735     return;
2736   }
2737 
2738   InitExpr = Init.get();
2739 
2740   FD->setInClassInitializer(InitExpr);
2741 }
2742 
2743 /// \brief Find the direct and/or virtual base specifiers that
2744 /// correspond to the given base type, for use in base initialization
2745 /// within a constructor.
FindBaseInitializer(Sema & SemaRef,CXXRecordDecl * ClassDecl,QualType BaseType,const CXXBaseSpecifier * & DirectBaseSpec,const CXXBaseSpecifier * & VirtualBaseSpec)2746 static bool FindBaseInitializer(Sema &SemaRef,
2747                                 CXXRecordDecl *ClassDecl,
2748                                 QualType BaseType,
2749                                 const CXXBaseSpecifier *&DirectBaseSpec,
2750                                 const CXXBaseSpecifier *&VirtualBaseSpec) {
2751   // First, check for a direct base class.
2752   DirectBaseSpec = nullptr;
2753   for (const auto &Base : ClassDecl->bases()) {
2754     if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base.getType())) {
2755       // We found a direct base of this type. That's what we're
2756       // initializing.
2757       DirectBaseSpec = &Base;
2758       break;
2759     }
2760   }
2761 
2762   // Check for a virtual base class.
2763   // FIXME: We might be able to short-circuit this if we know in advance that
2764   // there are no virtual bases.
2765   VirtualBaseSpec = nullptr;
2766   if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
2767     // We haven't found a base yet; search the class hierarchy for a
2768     // virtual base class.
2769     CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2770                        /*DetectVirtual=*/false);
2771     if (SemaRef.IsDerivedFrom(ClassDecl->getLocation(),
2772                               SemaRef.Context.getTypeDeclType(ClassDecl),
2773                               BaseType, Paths)) {
2774       for (CXXBasePaths::paths_iterator Path = Paths.begin();
2775            Path != Paths.end(); ++Path) {
2776         if (Path->back().Base->isVirtual()) {
2777           VirtualBaseSpec = Path->back().Base;
2778           break;
2779         }
2780       }
2781     }
2782   }
2783 
2784   return DirectBaseSpec || VirtualBaseSpec;
2785 }
2786 
2787 /// \brief Handle a C++ member initializer using braced-init-list syntax.
2788 MemInitResult
ActOnMemInitializer(Decl * ConstructorD,Scope * S,CXXScopeSpec & SS,IdentifierInfo * MemberOrBase,ParsedType TemplateTypeTy,const DeclSpec & DS,SourceLocation IdLoc,Expr * InitList,SourceLocation EllipsisLoc)2789 Sema::ActOnMemInitializer(Decl *ConstructorD,
2790                           Scope *S,
2791                           CXXScopeSpec &SS,
2792                           IdentifierInfo *MemberOrBase,
2793                           ParsedType TemplateTypeTy,
2794                           const DeclSpec &DS,
2795                           SourceLocation IdLoc,
2796                           Expr *InitList,
2797                           SourceLocation EllipsisLoc) {
2798   return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
2799                              DS, IdLoc, InitList,
2800                              EllipsisLoc);
2801 }
2802 
2803 /// \brief Handle a C++ member initializer using parentheses syntax.
2804 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)2805 Sema::ActOnMemInitializer(Decl *ConstructorD,
2806                           Scope *S,
2807                           CXXScopeSpec &SS,
2808                           IdentifierInfo *MemberOrBase,
2809                           ParsedType TemplateTypeTy,
2810                           const DeclSpec &DS,
2811                           SourceLocation IdLoc,
2812                           SourceLocation LParenLoc,
2813                           ArrayRef<Expr *> Args,
2814                           SourceLocation RParenLoc,
2815                           SourceLocation EllipsisLoc) {
2816   Expr *List = new (Context) ParenListExpr(Context, LParenLoc,
2817                                            Args, RParenLoc);
2818   return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
2819                              DS, IdLoc, List, EllipsisLoc);
2820 }
2821 
2822 namespace {
2823 
2824 // Callback to only accept typo corrections that can be a valid C++ member
2825 // intializer: either a non-static field member or a base class.
2826 class MemInitializerValidatorCCC : public CorrectionCandidateCallback {
2827 public:
MemInitializerValidatorCCC(CXXRecordDecl * ClassDecl)2828   explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl)
2829       : ClassDecl(ClassDecl) {}
2830 
ValidateCandidate(const TypoCorrection & candidate)2831   bool ValidateCandidate(const TypoCorrection &candidate) override {
2832     if (NamedDecl *ND = candidate.getCorrectionDecl()) {
2833       if (FieldDecl *Member = dyn_cast<FieldDecl>(ND))
2834         return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
2835       return isa<TypeDecl>(ND);
2836     }
2837     return false;
2838   }
2839 
2840 private:
2841   CXXRecordDecl *ClassDecl;
2842 };
2843 
2844 }
2845 
2846 /// \brief Handle a C++ member initializer.
2847 MemInitResult
BuildMemInitializer(Decl * ConstructorD,Scope * S,CXXScopeSpec & SS,IdentifierInfo * MemberOrBase,ParsedType TemplateTypeTy,const DeclSpec & DS,SourceLocation IdLoc,Expr * Init,SourceLocation EllipsisLoc)2848 Sema::BuildMemInitializer(Decl *ConstructorD,
2849                           Scope *S,
2850                           CXXScopeSpec &SS,
2851                           IdentifierInfo *MemberOrBase,
2852                           ParsedType TemplateTypeTy,
2853                           const DeclSpec &DS,
2854                           SourceLocation IdLoc,
2855                           Expr *Init,
2856                           SourceLocation EllipsisLoc) {
2857   ExprResult Res = CorrectDelayedTyposInExpr(Init);
2858   if (!Res.isUsable())
2859     return true;
2860   Init = Res.get();
2861 
2862   if (!ConstructorD)
2863     return true;
2864 
2865   AdjustDeclIfTemplate(ConstructorD);
2866 
2867   CXXConstructorDecl *Constructor
2868     = dyn_cast<CXXConstructorDecl>(ConstructorD);
2869   if (!Constructor) {
2870     // The user wrote a constructor initializer on a function that is
2871     // not a C++ constructor. Ignore the error for now, because we may
2872     // have more member initializers coming; we'll diagnose it just
2873     // once in ActOnMemInitializers.
2874     return true;
2875   }
2876 
2877   CXXRecordDecl *ClassDecl = Constructor->getParent();
2878 
2879   // C++ [class.base.init]p2:
2880   //   Names in a mem-initializer-id are looked up in the scope of the
2881   //   constructor's class and, if not found in that scope, are looked
2882   //   up in the scope containing the constructor's definition.
2883   //   [Note: if the constructor's class contains a member with the
2884   //   same name as a direct or virtual base class of the class, a
2885   //   mem-initializer-id naming the member or base class and composed
2886   //   of a single identifier refers to the class member. A
2887   //   mem-initializer-id for the hidden base class may be specified
2888   //   using a qualified name. ]
2889   if (!SS.getScopeRep() && !TemplateTypeTy) {
2890     // Look for a member, first.
2891     DeclContext::lookup_result Result = ClassDecl->lookup(MemberOrBase);
2892     if (!Result.empty()) {
2893       ValueDecl *Member;
2894       if ((Member = dyn_cast<FieldDecl>(Result.front())) ||
2895           (Member = dyn_cast<IndirectFieldDecl>(Result.front()))) {
2896         if (EllipsisLoc.isValid())
2897           Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
2898             << MemberOrBase
2899             << SourceRange(IdLoc, Init->getSourceRange().getEnd());
2900 
2901         return BuildMemberInitializer(Member, Init, IdLoc);
2902       }
2903     }
2904   }
2905   // It didn't name a member, so see if it names a class.
2906   QualType BaseType;
2907   TypeSourceInfo *TInfo = nullptr;
2908 
2909   if (TemplateTypeTy) {
2910     BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
2911   } else if (DS.getTypeSpecType() == TST_decltype) {
2912     BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
2913   } else {
2914     LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
2915     LookupParsedName(R, S, &SS);
2916 
2917     TypeDecl *TyD = R.getAsSingle<TypeDecl>();
2918     if (!TyD) {
2919       if (R.isAmbiguous()) return true;
2920 
2921       // We don't want access-control diagnostics here.
2922       R.suppressDiagnostics();
2923 
2924       if (SS.isSet() && isDependentScopeSpecifier(SS)) {
2925         bool NotUnknownSpecialization = false;
2926         DeclContext *DC = computeDeclContext(SS, false);
2927         if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
2928           NotUnknownSpecialization = !Record->hasAnyDependentBases();
2929 
2930         if (!NotUnknownSpecialization) {
2931           // When the scope specifier can refer to a member of an unknown
2932           // specialization, we take it as a type name.
2933           BaseType = CheckTypenameType(ETK_None, SourceLocation(),
2934                                        SS.getWithLocInContext(Context),
2935                                        *MemberOrBase, IdLoc);
2936           if (BaseType.isNull())
2937             return true;
2938 
2939           R.clear();
2940           R.setLookupName(MemberOrBase);
2941         }
2942       }
2943 
2944       // If no results were found, try to correct typos.
2945       TypoCorrection Corr;
2946       if (R.empty() && BaseType.isNull() &&
2947           (Corr = CorrectTypo(
2948                R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
2949                llvm::make_unique<MemInitializerValidatorCCC>(ClassDecl),
2950                CTK_ErrorRecovery, ClassDecl))) {
2951         if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
2952           // We have found a non-static data member with a similar
2953           // name to what was typed; complain and initialize that
2954           // member.
2955           diagnoseTypo(Corr,
2956                        PDiag(diag::err_mem_init_not_member_or_class_suggest)
2957                          << MemberOrBase << true);
2958           return BuildMemberInitializer(Member, Init, IdLoc);
2959         } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
2960           const CXXBaseSpecifier *DirectBaseSpec;
2961           const CXXBaseSpecifier *VirtualBaseSpec;
2962           if (FindBaseInitializer(*this, ClassDecl,
2963                                   Context.getTypeDeclType(Type),
2964                                   DirectBaseSpec, VirtualBaseSpec)) {
2965             // We have found a direct or virtual base class with a
2966             // similar name to what was typed; complain and initialize
2967             // that base class.
2968             diagnoseTypo(Corr,
2969                          PDiag(diag::err_mem_init_not_member_or_class_suggest)
2970                            << MemberOrBase << false,
2971                          PDiag() /*Suppress note, we provide our own.*/);
2972 
2973             const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
2974                                                               : VirtualBaseSpec;
2975             Diag(BaseSpec->getLocStart(),
2976                  diag::note_base_class_specified_here)
2977               << BaseSpec->getType()
2978               << BaseSpec->getSourceRange();
2979 
2980             TyD = Type;
2981           }
2982         }
2983       }
2984 
2985       if (!TyD && BaseType.isNull()) {
2986         Diag(IdLoc, diag::err_mem_init_not_member_or_class)
2987           << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
2988         return true;
2989       }
2990     }
2991 
2992     if (BaseType.isNull()) {
2993       BaseType = Context.getTypeDeclType(TyD);
2994       MarkAnyDeclReferenced(TyD->getLocation(), TyD, /*OdrUse=*/false);
2995       if (SS.isSet()) {
2996         BaseType = Context.getElaboratedType(ETK_None, SS.getScopeRep(),
2997                                              BaseType);
2998         TInfo = Context.CreateTypeSourceInfo(BaseType);
2999         ElaboratedTypeLoc TL = TInfo->getTypeLoc().castAs<ElaboratedTypeLoc>();
3000         TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
3001         TL.setElaboratedKeywordLoc(SourceLocation());
3002         TL.setQualifierLoc(SS.getWithLocInContext(Context));
3003       }
3004     }
3005   }
3006 
3007   if (!TInfo)
3008     TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
3009 
3010   return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc);
3011 }
3012 
3013 /// Checks a member initializer expression for cases where reference (or
3014 /// pointer) members are bound to by-value parameters (or their addresses).
CheckForDanglingReferenceOrPointer(Sema & S,ValueDecl * Member,Expr * Init,SourceLocation IdLoc)3015 static void CheckForDanglingReferenceOrPointer(Sema &S, ValueDecl *Member,
3016                                                Expr *Init,
3017                                                SourceLocation IdLoc) {
3018   QualType MemberTy = Member->getType();
3019 
3020   // We only handle pointers and references currently.
3021   // FIXME: Would this be relevant for ObjC object pointers? Or block pointers?
3022   if (!MemberTy->isReferenceType() && !MemberTy->isPointerType())
3023     return;
3024 
3025   const bool IsPointer = MemberTy->isPointerType();
3026   if (IsPointer) {
3027     if (const UnaryOperator *Op
3028           = dyn_cast<UnaryOperator>(Init->IgnoreParenImpCasts())) {
3029       // The only case we're worried about with pointers requires taking the
3030       // address.
3031       if (Op->getOpcode() != UO_AddrOf)
3032         return;
3033 
3034       Init = Op->getSubExpr();
3035     } else {
3036       // We only handle address-of expression initializers for pointers.
3037       return;
3038     }
3039   }
3040 
3041   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Init->IgnoreParens())) {
3042     // We only warn when referring to a non-reference parameter declaration.
3043     const ParmVarDecl *Parameter = dyn_cast<ParmVarDecl>(DRE->getDecl());
3044     if (!Parameter || Parameter->getType()->isReferenceType())
3045       return;
3046 
3047     S.Diag(Init->getExprLoc(),
3048            IsPointer ? diag::warn_init_ptr_member_to_parameter_addr
3049                      : diag::warn_bind_ref_member_to_parameter)
3050       << Member << Parameter << Init->getSourceRange();
3051   } else {
3052     // Other initializers are fine.
3053     return;
3054   }
3055 
3056   S.Diag(Member->getLocation(), diag::note_ref_or_ptr_member_declared_here)
3057     << (unsigned)IsPointer;
3058 }
3059 
3060 MemInitResult
BuildMemberInitializer(ValueDecl * Member,Expr * Init,SourceLocation IdLoc)3061 Sema::BuildMemberInitializer(ValueDecl *Member, Expr *Init,
3062                              SourceLocation IdLoc) {
3063   FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member);
3064   IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member);
3065   assert((DirectMember || IndirectMember) &&
3066          "Member must be a FieldDecl or IndirectFieldDecl");
3067 
3068   if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
3069     return true;
3070 
3071   if (Member->isInvalidDecl())
3072     return true;
3073 
3074   MultiExprArg Args;
3075   if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
3076     Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
3077   } else if (InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
3078     Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
3079   } else {
3080     // Template instantiation doesn't reconstruct ParenListExprs for us.
3081     Args = Init;
3082   }
3083 
3084   SourceRange InitRange = Init->getSourceRange();
3085 
3086   if (Member->getType()->isDependentType() || Init->isTypeDependent()) {
3087     // Can't check initialization for a member of dependent type or when
3088     // any of the arguments are type-dependent expressions.
3089     DiscardCleanupsInEvaluationContext();
3090   } else {
3091     bool InitList = false;
3092     if (isa<InitListExpr>(Init)) {
3093       InitList = true;
3094       Args = Init;
3095     }
3096 
3097     // Initialize the member.
3098     InitializedEntity MemberEntity =
3099       DirectMember ? InitializedEntity::InitializeMember(DirectMember, nullptr)
3100                    : InitializedEntity::InitializeMember(IndirectMember,
3101                                                          nullptr);
3102     InitializationKind Kind =
3103       InitList ? InitializationKind::CreateDirectList(IdLoc)
3104                : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(),
3105                                                   InitRange.getEnd());
3106 
3107     InitializationSequence InitSeq(*this, MemberEntity, Kind, Args);
3108     ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind, Args,
3109                                             nullptr);
3110     if (MemberInit.isInvalid())
3111       return true;
3112 
3113     CheckForDanglingReferenceOrPointer(*this, Member, MemberInit.get(), IdLoc);
3114 
3115     // C++11 [class.base.init]p7:
3116     //   The initialization of each base and member constitutes a
3117     //   full-expression.
3118     MemberInit = ActOnFinishFullExpr(MemberInit.get(), InitRange.getBegin());
3119     if (MemberInit.isInvalid())
3120       return true;
3121 
3122     Init = MemberInit.get();
3123   }
3124 
3125   if (DirectMember) {
3126     return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc,
3127                                             InitRange.getBegin(), Init,
3128                                             InitRange.getEnd());
3129   } else {
3130     return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc,
3131                                             InitRange.getBegin(), Init,
3132                                             InitRange.getEnd());
3133   }
3134 }
3135 
3136 MemInitResult
BuildDelegatingInitializer(TypeSourceInfo * TInfo,Expr * Init,CXXRecordDecl * ClassDecl)3137 Sema::BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init,
3138                                  CXXRecordDecl *ClassDecl) {
3139   SourceLocation NameLoc = TInfo->getTypeLoc().getLocalSourceRange().getBegin();
3140   if (!LangOpts.CPlusPlus11)
3141     return Diag(NameLoc, diag::err_delegating_ctor)
3142       << TInfo->getTypeLoc().getLocalSourceRange();
3143   Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
3144 
3145   bool InitList = true;
3146   MultiExprArg Args = Init;
3147   if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
3148     InitList = false;
3149     Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
3150   }
3151 
3152   SourceRange InitRange = Init->getSourceRange();
3153   // Initialize the object.
3154   InitializedEntity DelegationEntity = InitializedEntity::InitializeDelegation(
3155                                      QualType(ClassDecl->getTypeForDecl(), 0));
3156   InitializationKind Kind =
3157     InitList ? InitializationKind::CreateDirectList(NameLoc)
3158              : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(),
3159                                                 InitRange.getEnd());
3160   InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args);
3161   ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind,
3162                                               Args, nullptr);
3163   if (DelegationInit.isInvalid())
3164     return true;
3165 
3166   assert(cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() &&
3167          "Delegating constructor with no target?");
3168 
3169   // C++11 [class.base.init]p7:
3170   //   The initialization of each base and member constitutes a
3171   //   full-expression.
3172   DelegationInit = ActOnFinishFullExpr(DelegationInit.get(),
3173                                        InitRange.getBegin());
3174   if (DelegationInit.isInvalid())
3175     return true;
3176 
3177   // If we are in a dependent context, template instantiation will
3178   // perform this type-checking again. Just save the arguments that we
3179   // received in a ParenListExpr.
3180   // FIXME: This isn't quite ideal, since our ASTs don't capture all
3181   // of the information that we have about the base
3182   // initializer. However, deconstructing the ASTs is a dicey process,
3183   // and this approach is far more likely to get the corner cases right.
3184   if (CurContext->isDependentContext())
3185     DelegationInit = Init;
3186 
3187   return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(),
3188                                           DelegationInit.getAs<Expr>(),
3189                                           InitRange.getEnd());
3190 }
3191 
3192 MemInitResult
BuildBaseInitializer(QualType BaseType,TypeSourceInfo * BaseTInfo,Expr * Init,CXXRecordDecl * ClassDecl,SourceLocation EllipsisLoc)3193 Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo,
3194                            Expr *Init, CXXRecordDecl *ClassDecl,
3195                            SourceLocation EllipsisLoc) {
3196   SourceLocation BaseLoc
3197     = BaseTInfo->getTypeLoc().getLocalSourceRange().getBegin();
3198 
3199   if (!BaseType->isDependentType() && !BaseType->isRecordType())
3200     return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
3201              << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
3202 
3203   // C++ [class.base.init]p2:
3204   //   [...] Unless the mem-initializer-id names a nonstatic data
3205   //   member of the constructor's class or a direct or virtual base
3206   //   of that class, the mem-initializer is ill-formed. A
3207   //   mem-initializer-list can initialize a base class using any
3208   //   name that denotes that base class type.
3209   bool Dependent = BaseType->isDependentType() || Init->isTypeDependent();
3210 
3211   SourceRange InitRange = Init->getSourceRange();
3212   if (EllipsisLoc.isValid()) {
3213     // This is a pack expansion.
3214     if (!BaseType->containsUnexpandedParameterPack())  {
3215       Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
3216         << SourceRange(BaseLoc, InitRange.getEnd());
3217 
3218       EllipsisLoc = SourceLocation();
3219     }
3220   } else {
3221     // Check for any unexpanded parameter packs.
3222     if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer))
3223       return true;
3224 
3225     if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
3226       return true;
3227   }
3228 
3229   // Check for direct and virtual base classes.
3230   const CXXBaseSpecifier *DirectBaseSpec = nullptr;
3231   const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
3232   if (!Dependent) {
3233     if (Context.hasSameUnqualifiedType(QualType(ClassDecl->getTypeForDecl(),0),
3234                                        BaseType))
3235       return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl);
3236 
3237     FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
3238                         VirtualBaseSpec);
3239 
3240     // C++ [base.class.init]p2:
3241     // Unless the mem-initializer-id names a nonstatic data member of the
3242     // constructor's class or a direct or virtual base of that class, the
3243     // mem-initializer is ill-formed.
3244     if (!DirectBaseSpec && !VirtualBaseSpec) {
3245       // If the class has any dependent bases, then it's possible that
3246       // one of those types will resolve to the same type as
3247       // BaseType. Therefore, just treat this as a dependent base
3248       // class initialization.  FIXME: Should we try to check the
3249       // initialization anyway? It seems odd.
3250       if (ClassDecl->hasAnyDependentBases())
3251         Dependent = true;
3252       else
3253         return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
3254           << BaseType << Context.getTypeDeclType(ClassDecl)
3255           << BaseTInfo->getTypeLoc().getLocalSourceRange();
3256     }
3257   }
3258 
3259   if (Dependent) {
3260     DiscardCleanupsInEvaluationContext();
3261 
3262     return new (Context) CXXCtorInitializer(Context, BaseTInfo,
3263                                             /*IsVirtual=*/false,
3264                                             InitRange.getBegin(), Init,
3265                                             InitRange.getEnd(), EllipsisLoc);
3266   }
3267 
3268   // C++ [base.class.init]p2:
3269   //   If a mem-initializer-id is ambiguous because it designates both
3270   //   a direct non-virtual base class and an inherited virtual base
3271   //   class, the mem-initializer is ill-formed.
3272   if (DirectBaseSpec && VirtualBaseSpec)
3273     return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
3274       << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
3275 
3276   const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
3277   if (!BaseSpec)
3278     BaseSpec = VirtualBaseSpec;
3279 
3280   // Initialize the base.
3281   bool InitList = true;
3282   MultiExprArg Args = Init;
3283   if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
3284     InitList = false;
3285     Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
3286   }
3287 
3288   InitializedEntity BaseEntity =
3289     InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec);
3290   InitializationKind Kind =
3291     InitList ? InitializationKind::CreateDirectList(BaseLoc)
3292              : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(),
3293                                                 InitRange.getEnd());
3294   InitializationSequence InitSeq(*this, BaseEntity, Kind, Args);
3295   ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind, Args, nullptr);
3296   if (BaseInit.isInvalid())
3297     return true;
3298 
3299   // C++11 [class.base.init]p7:
3300   //   The initialization of each base and member constitutes a
3301   //   full-expression.
3302   BaseInit = ActOnFinishFullExpr(BaseInit.get(), InitRange.getBegin());
3303   if (BaseInit.isInvalid())
3304     return true;
3305 
3306   // If we are in a dependent context, template instantiation will
3307   // perform this type-checking again. Just save the arguments that we
3308   // received in a ParenListExpr.
3309   // FIXME: This isn't quite ideal, since our ASTs don't capture all
3310   // of the information that we have about the base
3311   // initializer. However, deconstructing the ASTs is a dicey process,
3312   // and this approach is far more likely to get the corner cases right.
3313   if (CurContext->isDependentContext())
3314     BaseInit = Init;
3315 
3316   return new (Context) CXXCtorInitializer(Context, BaseTInfo,
3317                                           BaseSpec->isVirtual(),
3318                                           InitRange.getBegin(),
3319                                           BaseInit.getAs<Expr>(),
3320                                           InitRange.getEnd(), EllipsisLoc);
3321 }
3322 
3323 // Create a static_cast\<T&&>(expr).
CastForMoving(Sema & SemaRef,Expr * E,QualType T=QualType ())3324 static Expr *CastForMoving(Sema &SemaRef, Expr *E, QualType T = QualType()) {
3325   if (T.isNull()) T = E->getType();
3326   QualType TargetType = SemaRef.BuildReferenceType(
3327       T, /*SpelledAsLValue*/false, SourceLocation(), DeclarationName());
3328   SourceLocation ExprLoc = E->getLocStart();
3329   TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo(
3330       TargetType, ExprLoc);
3331 
3332   return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
3333                                    SourceRange(ExprLoc, ExprLoc),
3334                                    E->getSourceRange()).get();
3335 }
3336 
3337 /// ImplicitInitializerKind - How an implicit base or member initializer should
3338 /// initialize its base or member.
3339 enum ImplicitInitializerKind {
3340   IIK_Default,
3341   IIK_Copy,
3342   IIK_Move,
3343   IIK_Inherit
3344 };
3345 
3346 static bool
BuildImplicitBaseInitializer(Sema & SemaRef,CXXConstructorDecl * Constructor,ImplicitInitializerKind ImplicitInitKind,CXXBaseSpecifier * BaseSpec,bool IsInheritedVirtualBase,CXXCtorInitializer * & CXXBaseInit)3347 BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor,
3348                              ImplicitInitializerKind ImplicitInitKind,
3349                              CXXBaseSpecifier *BaseSpec,
3350                              bool IsInheritedVirtualBase,
3351                              CXXCtorInitializer *&CXXBaseInit) {
3352   InitializedEntity InitEntity
3353     = InitializedEntity::InitializeBase(SemaRef.Context, BaseSpec,
3354                                         IsInheritedVirtualBase);
3355 
3356   ExprResult BaseInit;
3357 
3358   switch (ImplicitInitKind) {
3359   case IIK_Inherit:
3360   case IIK_Default: {
3361     InitializationKind InitKind
3362       = InitializationKind::CreateDefault(Constructor->getLocation());
3363     InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
3364     BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
3365     break;
3366   }
3367 
3368   case IIK_Move:
3369   case IIK_Copy: {
3370     bool Moving = ImplicitInitKind == IIK_Move;
3371     ParmVarDecl *Param = Constructor->getParamDecl(0);
3372     QualType ParamType = Param->getType().getNonReferenceType();
3373 
3374     Expr *CopyCtorArg =
3375       DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(),
3376                           SourceLocation(), Param, false,
3377                           Constructor->getLocation(), ParamType,
3378                           VK_LValue, nullptr);
3379 
3380     SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg));
3381 
3382     // Cast to the base class to avoid ambiguities.
3383     QualType ArgTy =
3384       SemaRef.Context.getQualifiedType(BaseSpec->getType().getUnqualifiedType(),
3385                                        ParamType.getQualifiers());
3386 
3387     if (Moving) {
3388       CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg);
3389     }
3390 
3391     CXXCastPath BasePath;
3392     BasePath.push_back(BaseSpec);
3393     CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy,
3394                                             CK_UncheckedDerivedToBase,
3395                                             Moving ? VK_XValue : VK_LValue,
3396                                             &BasePath).get();
3397 
3398     InitializationKind InitKind
3399       = InitializationKind::CreateDirect(Constructor->getLocation(),
3400                                          SourceLocation(), SourceLocation());
3401     InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, CopyCtorArg);
3402     BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, CopyCtorArg);
3403     break;
3404   }
3405   }
3406 
3407   BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit);
3408   if (BaseInit.isInvalid())
3409     return true;
3410 
3411   CXXBaseInit =
3412     new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
3413                SemaRef.Context.getTrivialTypeSourceInfo(BaseSpec->getType(),
3414                                                         SourceLocation()),
3415                                              BaseSpec->isVirtual(),
3416                                              SourceLocation(),
3417                                              BaseInit.getAs<Expr>(),
3418                                              SourceLocation(),
3419                                              SourceLocation());
3420 
3421   return false;
3422 }
3423 
RefersToRValueRef(Expr * MemRef)3424 static bool RefersToRValueRef(Expr *MemRef) {
3425   ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
3426   return Referenced->getType()->isRValueReferenceType();
3427 }
3428 
3429 static bool
BuildImplicitMemberInitializer(Sema & SemaRef,CXXConstructorDecl * Constructor,ImplicitInitializerKind ImplicitInitKind,FieldDecl * Field,IndirectFieldDecl * Indirect,CXXCtorInitializer * & CXXMemberInit)3430 BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor,
3431                                ImplicitInitializerKind ImplicitInitKind,
3432                                FieldDecl *Field, IndirectFieldDecl *Indirect,
3433                                CXXCtorInitializer *&CXXMemberInit) {
3434   if (Field->isInvalidDecl())
3435     return true;
3436 
3437   SourceLocation Loc = Constructor->getLocation();
3438 
3439   if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) {
3440     bool Moving = ImplicitInitKind == IIK_Move;
3441     ParmVarDecl *Param = Constructor->getParamDecl(0);
3442     QualType ParamType = Param->getType().getNonReferenceType();
3443 
3444     // Suppress copying zero-width bitfields.
3445     if (Field->isBitField() && Field->getBitWidthValue(SemaRef.Context) == 0)
3446       return false;
3447 
3448     Expr *MemberExprBase =
3449       DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(),
3450                           SourceLocation(), Param, false,
3451                           Loc, ParamType, VK_LValue, nullptr);
3452 
3453     SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase));
3454 
3455     if (Moving) {
3456       MemberExprBase = CastForMoving(SemaRef, MemberExprBase);
3457     }
3458 
3459     // Build a reference to this field within the parameter.
3460     CXXScopeSpec SS;
3461     LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
3462                               Sema::LookupMemberName);
3463     MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect)
3464                                   : cast<ValueDecl>(Field), AS_public);
3465     MemberLookup.resolveKind();
3466     ExprResult CtorArg
3467       = SemaRef.BuildMemberReferenceExpr(MemberExprBase,
3468                                          ParamType, Loc,
3469                                          /*IsArrow=*/false,
3470                                          SS,
3471                                          /*TemplateKWLoc=*/SourceLocation(),
3472                                          /*FirstQualifierInScope=*/nullptr,
3473                                          MemberLookup,
3474                                          /*TemplateArgs=*/nullptr,
3475                                          /*S*/nullptr);
3476     if (CtorArg.isInvalid())
3477       return true;
3478 
3479     // C++11 [class.copy]p15:
3480     //   - if a member m has rvalue reference type T&&, it is direct-initialized
3481     //     with static_cast<T&&>(x.m);
3482     if (RefersToRValueRef(CtorArg.get())) {
3483       CtorArg = CastForMoving(SemaRef, CtorArg.get());
3484     }
3485 
3486     // When the field we are copying is an array, create index variables for
3487     // each dimension of the array. We use these index variables to subscript
3488     // the source array, and other clients (e.g., CodeGen) will perform the
3489     // necessary iteration with these index variables.
3490     SmallVector<VarDecl *, 4> IndexVariables;
3491     QualType BaseType = Field->getType();
3492     QualType SizeType = SemaRef.Context.getSizeType();
3493     bool InitializingArray = false;
3494     while (const ConstantArrayType *Array
3495                           = SemaRef.Context.getAsConstantArrayType(BaseType)) {
3496       InitializingArray = true;
3497       // Create the iteration variable for this array index.
3498       IdentifierInfo *IterationVarName = nullptr;
3499       {
3500         SmallString<8> Str;
3501         llvm::raw_svector_ostream OS(Str);
3502         OS << "__i" << IndexVariables.size();
3503         IterationVarName = &SemaRef.Context.Idents.get(OS.str());
3504       }
3505       VarDecl *IterationVar
3506         = VarDecl::Create(SemaRef.Context, SemaRef.CurContext, Loc, Loc,
3507                           IterationVarName, SizeType,
3508                         SemaRef.Context.getTrivialTypeSourceInfo(SizeType, Loc),
3509                           SC_None);
3510       IndexVariables.push_back(IterationVar);
3511 
3512       // Create a reference to the iteration variable.
3513       ExprResult IterationVarRef
3514         = SemaRef.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc);
3515       assert(!IterationVarRef.isInvalid() &&
3516              "Reference to invented variable cannot fail!");
3517       IterationVarRef = SemaRef.DefaultLvalueConversion(IterationVarRef.get());
3518       assert(!IterationVarRef.isInvalid() &&
3519              "Conversion of invented variable cannot fail!");
3520 
3521       // Subscript the array with this iteration variable.
3522       CtorArg = SemaRef.CreateBuiltinArraySubscriptExpr(CtorArg.get(), Loc,
3523                                                         IterationVarRef.get(),
3524                                                         Loc);
3525       if (CtorArg.isInvalid())
3526         return true;
3527 
3528       BaseType = Array->getElementType();
3529     }
3530 
3531     // The array subscript expression is an lvalue, which is wrong for moving.
3532     if (Moving && InitializingArray)
3533       CtorArg = CastForMoving(SemaRef, CtorArg.get());
3534 
3535     // Construct the entity that we will be initializing. For an array, this
3536     // will be first element in the array, which may require several levels
3537     // of array-subscript entities.
3538     SmallVector<InitializedEntity, 4> Entities;
3539     Entities.reserve(1 + IndexVariables.size());
3540     if (Indirect)
3541       Entities.push_back(InitializedEntity::InitializeMember(Indirect));
3542     else
3543       Entities.push_back(InitializedEntity::InitializeMember(Field));
3544     for (unsigned I = 0, N = IndexVariables.size(); I != N; ++I)
3545       Entities.push_back(InitializedEntity::InitializeElement(SemaRef.Context,
3546                                                               0,
3547                                                               Entities.back()));
3548 
3549     // Direct-initialize to use the copy constructor.
3550     InitializationKind InitKind =
3551       InitializationKind::CreateDirect(Loc, SourceLocation(), SourceLocation());
3552 
3553     Expr *CtorArgE = CtorArg.getAs<Expr>();
3554     InitializationSequence InitSeq(SemaRef, Entities.back(), InitKind,
3555                                    CtorArgE);
3556 
3557     ExprResult MemberInit
3558       = InitSeq.Perform(SemaRef, Entities.back(), InitKind,
3559                         MultiExprArg(&CtorArgE, 1));
3560     MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
3561     if (MemberInit.isInvalid())
3562       return true;
3563 
3564     if (Indirect) {
3565       assert(IndexVariables.size() == 0 &&
3566              "Indirect field improperly initialized");
3567       CXXMemberInit
3568         = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Indirect,
3569                                                    Loc, Loc,
3570                                                    MemberInit.getAs<Expr>(),
3571                                                    Loc);
3572     } else
3573       CXXMemberInit = CXXCtorInitializer::Create(SemaRef.Context, Field, Loc,
3574                                                  Loc, MemberInit.getAs<Expr>(),
3575                                                  Loc,
3576                                                  IndexVariables.data(),
3577                                                  IndexVariables.size());
3578     return false;
3579   }
3580 
3581   assert((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) &&
3582          "Unhandled implicit init kind!");
3583 
3584   QualType FieldBaseElementType =
3585     SemaRef.Context.getBaseElementType(Field->getType());
3586 
3587   if (FieldBaseElementType->isRecordType()) {
3588     InitializedEntity InitEntity
3589       = Indirect? InitializedEntity::InitializeMember(Indirect)
3590                 : InitializedEntity::InitializeMember(Field);
3591     InitializationKind InitKind =
3592       InitializationKind::CreateDefault(Loc);
3593 
3594     InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
3595     ExprResult MemberInit =
3596       InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
3597 
3598     MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
3599     if (MemberInit.isInvalid())
3600       return true;
3601 
3602     if (Indirect)
3603       CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
3604                                                                Indirect, Loc,
3605                                                                Loc,
3606                                                                MemberInit.get(),
3607                                                                Loc);
3608     else
3609       CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
3610                                                                Field, Loc, Loc,
3611                                                                MemberInit.get(),
3612                                                                Loc);
3613     return false;
3614   }
3615 
3616   if (!Field->getParent()->isUnion()) {
3617     if (FieldBaseElementType->isReferenceType()) {
3618       SemaRef.Diag(Constructor->getLocation(),
3619                    diag::err_uninitialized_member_in_ctor)
3620       << (int)Constructor->isImplicit()
3621       << SemaRef.Context.getTagDeclType(Constructor->getParent())
3622       << 0 << Field->getDeclName();
3623       SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
3624       return true;
3625     }
3626 
3627     if (FieldBaseElementType.isConstQualified()) {
3628       SemaRef.Diag(Constructor->getLocation(),
3629                    diag::err_uninitialized_member_in_ctor)
3630       << (int)Constructor->isImplicit()
3631       << SemaRef.Context.getTagDeclType(Constructor->getParent())
3632       << 1 << Field->getDeclName();
3633       SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
3634       return true;
3635     }
3636   }
3637 
3638   if (SemaRef.getLangOpts().ObjCAutoRefCount &&
3639       FieldBaseElementType->isObjCRetainableType() &&
3640       FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_None &&
3641       FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_ExplicitNone) {
3642     // ARC:
3643     //   Default-initialize Objective-C pointers to NULL.
3644     CXXMemberInit
3645       = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
3646                                                  Loc, Loc,
3647                  new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()),
3648                                                  Loc);
3649     return false;
3650   }
3651 
3652   // Nothing to initialize.
3653   CXXMemberInit = nullptr;
3654   return false;
3655 }
3656 
3657 namespace {
3658 struct BaseAndFieldInfo {
3659   Sema &S;
3660   CXXConstructorDecl *Ctor;
3661   bool AnyErrorsInInits;
3662   ImplicitInitializerKind IIK;
3663   llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
3664   SmallVector<CXXCtorInitializer*, 8> AllToInit;
3665   llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
3666 
BaseAndFieldInfo__anon92980ac10411::BaseAndFieldInfo3667   BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits)
3668     : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
3669     bool Generated = Ctor->isImplicit() || Ctor->isDefaulted();
3670     if (Ctor->getInheritedConstructor())
3671       IIK = IIK_Inherit;
3672     else if (Generated && Ctor->isCopyConstructor())
3673       IIK = IIK_Copy;
3674     else if (Generated && Ctor->isMoveConstructor())
3675       IIK = IIK_Move;
3676     else
3677       IIK = IIK_Default;
3678   }
3679 
isImplicitCopyOrMove__anon92980ac10411::BaseAndFieldInfo3680   bool isImplicitCopyOrMove() const {
3681     switch (IIK) {
3682     case IIK_Copy:
3683     case IIK_Move:
3684       return true;
3685 
3686     case IIK_Default:
3687     case IIK_Inherit:
3688       return false;
3689     }
3690 
3691     llvm_unreachable("Invalid ImplicitInitializerKind!");
3692   }
3693 
addFieldInitializer__anon92980ac10411::BaseAndFieldInfo3694   bool addFieldInitializer(CXXCtorInitializer *Init) {
3695     AllToInit.push_back(Init);
3696 
3697     // Check whether this initializer makes the field "used".
3698     if (Init->getInit()->HasSideEffects(S.Context))
3699       S.UnusedPrivateFields.remove(Init->getAnyMember());
3700 
3701     return false;
3702   }
3703 
isInactiveUnionMember__anon92980ac10411::BaseAndFieldInfo3704   bool isInactiveUnionMember(FieldDecl *Field) {
3705     RecordDecl *Record = Field->getParent();
3706     if (!Record->isUnion())
3707       return false;
3708 
3709     if (FieldDecl *Active =
3710             ActiveUnionMember.lookup(Record->getCanonicalDecl()))
3711       return Active != Field->getCanonicalDecl();
3712 
3713     // In an implicit copy or move constructor, ignore any in-class initializer.
3714     if (isImplicitCopyOrMove())
3715       return true;
3716 
3717     // If there's no explicit initialization, the field is active only if it
3718     // has an in-class initializer...
3719     if (Field->hasInClassInitializer())
3720       return false;
3721     // ... or it's an anonymous struct or union whose class has an in-class
3722     // initializer.
3723     if (!Field->isAnonymousStructOrUnion())
3724       return true;
3725     CXXRecordDecl *FieldRD = Field->getType()->getAsCXXRecordDecl();
3726     return !FieldRD->hasInClassInitializer();
3727   }
3728 
3729   /// \brief Determine whether the given field is, or is within, a union member
3730   /// that is inactive (because there was an initializer given for a different
3731   /// member of the union, or because the union was not initialized at all).
isWithinInactiveUnionMember__anon92980ac10411::BaseAndFieldInfo3732   bool isWithinInactiveUnionMember(FieldDecl *Field,
3733                                    IndirectFieldDecl *Indirect) {
3734     if (!Indirect)
3735       return isInactiveUnionMember(Field);
3736 
3737     for (auto *C : Indirect->chain()) {
3738       FieldDecl *Field = dyn_cast<FieldDecl>(C);
3739       if (Field && isInactiveUnionMember(Field))
3740         return true;
3741     }
3742     return false;
3743   }
3744 };
3745 }
3746 
3747 /// \brief Determine whether the given type is an incomplete or zero-lenfgth
3748 /// array type.
isIncompleteOrZeroLengthArrayType(ASTContext & Context,QualType T)3749 static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T) {
3750   if (T->isIncompleteArrayType())
3751     return true;
3752 
3753   while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
3754     if (!ArrayT->getSize())
3755       return true;
3756 
3757     T = ArrayT->getElementType();
3758   }
3759 
3760   return false;
3761 }
3762 
CollectFieldInitializer(Sema & SemaRef,BaseAndFieldInfo & Info,FieldDecl * Field,IndirectFieldDecl * Indirect=nullptr)3763 static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
3764                                     FieldDecl *Field,
3765                                     IndirectFieldDecl *Indirect = nullptr) {
3766   if (Field->isInvalidDecl())
3767     return false;
3768 
3769   // Overwhelmingly common case: we have a direct initializer for this field.
3770   if (CXXCtorInitializer *Init =
3771           Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
3772     return Info.addFieldInitializer(Init);
3773 
3774   // C++11 [class.base.init]p8:
3775   //   if the entity is a non-static data member that has a
3776   //   brace-or-equal-initializer and either
3777   //   -- the constructor's class is a union and no other variant member of that
3778   //      union is designated by a mem-initializer-id or
3779   //   -- the constructor's class is not a union, and, if the entity is a member
3780   //      of an anonymous union, no other member of that union is designated by
3781   //      a mem-initializer-id,
3782   //   the entity is initialized as specified in [dcl.init].
3783   //
3784   // We also apply the same rules to handle anonymous structs within anonymous
3785   // unions.
3786   if (Info.isWithinInactiveUnionMember(Field, Indirect))
3787     return false;
3788 
3789   if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
3790     ExprResult DIE =
3791         SemaRef.BuildCXXDefaultInitExpr(Info.Ctor->getLocation(), Field);
3792     if (DIE.isInvalid())
3793       return true;
3794     CXXCtorInitializer *Init;
3795     if (Indirect)
3796       Init = new (SemaRef.Context)
3797           CXXCtorInitializer(SemaRef.Context, Indirect, SourceLocation(),
3798                              SourceLocation(), DIE.get(), SourceLocation());
3799     else
3800       Init = new (SemaRef.Context)
3801           CXXCtorInitializer(SemaRef.Context, Field, SourceLocation(),
3802                              SourceLocation(), DIE.get(), SourceLocation());
3803     return Info.addFieldInitializer(Init);
3804   }
3805 
3806   // Don't initialize incomplete or zero-length arrays.
3807   if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType()))
3808     return false;
3809 
3810   // Don't try to build an implicit initializer if there were semantic
3811   // errors in any of the initializers (and therefore we might be
3812   // missing some that the user actually wrote).
3813   if (Info.AnyErrorsInInits)
3814     return false;
3815 
3816   CXXCtorInitializer *Init = nullptr;
3817   if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field,
3818                                      Indirect, Init))
3819     return true;
3820 
3821   if (!Init)
3822     return false;
3823 
3824   return Info.addFieldInitializer(Init);
3825 }
3826 
3827 bool
SetDelegatingInitializer(CXXConstructorDecl * Constructor,CXXCtorInitializer * Initializer)3828 Sema::SetDelegatingInitializer(CXXConstructorDecl *Constructor,
3829                                CXXCtorInitializer *Initializer) {
3830   assert(Initializer->isDelegatingInitializer());
3831   Constructor->setNumCtorInitializers(1);
3832   CXXCtorInitializer **initializer =
3833     new (Context) CXXCtorInitializer*[1];
3834   memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*));
3835   Constructor->setCtorInitializers(initializer);
3836 
3837   if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) {
3838     MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor);
3839     DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation());
3840   }
3841 
3842   DelegatingCtorDecls.push_back(Constructor);
3843 
3844   DiagnoseUninitializedFields(*this, Constructor);
3845 
3846   return false;
3847 }
3848 
SetCtorInitializers(CXXConstructorDecl * Constructor,bool AnyErrors,ArrayRef<CXXCtorInitializer * > Initializers)3849 bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
3850                                ArrayRef<CXXCtorInitializer *> Initializers) {
3851   if (Constructor->isDependentContext()) {
3852     // Just store the initializers as written, they will be checked during
3853     // instantiation.
3854     if (!Initializers.empty()) {
3855       Constructor->setNumCtorInitializers(Initializers.size());
3856       CXXCtorInitializer **baseOrMemberInitializers =
3857         new (Context) CXXCtorInitializer*[Initializers.size()];
3858       memcpy(baseOrMemberInitializers, Initializers.data(),
3859              Initializers.size() * sizeof(CXXCtorInitializer*));
3860       Constructor->setCtorInitializers(baseOrMemberInitializers);
3861     }
3862 
3863     // Let template instantiation know whether we had errors.
3864     if (AnyErrors)
3865       Constructor->setInvalidDecl();
3866 
3867     return false;
3868   }
3869 
3870   BaseAndFieldInfo Info(*this, Constructor, AnyErrors);
3871 
3872   // We need to build the initializer AST according to order of construction
3873   // and not what user specified in the Initializers list.
3874   CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
3875   if (!ClassDecl)
3876     return true;
3877 
3878   bool HadError = false;
3879 
3880   for (unsigned i = 0; i < Initializers.size(); i++) {
3881     CXXCtorInitializer *Member = Initializers[i];
3882 
3883     if (Member->isBaseInitializer())
3884       Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
3885     else {
3886       Info.AllBaseFields[Member->getAnyMember()->getCanonicalDecl()] = Member;
3887 
3888       if (IndirectFieldDecl *F = Member->getIndirectMember()) {
3889         for (auto *C : F->chain()) {
3890           FieldDecl *FD = dyn_cast<FieldDecl>(C);
3891           if (FD && FD->getParent()->isUnion())
3892             Info.ActiveUnionMember.insert(std::make_pair(
3893                 FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
3894         }
3895       } else if (FieldDecl *FD = Member->getMember()) {
3896         if (FD->getParent()->isUnion())
3897           Info.ActiveUnionMember.insert(std::make_pair(
3898               FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
3899       }
3900     }
3901   }
3902 
3903   // Keep track of the direct virtual bases.
3904   llvm::SmallPtrSet<CXXBaseSpecifier *, 16> DirectVBases;
3905   for (auto &I : ClassDecl->bases()) {
3906     if (I.isVirtual())
3907       DirectVBases.insert(&I);
3908   }
3909 
3910   // Push virtual bases before others.
3911   for (auto &VBase : ClassDecl->vbases()) {
3912     if (CXXCtorInitializer *Value
3913         = Info.AllBaseFields.lookup(VBase.getType()->getAs<RecordType>())) {
3914       // [class.base.init]p7, per DR257:
3915       //   A mem-initializer where the mem-initializer-id names a virtual base
3916       //   class is ignored during execution of a constructor of any class that
3917       //   is not the most derived class.
3918       if (ClassDecl->isAbstract()) {
3919         // FIXME: Provide a fixit to remove the base specifier. This requires
3920         // tracking the location of the associated comma for a base specifier.
3921         Diag(Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
3922           << VBase.getType() << ClassDecl;
3923         DiagnoseAbstractType(ClassDecl);
3924       }
3925 
3926       Info.AllToInit.push_back(Value);
3927     } else if (!AnyErrors && !ClassDecl->isAbstract()) {
3928       // [class.base.init]p8, per DR257:
3929       //   If a given [...] base class is not named by a mem-initializer-id
3930       //   [...] and the entity is not a virtual base class of an abstract
3931       //   class, then [...] the entity is default-initialized.
3932       bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
3933       CXXCtorInitializer *CXXBaseInit;
3934       if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
3935                                        &VBase, IsInheritedVirtualBase,
3936                                        CXXBaseInit)) {
3937         HadError = true;
3938         continue;
3939       }
3940 
3941       Info.AllToInit.push_back(CXXBaseInit);
3942     }
3943   }
3944 
3945   // Non-virtual bases.
3946   for (auto &Base : ClassDecl->bases()) {
3947     // Virtuals are in the virtual base list and already constructed.
3948     if (Base.isVirtual())
3949       continue;
3950 
3951     if (CXXCtorInitializer *Value
3952           = Info.AllBaseFields.lookup(Base.getType()->getAs<RecordType>())) {
3953       Info.AllToInit.push_back(Value);
3954     } else if (!AnyErrors) {
3955       CXXCtorInitializer *CXXBaseInit;
3956       if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
3957                                        &Base, /*IsInheritedVirtualBase=*/false,
3958                                        CXXBaseInit)) {
3959         HadError = true;
3960         continue;
3961       }
3962 
3963       Info.AllToInit.push_back(CXXBaseInit);
3964     }
3965   }
3966 
3967   // Fields.
3968   for (auto *Mem : ClassDecl->decls()) {
3969     if (auto *F = dyn_cast<FieldDecl>(Mem)) {
3970       // C++ [class.bit]p2:
3971       //   A declaration for a bit-field that omits the identifier declares an
3972       //   unnamed bit-field. Unnamed bit-fields are not members and cannot be
3973       //   initialized.
3974       if (F->isUnnamedBitfield())
3975         continue;
3976 
3977       // If we're not generating the implicit copy/move constructor, then we'll
3978       // handle anonymous struct/union fields based on their individual
3979       // indirect fields.
3980       if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
3981         continue;
3982 
3983       if (CollectFieldInitializer(*this, Info, F))
3984         HadError = true;
3985       continue;
3986     }
3987 
3988     // Beyond this point, we only consider default initialization.
3989     if (Info.isImplicitCopyOrMove())
3990       continue;
3991 
3992     if (auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
3993       if (F->getType()->isIncompleteArrayType()) {
3994         assert(ClassDecl->hasFlexibleArrayMember() &&
3995                "Incomplete array type is not valid");
3996         continue;
3997       }
3998 
3999       // Initialize each field of an anonymous struct individually.
4000       if (CollectFieldInitializer(*this, Info, F->getAnonField(), F))
4001         HadError = true;
4002 
4003       continue;
4004     }
4005   }
4006 
4007   unsigned NumInitializers = Info.AllToInit.size();
4008   if (NumInitializers > 0) {
4009     Constructor->setNumCtorInitializers(NumInitializers);
4010     CXXCtorInitializer **baseOrMemberInitializers =
4011       new (Context) CXXCtorInitializer*[NumInitializers];
4012     memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
4013            NumInitializers * sizeof(CXXCtorInitializer*));
4014     Constructor->setCtorInitializers(baseOrMemberInitializers);
4015 
4016     // Constructors implicitly reference the base and member
4017     // destructors.
4018     MarkBaseAndMemberDestructorsReferenced(Constructor->getLocation(),
4019                                            Constructor->getParent());
4020   }
4021 
4022   return HadError;
4023 }
4024 
PopulateKeysForFields(FieldDecl * Field,SmallVectorImpl<const void * > & IdealInits)4025 static void PopulateKeysForFields(FieldDecl *Field, SmallVectorImpl<const void*> &IdealInits) {
4026   if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
4027     const RecordDecl *RD = RT->getDecl();
4028     if (RD->isAnonymousStructOrUnion()) {
4029       for (auto *Field : RD->fields())
4030         PopulateKeysForFields(Field, IdealInits);
4031       return;
4032     }
4033   }
4034   IdealInits.push_back(Field->getCanonicalDecl());
4035 }
4036 
GetKeyForBase(ASTContext & Context,QualType BaseType)4037 static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
4038   return Context.getCanonicalType(BaseType).getTypePtr();
4039 }
4040 
GetKeyForMember(ASTContext & Context,CXXCtorInitializer * Member)4041 static const void *GetKeyForMember(ASTContext &Context,
4042                                    CXXCtorInitializer *Member) {
4043   if (!Member->isAnyMemberInitializer())
4044     return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0));
4045 
4046   return Member->getAnyMember()->getCanonicalDecl();
4047 }
4048 
DiagnoseBaseOrMemInitializerOrder(Sema & SemaRef,const CXXConstructorDecl * Constructor,ArrayRef<CXXCtorInitializer * > Inits)4049 static void DiagnoseBaseOrMemInitializerOrder(
4050     Sema &SemaRef, const CXXConstructorDecl *Constructor,
4051     ArrayRef<CXXCtorInitializer *> Inits) {
4052   if (Constructor->getDeclContext()->isDependentContext())
4053     return;
4054 
4055   // Don't check initializers order unless the warning is enabled at the
4056   // location of at least one initializer.
4057   bool ShouldCheckOrder = false;
4058   for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
4059     CXXCtorInitializer *Init = Inits[InitIndex];
4060     if (!SemaRef.Diags.isIgnored(diag::warn_initializer_out_of_order,
4061                                  Init->getSourceLocation())) {
4062       ShouldCheckOrder = true;
4063       break;
4064     }
4065   }
4066   if (!ShouldCheckOrder)
4067     return;
4068 
4069   // Build the list of bases and members in the order that they'll
4070   // actually be initialized.  The explicit initializers should be in
4071   // this same order but may be missing things.
4072   SmallVector<const void*, 32> IdealInitKeys;
4073 
4074   const CXXRecordDecl *ClassDecl = Constructor->getParent();
4075 
4076   // 1. Virtual bases.
4077   for (const auto &VBase : ClassDecl->vbases())
4078     IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase.getType()));
4079 
4080   // 2. Non-virtual bases.
4081   for (const auto &Base : ClassDecl->bases()) {
4082     if (Base.isVirtual())
4083       continue;
4084     IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base.getType()));
4085   }
4086 
4087   // 3. Direct fields.
4088   for (auto *Field : ClassDecl->fields()) {
4089     if (Field->isUnnamedBitfield())
4090       continue;
4091 
4092     PopulateKeysForFields(Field, IdealInitKeys);
4093   }
4094 
4095   unsigned NumIdealInits = IdealInitKeys.size();
4096   unsigned IdealIndex = 0;
4097 
4098   CXXCtorInitializer *PrevInit = nullptr;
4099   for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
4100     CXXCtorInitializer *Init = Inits[InitIndex];
4101     const void *InitKey = GetKeyForMember(SemaRef.Context, Init);
4102 
4103     // Scan forward to try to find this initializer in the idealized
4104     // initializers list.
4105     for (; IdealIndex != NumIdealInits; ++IdealIndex)
4106       if (InitKey == IdealInitKeys[IdealIndex])
4107         break;
4108 
4109     // If we didn't find this initializer, it must be because we
4110     // scanned past it on a previous iteration.  That can only
4111     // happen if we're out of order;  emit a warning.
4112     if (IdealIndex == NumIdealInits && PrevInit) {
4113       Sema::SemaDiagnosticBuilder D =
4114         SemaRef.Diag(PrevInit->getSourceLocation(),
4115                      diag::warn_initializer_out_of_order);
4116 
4117       if (PrevInit->isAnyMemberInitializer())
4118         D << 0 << PrevInit->getAnyMember()->getDeclName();
4119       else
4120         D << 1 << PrevInit->getTypeSourceInfo()->getType();
4121 
4122       if (Init->isAnyMemberInitializer())
4123         D << 0 << Init->getAnyMember()->getDeclName();
4124       else
4125         D << 1 << Init->getTypeSourceInfo()->getType();
4126 
4127       // Move back to the initializer's location in the ideal list.
4128       for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
4129         if (InitKey == IdealInitKeys[IdealIndex])
4130           break;
4131 
4132       assert(IdealIndex < NumIdealInits &&
4133              "initializer not found in initializer list");
4134     }
4135 
4136     PrevInit = Init;
4137   }
4138 }
4139 
4140 namespace {
CheckRedundantInit(Sema & S,CXXCtorInitializer * Init,CXXCtorInitializer * & PrevInit)4141 bool CheckRedundantInit(Sema &S,
4142                         CXXCtorInitializer *Init,
4143                         CXXCtorInitializer *&PrevInit) {
4144   if (!PrevInit) {
4145     PrevInit = Init;
4146     return false;
4147   }
4148 
4149   if (FieldDecl *Field = Init->getAnyMember())
4150     S.Diag(Init->getSourceLocation(),
4151            diag::err_multiple_mem_initialization)
4152       << Field->getDeclName()
4153       << Init->getSourceRange();
4154   else {
4155     const Type *BaseClass = Init->getBaseClass();
4156     assert(BaseClass && "neither field nor base");
4157     S.Diag(Init->getSourceLocation(),
4158            diag::err_multiple_base_initialization)
4159       << QualType(BaseClass, 0)
4160       << Init->getSourceRange();
4161   }
4162   S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer)
4163     << 0 << PrevInit->getSourceRange();
4164 
4165   return true;
4166 }
4167 
4168 typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
4169 typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
4170 
CheckRedundantUnionInit(Sema & S,CXXCtorInitializer * Init,RedundantUnionMap & Unions)4171 bool CheckRedundantUnionInit(Sema &S,
4172                              CXXCtorInitializer *Init,
4173                              RedundantUnionMap &Unions) {
4174   FieldDecl *Field = Init->getAnyMember();
4175   RecordDecl *Parent = Field->getParent();
4176   NamedDecl *Child = Field;
4177 
4178   while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {
4179     if (Parent->isUnion()) {
4180       UnionEntry &En = Unions[Parent];
4181       if (En.first && En.first != Child) {
4182         S.Diag(Init->getSourceLocation(),
4183                diag::err_multiple_mem_union_initialization)
4184           << Field->getDeclName()
4185           << Init->getSourceRange();
4186         S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
4187           << 0 << En.second->getSourceRange();
4188         return true;
4189       }
4190       if (!En.first) {
4191         En.first = Child;
4192         En.second = Init;
4193       }
4194       if (!Parent->isAnonymousStructOrUnion())
4195         return false;
4196     }
4197 
4198     Child = Parent;
4199     Parent = cast<RecordDecl>(Parent->getDeclContext());
4200   }
4201 
4202   return false;
4203 }
4204 }
4205 
4206 /// ActOnMemInitializers - Handle the member initializers for a constructor.
ActOnMemInitializers(Decl * ConstructorDecl,SourceLocation ColonLoc,ArrayRef<CXXCtorInitializer * > MemInits,bool AnyErrors)4207 void Sema::ActOnMemInitializers(Decl *ConstructorDecl,
4208                                 SourceLocation ColonLoc,
4209                                 ArrayRef<CXXCtorInitializer*> MemInits,
4210                                 bool AnyErrors) {
4211   if (!ConstructorDecl)
4212     return;
4213 
4214   AdjustDeclIfTemplate(ConstructorDecl);
4215 
4216   CXXConstructorDecl *Constructor
4217     = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
4218 
4219   if (!Constructor) {
4220     Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
4221     return;
4222   }
4223 
4224   // Mapping for the duplicate initializers check.
4225   // For member initializers, this is keyed with a FieldDecl*.
4226   // For base initializers, this is keyed with a Type*.
4227   llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
4228 
4229   // Mapping for the inconsistent anonymous-union initializers check.
4230   RedundantUnionMap MemberUnions;
4231 
4232   bool HadError = false;
4233   for (unsigned i = 0; i < MemInits.size(); i++) {
4234     CXXCtorInitializer *Init = MemInits[i];
4235 
4236     // Set the source order index.
4237     Init->setSourceOrder(i);
4238 
4239     if (Init->isAnyMemberInitializer()) {
4240       const void *Key = GetKeyForMember(Context, Init);
4241       if (CheckRedundantInit(*this, Init, Members[Key]) ||
4242           CheckRedundantUnionInit(*this, Init, MemberUnions))
4243         HadError = true;
4244     } else if (Init->isBaseInitializer()) {
4245       const void *Key = GetKeyForMember(Context, Init);
4246       if (CheckRedundantInit(*this, Init, Members[Key]))
4247         HadError = true;
4248     } else {
4249       assert(Init->isDelegatingInitializer());
4250       // This must be the only initializer
4251       if (MemInits.size() != 1) {
4252         Diag(Init->getSourceLocation(),
4253              diag::err_delegating_initializer_alone)
4254           << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
4255         // We will treat this as being the only initializer.
4256       }
4257       SetDelegatingInitializer(Constructor, MemInits[i]);
4258       // Return immediately as the initializer is set.
4259       return;
4260     }
4261   }
4262 
4263   if (HadError)
4264     return;
4265 
4266   DiagnoseBaseOrMemInitializerOrder(*this, Constructor, MemInits);
4267 
4268   SetCtorInitializers(Constructor, AnyErrors, MemInits);
4269 
4270   DiagnoseUninitializedFields(*this, Constructor);
4271 }
4272 
4273 void
MarkBaseAndMemberDestructorsReferenced(SourceLocation Location,CXXRecordDecl * ClassDecl)4274 Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location,
4275                                              CXXRecordDecl *ClassDecl) {
4276   // Ignore dependent contexts. Also ignore unions, since their members never
4277   // have destructors implicitly called.
4278   if (ClassDecl->isDependentContext() || ClassDecl->isUnion())
4279     return;
4280 
4281   // FIXME: all the access-control diagnostics are positioned on the
4282   // field/base declaration.  That's probably good; that said, the
4283   // user might reasonably want to know why the destructor is being
4284   // emitted, and we currently don't say.
4285 
4286   // Non-static data members.
4287   for (auto *Field : ClassDecl->fields()) {
4288     if (Field->isInvalidDecl())
4289       continue;
4290 
4291     // Don't destroy incomplete or zero-length arrays.
4292     if (isIncompleteOrZeroLengthArrayType(Context, Field->getType()))
4293       continue;
4294 
4295     QualType FieldType = Context.getBaseElementType(Field->getType());
4296 
4297     const RecordType* RT = FieldType->getAs<RecordType>();
4298     if (!RT)
4299       continue;
4300 
4301     CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
4302     if (FieldClassDecl->isInvalidDecl())
4303       continue;
4304     if (FieldClassDecl->hasIrrelevantDestructor())
4305       continue;
4306     // The destructor for an implicit anonymous union member is never invoked.
4307     if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
4308       continue;
4309 
4310     CXXDestructorDecl *Dtor = LookupDestructor(FieldClassDecl);
4311     assert(Dtor && "No dtor found for FieldClassDecl!");
4312     CheckDestructorAccess(Field->getLocation(), Dtor,
4313                           PDiag(diag::err_access_dtor_field)
4314                             << Field->getDeclName()
4315                             << FieldType);
4316 
4317     MarkFunctionReferenced(Location, Dtor);
4318     DiagnoseUseOfDecl(Dtor, Location);
4319   }
4320 
4321   llvm::SmallPtrSet<const RecordType *, 8> DirectVirtualBases;
4322 
4323   // Bases.
4324   for (const auto &Base : ClassDecl->bases()) {
4325     // Bases are always records in a well-formed non-dependent class.
4326     const RecordType *RT = Base.getType()->getAs<RecordType>();
4327 
4328     // Remember direct virtual bases.
4329     if (Base.isVirtual())
4330       DirectVirtualBases.insert(RT);
4331 
4332     CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
4333     // If our base class is invalid, we probably can't get its dtor anyway.
4334     if (BaseClassDecl->isInvalidDecl())
4335       continue;
4336     if (BaseClassDecl->hasIrrelevantDestructor())
4337       continue;
4338 
4339     CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
4340     assert(Dtor && "No dtor found for BaseClassDecl!");
4341 
4342     // FIXME: caret should be on the start of the class name
4343     CheckDestructorAccess(Base.getLocStart(), Dtor,
4344                           PDiag(diag::err_access_dtor_base)
4345                             << Base.getType()
4346                             << Base.getSourceRange(),
4347                           Context.getTypeDeclType(ClassDecl));
4348 
4349     MarkFunctionReferenced(Location, Dtor);
4350     DiagnoseUseOfDecl(Dtor, Location);
4351   }
4352 
4353   // Virtual bases.
4354   for (const auto &VBase : ClassDecl->vbases()) {
4355     // Bases are always records in a well-formed non-dependent class.
4356     const RecordType *RT = VBase.getType()->castAs<RecordType>();
4357 
4358     // Ignore direct virtual bases.
4359     if (DirectVirtualBases.count(RT))
4360       continue;
4361 
4362     CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
4363     // If our base class is invalid, we probably can't get its dtor anyway.
4364     if (BaseClassDecl->isInvalidDecl())
4365       continue;
4366     if (BaseClassDecl->hasIrrelevantDestructor())
4367       continue;
4368 
4369     CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
4370     assert(Dtor && "No dtor found for BaseClassDecl!");
4371     if (CheckDestructorAccess(
4372             ClassDecl->getLocation(), Dtor,
4373             PDiag(diag::err_access_dtor_vbase)
4374                 << Context.getTypeDeclType(ClassDecl) << VBase.getType(),
4375             Context.getTypeDeclType(ClassDecl)) ==
4376         AR_accessible) {
4377       CheckDerivedToBaseConversion(
4378           Context.getTypeDeclType(ClassDecl), VBase.getType(),
4379           diag::err_access_dtor_vbase, 0, ClassDecl->getLocation(),
4380           SourceRange(), DeclarationName(), nullptr);
4381     }
4382 
4383     MarkFunctionReferenced(Location, Dtor);
4384     DiagnoseUseOfDecl(Dtor, Location);
4385   }
4386 }
4387 
ActOnDefaultCtorInitializers(Decl * CDtorDecl)4388 void Sema::ActOnDefaultCtorInitializers(Decl *CDtorDecl) {
4389   if (!CDtorDecl)
4390     return;
4391 
4392   if (CXXConstructorDecl *Constructor
4393       = dyn_cast<CXXConstructorDecl>(CDtorDecl)) {
4394     SetCtorInitializers(Constructor, /*AnyErrors=*/false);
4395     DiagnoseUninitializedFields(*this, Constructor);
4396   }
4397 }
4398 
isAbstractType(SourceLocation Loc,QualType T)4399 bool Sema::isAbstractType(SourceLocation Loc, QualType T) {
4400   if (!getLangOpts().CPlusPlus)
4401     return false;
4402 
4403   const auto *RD = Context.getBaseElementType(T)->getAsCXXRecordDecl();
4404   if (!RD)
4405     return false;
4406 
4407   // FIXME: Per [temp.inst]p1, we are supposed to trigger instantiation of a
4408   // class template specialization here, but doing so breaks a lot of code.
4409 
4410   // We can't answer whether something is abstract until it has a
4411   // definition. If it's currently being defined, we'll walk back
4412   // over all the declarations when we have a full definition.
4413   const CXXRecordDecl *Def = RD->getDefinition();
4414   if (!Def || Def->isBeingDefined())
4415     return false;
4416 
4417   return RD->isAbstract();
4418 }
4419 
RequireNonAbstractType(SourceLocation Loc,QualType T,TypeDiagnoser & Diagnoser)4420 bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
4421                                   TypeDiagnoser &Diagnoser) {
4422   if (!isAbstractType(Loc, T))
4423     return false;
4424 
4425   T = Context.getBaseElementType(T);
4426   Diagnoser.diagnose(*this, Loc, T);
4427   DiagnoseAbstractType(T->getAsCXXRecordDecl());
4428   return true;
4429 }
4430 
DiagnoseAbstractType(const CXXRecordDecl * RD)4431 void Sema::DiagnoseAbstractType(const CXXRecordDecl *RD) {
4432   // Check if we've already emitted the list of pure virtual functions
4433   // for this class.
4434   if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
4435     return;
4436 
4437   // If the diagnostic is suppressed, don't emit the notes. We're only
4438   // going to emit them once, so try to attach them to a diagnostic we're
4439   // actually going to show.
4440   if (Diags.isLastDiagnosticIgnored())
4441     return;
4442 
4443   CXXFinalOverriderMap FinalOverriders;
4444   RD->getFinalOverriders(FinalOverriders);
4445 
4446   // Keep a set of seen pure methods so we won't diagnose the same method
4447   // more than once.
4448   llvm::SmallPtrSet<const CXXMethodDecl *, 8> SeenPureMethods;
4449 
4450   for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
4451                                    MEnd = FinalOverriders.end();
4452        M != MEnd;
4453        ++M) {
4454     for (OverridingMethods::iterator SO = M->second.begin(),
4455                                   SOEnd = M->second.end();
4456          SO != SOEnd; ++SO) {
4457       // C++ [class.abstract]p4:
4458       //   A class is abstract if it contains or inherits at least one
4459       //   pure virtual function for which the final overrider is pure
4460       //   virtual.
4461 
4462       //
4463       if (SO->second.size() != 1)
4464         continue;
4465 
4466       if (!SO->second.front().Method->isPure())
4467         continue;
4468 
4469       if (!SeenPureMethods.insert(SO->second.front().Method).second)
4470         continue;
4471 
4472       Diag(SO->second.front().Method->getLocation(),
4473            diag::note_pure_virtual_function)
4474         << SO->second.front().Method->getDeclName() << RD->getDeclName();
4475     }
4476   }
4477 
4478   if (!PureVirtualClassDiagSet)
4479     PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
4480   PureVirtualClassDiagSet->insert(RD);
4481 }
4482 
4483 namespace {
4484 struct AbstractUsageInfo {
4485   Sema &S;
4486   CXXRecordDecl *Record;
4487   CanQualType AbstractType;
4488   bool Invalid;
4489 
AbstractUsageInfo__anon92980ac10611::AbstractUsageInfo4490   AbstractUsageInfo(Sema &S, CXXRecordDecl *Record)
4491     : S(S), Record(Record),
4492       AbstractType(S.Context.getCanonicalType(
4493                    S.Context.getTypeDeclType(Record))),
4494       Invalid(false) {}
4495 
DiagnoseAbstractType__anon92980ac10611::AbstractUsageInfo4496   void DiagnoseAbstractType() {
4497     if (Invalid) return;
4498     S.DiagnoseAbstractType(Record);
4499     Invalid = true;
4500   }
4501 
4502   void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
4503 };
4504 
4505 struct CheckAbstractUsage {
4506   AbstractUsageInfo &Info;
4507   const NamedDecl *Ctx;
4508 
CheckAbstractUsage__anon92980ac10611::CheckAbstractUsage4509   CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
4510     : Info(Info), Ctx(Ctx) {}
4511 
Visit__anon92980ac10611::CheckAbstractUsage4512   void Visit(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
4513     switch (TL.getTypeLocClass()) {
4514 #define ABSTRACT_TYPELOC(CLASS, PARENT)
4515 #define TYPELOC(CLASS, PARENT) \
4516     case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
4517 #include "clang/AST/TypeLocNodes.def"
4518     }
4519   }
4520 
Check__anon92980ac10611::CheckAbstractUsage4521   void Check(FunctionProtoTypeLoc TL, Sema::AbstractDiagSelID Sel) {
4522     Visit(TL.getReturnLoc(), Sema::AbstractReturnType);
4523     for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {
4524       if (!TL.getParam(I))
4525         continue;
4526 
4527       TypeSourceInfo *TSI = TL.getParam(I)->getTypeSourceInfo();
4528       if (TSI) Visit(TSI->getTypeLoc(), Sema::AbstractParamType);
4529     }
4530   }
4531 
Check__anon92980ac10611::CheckAbstractUsage4532   void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) {
4533     Visit(TL.getElementLoc(), Sema::AbstractArrayType);
4534   }
4535 
Check__anon92980ac10611::CheckAbstractUsage4536   void Check(TemplateSpecializationTypeLoc TL, Sema::AbstractDiagSelID Sel) {
4537     // Visit the type parameters from a permissive context.
4538     for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
4539       TemplateArgumentLoc TAL = TL.getArgLoc(I);
4540       if (TAL.getArgument().getKind() == TemplateArgument::Type)
4541         if (TypeSourceInfo *TSI = TAL.getTypeSourceInfo())
4542           Visit(TSI->getTypeLoc(), Sema::AbstractNone);
4543       // TODO: other template argument types?
4544     }
4545   }
4546 
4547   // Visit pointee types from a permissive context.
4548 #define CheckPolymorphic(Type) \
4549   void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
4550     Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
4551   }
4552   CheckPolymorphic(PointerTypeLoc)
CheckPolymorphic__anon92980ac10611::CheckAbstractUsage4553   CheckPolymorphic(ReferenceTypeLoc)
4554   CheckPolymorphic(MemberPointerTypeLoc)
4555   CheckPolymorphic(BlockPointerTypeLoc)
4556   CheckPolymorphic(AtomicTypeLoc)
4557 
4558   /// Handle all the types we haven't given a more specific
4559   /// implementation for above.
4560   void Check(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
4561     // Every other kind of type that we haven't called out already
4562     // that has an inner type is either (1) sugar or (2) contains that
4563     // inner type in some way as a subobject.
4564     if (TypeLoc Next = TL.getNextTypeLoc())
4565       return Visit(Next, Sel);
4566 
4567     // If there's no inner type and we're in a permissive context,
4568     // don't diagnose.
4569     if (Sel == Sema::AbstractNone) return;
4570 
4571     // Check whether the type matches the abstract type.
4572     QualType T = TL.getType();
4573     if (T->isArrayType()) {
4574       Sel = Sema::AbstractArrayType;
4575       T = Info.S.Context.getBaseElementType(T);
4576     }
4577     CanQualType CT = T->getCanonicalTypeUnqualified().getUnqualifiedType();
4578     if (CT != Info.AbstractType) return;
4579 
4580     // It matched; do some magic.
4581     if (Sel == Sema::AbstractArrayType) {
4582       Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type)
4583         << T << TL.getSourceRange();
4584     } else {
4585       Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl)
4586         << Sel << T << TL.getSourceRange();
4587     }
4588     Info.DiagnoseAbstractType();
4589   }
4590 };
4591 
CheckType(const NamedDecl * D,TypeLoc TL,Sema::AbstractDiagSelID Sel)4592 void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
4593                                   Sema::AbstractDiagSelID Sel) {
4594   CheckAbstractUsage(*this, D).Visit(TL, Sel);
4595 }
4596 
4597 }
4598 
4599 /// Check for invalid uses of an abstract type in a method declaration.
CheckAbstractClassUsage(AbstractUsageInfo & Info,CXXMethodDecl * MD)4600 static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
4601                                     CXXMethodDecl *MD) {
4602   // No need to do the check on definitions, which require that
4603   // the return/param types be complete.
4604   if (MD->doesThisDeclarationHaveABody())
4605     return;
4606 
4607   // For safety's sake, just ignore it if we don't have type source
4608   // information.  This should never happen for non-implicit methods,
4609   // but...
4610   if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
4611     Info.CheckType(MD, TSI->getTypeLoc(), Sema::AbstractNone);
4612 }
4613 
4614 /// Check for invalid uses of an abstract type within a class definition.
CheckAbstractClassUsage(AbstractUsageInfo & Info,CXXRecordDecl * RD)4615 static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
4616                                     CXXRecordDecl *RD) {
4617   for (auto *D : RD->decls()) {
4618     if (D->isImplicit()) continue;
4619 
4620     // Methods and method templates.
4621     if (isa<CXXMethodDecl>(D)) {
4622       CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(D));
4623     } else if (isa<FunctionTemplateDecl>(D)) {
4624       FunctionDecl *FD = cast<FunctionTemplateDecl>(D)->getTemplatedDecl();
4625       CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(FD));
4626 
4627     // Fields and static variables.
4628     } else if (isa<FieldDecl>(D)) {
4629       FieldDecl *FD = cast<FieldDecl>(D);
4630       if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
4631         Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractFieldType);
4632     } else if (isa<VarDecl>(D)) {
4633       VarDecl *VD = cast<VarDecl>(D);
4634       if (TypeSourceInfo *TSI = VD->getTypeSourceInfo())
4635         Info.CheckType(VD, TSI->getTypeLoc(), Sema::AbstractVariableType);
4636 
4637     // Nested classes and class templates.
4638     } else if (isa<CXXRecordDecl>(D)) {
4639       CheckAbstractClassUsage(Info, cast<CXXRecordDecl>(D));
4640     } else if (isa<ClassTemplateDecl>(D)) {
4641       CheckAbstractClassUsage(Info,
4642                              cast<ClassTemplateDecl>(D)->getTemplatedDecl());
4643     }
4644   }
4645 }
4646 
ReferenceDllExportedMethods(Sema & S,CXXRecordDecl * Class)4647 static void ReferenceDllExportedMethods(Sema &S, CXXRecordDecl *Class) {
4648   Attr *ClassAttr = getDLLAttr(Class);
4649   if (!ClassAttr)
4650     return;
4651 
4652   assert(ClassAttr->getKind() == attr::DLLExport);
4653 
4654   TemplateSpecializationKind TSK = Class->getTemplateSpecializationKind();
4655 
4656   if (TSK == TSK_ExplicitInstantiationDeclaration)
4657     // Don't go any further if this is just an explicit instantiation
4658     // declaration.
4659     return;
4660 
4661   for (Decl *Member : Class->decls()) {
4662     auto *MD = dyn_cast<CXXMethodDecl>(Member);
4663     if (!MD)
4664       continue;
4665 
4666     if (Member->getAttr<DLLExportAttr>()) {
4667       if (MD->isUserProvided()) {
4668         // Instantiate non-default class member functions ...
4669 
4670         // .. except for certain kinds of template specializations.
4671         if (TSK == TSK_ImplicitInstantiation && !ClassAttr->isInherited())
4672           continue;
4673 
4674         S.MarkFunctionReferenced(Class->getLocation(), MD);
4675 
4676         // The function will be passed to the consumer when its definition is
4677         // encountered.
4678       } else if (!MD->isTrivial() || MD->isExplicitlyDefaulted() ||
4679                  MD->isCopyAssignmentOperator() ||
4680                  MD->isMoveAssignmentOperator()) {
4681         // Synthesize and instantiate non-trivial implicit methods, explicitly
4682         // defaulted methods, and the copy and move assignment operators. The
4683         // latter are exported even if they are trivial, because the address of
4684         // an operator can be taken and should compare equal accross libraries.
4685         DiagnosticErrorTrap Trap(S.Diags);
4686         S.MarkFunctionReferenced(Class->getLocation(), MD);
4687         if (Trap.hasErrorOccurred()) {
4688           S.Diag(ClassAttr->getLocation(), diag::note_due_to_dllexported_class)
4689               << Class->getName() << !S.getLangOpts().CPlusPlus11;
4690           break;
4691         }
4692 
4693         // There is no later point when we will see the definition of this
4694         // function, so pass it to the consumer now.
4695         S.Consumer.HandleTopLevelDecl(DeclGroupRef(MD));
4696       }
4697     }
4698   }
4699 }
4700 
4701 /// \brief Check class-level dllimport/dllexport attribute.
checkClassLevelDLLAttribute(CXXRecordDecl * Class)4702 void Sema::checkClassLevelDLLAttribute(CXXRecordDecl *Class) {
4703   Attr *ClassAttr = getDLLAttr(Class);
4704 
4705   // MSVC inherits DLL attributes to partial class template specializations.
4706   if (Context.getTargetInfo().getCXXABI().isMicrosoft() && !ClassAttr) {
4707     if (auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(Class)) {
4708       if (Attr *TemplateAttr =
4709               getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
4710         auto *A = cast<InheritableAttr>(TemplateAttr->clone(getASTContext()));
4711         A->setInherited(true);
4712         ClassAttr = A;
4713       }
4714     }
4715   }
4716 
4717   if (!ClassAttr)
4718     return;
4719 
4720   if (!Class->isExternallyVisible()) {
4721     Diag(Class->getLocation(), diag::err_attribute_dll_not_extern)
4722         << Class << ClassAttr;
4723     return;
4724   }
4725 
4726   if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
4727       !ClassAttr->isInherited()) {
4728     // Diagnose dll attributes on members of class with dll attribute.
4729     for (Decl *Member : Class->decls()) {
4730       if (!isa<VarDecl>(Member) && !isa<CXXMethodDecl>(Member))
4731         continue;
4732       InheritableAttr *MemberAttr = getDLLAttr(Member);
4733       if (!MemberAttr || MemberAttr->isInherited() || Member->isInvalidDecl())
4734         continue;
4735 
4736       Diag(MemberAttr->getLocation(),
4737              diag::err_attribute_dll_member_of_dll_class)
4738           << MemberAttr << ClassAttr;
4739       Diag(ClassAttr->getLocation(), diag::note_previous_attribute);
4740       Member->setInvalidDecl();
4741     }
4742   }
4743 
4744   if (Class->getDescribedClassTemplate())
4745     // Don't inherit dll attribute until the template is instantiated.
4746     return;
4747 
4748   // The class is either imported or exported.
4749   const bool ClassExported = ClassAttr->getKind() == attr::DLLExport;
4750 
4751   TemplateSpecializationKind TSK = Class->getTemplateSpecializationKind();
4752 
4753   // Ignore explicit dllexport on explicit class template instantiation declarations.
4754   if (ClassExported && !ClassAttr->isInherited() &&
4755       TSK == TSK_ExplicitInstantiationDeclaration) {
4756     Class->dropAttr<DLLExportAttr>();
4757     return;
4758   }
4759 
4760   // Force declaration of implicit members so they can inherit the attribute.
4761   ForceDeclarationOfImplicitMembers(Class);
4762 
4763   // FIXME: MSVC's docs say all bases must be exportable, but this doesn't
4764   // seem to be true in practice?
4765 
4766   for (Decl *Member : Class->decls()) {
4767     VarDecl *VD = dyn_cast<VarDecl>(Member);
4768     CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Member);
4769 
4770     // Only methods and static fields inherit the attributes.
4771     if (!VD && !MD)
4772       continue;
4773 
4774     if (MD) {
4775       // Don't process deleted methods.
4776       if (MD->isDeleted())
4777         continue;
4778 
4779       if (MD->isInlined()) {
4780         // MinGW does not import or export inline methods.
4781         if (!Context.getTargetInfo().getCXXABI().isMicrosoft())
4782           continue;
4783 
4784         // MSVC versions before 2015 don't export the move assignment operators
4785         // and move constructor, so don't attempt to import/export them if
4786         // we have a definition.
4787         auto *Ctor = dyn_cast<CXXConstructorDecl>(MD);
4788         if ((MD->isMoveAssignmentOperator() ||
4789              (Ctor && Ctor->isMoveConstructor())) &&
4790             !getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015))
4791           continue;
4792 
4793         // MSVC2015 doesn't export trivial defaulted x-tor but copy assign
4794         // operator is exported anyway.
4795         if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
4796             (Ctor || isa<CXXDestructorDecl>(MD)) && MD->isTrivial())
4797           continue;
4798       }
4799     }
4800 
4801     if (!cast<NamedDecl>(Member)->isExternallyVisible())
4802       continue;
4803 
4804     if (!getDLLAttr(Member)) {
4805       auto *NewAttr =
4806           cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
4807       NewAttr->setInherited(true);
4808       Member->addAttr(NewAttr);
4809     }
4810   }
4811 
4812   if (ClassExported)
4813     DelayedDllExportClasses.push_back(Class);
4814 }
4815 
4816 /// \brief Perform propagation of DLL attributes from a derived class to a
4817 /// templated base class for MS compatibility.
propagateDLLAttrToBaseClassTemplate(CXXRecordDecl * Class,Attr * ClassAttr,ClassTemplateSpecializationDecl * BaseTemplateSpec,SourceLocation BaseLoc)4818 void Sema::propagateDLLAttrToBaseClassTemplate(
4819     CXXRecordDecl *Class, Attr *ClassAttr,
4820     ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc) {
4821   if (getDLLAttr(
4822           BaseTemplateSpec->getSpecializedTemplate()->getTemplatedDecl())) {
4823     // If the base class template has a DLL attribute, don't try to change it.
4824     return;
4825   }
4826 
4827   auto TSK = BaseTemplateSpec->getSpecializationKind();
4828   if (!getDLLAttr(BaseTemplateSpec) &&
4829       (TSK == TSK_Undeclared || TSK == TSK_ExplicitInstantiationDeclaration ||
4830        TSK == TSK_ImplicitInstantiation)) {
4831     // The template hasn't been instantiated yet (or it has, but only as an
4832     // explicit instantiation declaration or implicit instantiation, which means
4833     // we haven't codegenned any members yet), so propagate the attribute.
4834     auto *NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
4835     NewAttr->setInherited(true);
4836     BaseTemplateSpec->addAttr(NewAttr);
4837 
4838     // If the template is already instantiated, checkDLLAttributeRedeclaration()
4839     // needs to be run again to work see the new attribute. Otherwise this will
4840     // get run whenever the template is instantiated.
4841     if (TSK != TSK_Undeclared)
4842       checkClassLevelDLLAttribute(BaseTemplateSpec);
4843 
4844     return;
4845   }
4846 
4847   if (getDLLAttr(BaseTemplateSpec)) {
4848     // The template has already been specialized or instantiated with an
4849     // attribute, explicitly or through propagation. We should not try to change
4850     // it.
4851     return;
4852   }
4853 
4854   // The template was previously instantiated or explicitly specialized without
4855   // a dll attribute, It's too late for us to add an attribute, so warn that
4856   // this is unsupported.
4857   Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)
4858       << BaseTemplateSpec->isExplicitSpecialization();
4859   Diag(ClassAttr->getLocation(), diag::note_attribute);
4860   if (BaseTemplateSpec->isExplicitSpecialization()) {
4861     Diag(BaseTemplateSpec->getLocation(),
4862            diag::note_template_class_explicit_specialization_was_here)
4863         << BaseTemplateSpec;
4864   } else {
4865     Diag(BaseTemplateSpec->getPointOfInstantiation(),
4866            diag::note_template_class_instantiation_was_here)
4867         << BaseTemplateSpec;
4868   }
4869 }
4870 
DefineImplicitSpecialMember(Sema & S,CXXMethodDecl * MD,SourceLocation DefaultLoc)4871 static void DefineImplicitSpecialMember(Sema &S, CXXMethodDecl *MD,
4872                                         SourceLocation DefaultLoc) {
4873   switch (S.getSpecialMember(MD)) {
4874   case Sema::CXXDefaultConstructor:
4875     S.DefineImplicitDefaultConstructor(DefaultLoc,
4876                                        cast<CXXConstructorDecl>(MD));
4877     break;
4878   case Sema::CXXCopyConstructor:
4879     S.DefineImplicitCopyConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
4880     break;
4881   case Sema::CXXCopyAssignment:
4882     S.DefineImplicitCopyAssignment(DefaultLoc, MD);
4883     break;
4884   case Sema::CXXDestructor:
4885     S.DefineImplicitDestructor(DefaultLoc, cast<CXXDestructorDecl>(MD));
4886     break;
4887   case Sema::CXXMoveConstructor:
4888     S.DefineImplicitMoveConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
4889     break;
4890   case Sema::CXXMoveAssignment:
4891     S.DefineImplicitMoveAssignment(DefaultLoc, MD);
4892     break;
4893   case Sema::CXXInvalid:
4894     llvm_unreachable("Invalid special member.");
4895   }
4896 }
4897 
4898 /// \brief Perform semantic checks on a class definition that has been
4899 /// completing, introducing implicitly-declared members, checking for
4900 /// abstract types, etc.
CheckCompletedCXXClass(CXXRecordDecl * Record)4901 void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
4902   if (!Record)
4903     return;
4904 
4905   if (Record->isAbstract() && !Record->isInvalidDecl()) {
4906     AbstractUsageInfo Info(*this, Record);
4907     CheckAbstractClassUsage(Info, Record);
4908   }
4909 
4910   // If this is not an aggregate type and has no user-declared constructor,
4911   // complain about any non-static data members of reference or const scalar
4912   // type, since they will never get initializers.
4913   if (!Record->isInvalidDecl() && !Record->isDependentType() &&
4914       !Record->isAggregate() && !Record->hasUserDeclaredConstructor() &&
4915       !Record->isLambda()) {
4916     bool Complained = false;
4917     for (const auto *F : Record->fields()) {
4918       if (F->hasInClassInitializer() || F->isUnnamedBitfield())
4919         continue;
4920 
4921       if (F->getType()->isReferenceType() ||
4922           (F->getType().isConstQualified() && F->getType()->isScalarType())) {
4923         if (!Complained) {
4924           Diag(Record->getLocation(), diag::warn_no_constructor_for_refconst)
4925             << Record->getTagKind() << Record;
4926           Complained = true;
4927         }
4928 
4929         Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
4930           << F->getType()->isReferenceType()
4931           << F->getDeclName();
4932       }
4933     }
4934   }
4935 
4936   if (Record->getIdentifier()) {
4937     // C++ [class.mem]p13:
4938     //   If T is the name of a class, then each of the following shall have a
4939     //   name different from T:
4940     //     - every member of every anonymous union that is a member of class T.
4941     //
4942     // C++ [class.mem]p14:
4943     //   In addition, if class T has a user-declared constructor (12.1), every
4944     //   non-static data member of class T shall have a name different from T.
4945     DeclContext::lookup_result R = Record->lookup(Record->getDeclName());
4946     for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
4947          ++I) {
4948       NamedDecl *D = *I;
4949       if ((isa<FieldDecl>(D) && Record->hasUserDeclaredConstructor()) ||
4950           isa<IndirectFieldDecl>(D)) {
4951         Diag(D->getLocation(), diag::err_member_name_of_class)
4952           << D->getDeclName();
4953         break;
4954       }
4955     }
4956   }
4957 
4958   // Warn if the class has virtual methods but non-virtual public destructor.
4959   if (Record->isPolymorphic() && !Record->isDependentType()) {
4960     CXXDestructorDecl *dtor = Record->getDestructor();
4961     if ((!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public)) &&
4962         !Record->hasAttr<FinalAttr>())
4963       Diag(dtor ? dtor->getLocation() : Record->getLocation(),
4964            diag::warn_non_virtual_dtor) << Context.getRecordType(Record);
4965   }
4966 
4967   if (Record->isAbstract()) {
4968     if (FinalAttr *FA = Record->getAttr<FinalAttr>()) {
4969       Diag(Record->getLocation(), diag::warn_abstract_final_class)
4970         << FA->isSpelledAsSealed();
4971       DiagnoseAbstractType(Record);
4972     }
4973   }
4974 
4975   bool HasMethodWithOverrideControl = false,
4976        HasOverridingMethodWithoutOverrideControl = false;
4977   if (!Record->isDependentType()) {
4978     for (auto *M : Record->methods()) {
4979       // See if a method overloads virtual methods in a base
4980       // class without overriding any.
4981       if (!M->isStatic())
4982         DiagnoseHiddenVirtualMethods(M);
4983       if (M->hasAttr<OverrideAttr>())
4984         HasMethodWithOverrideControl = true;
4985       else if (M->size_overridden_methods() > 0)
4986         HasOverridingMethodWithoutOverrideControl = true;
4987       // Check whether the explicitly-defaulted special members are valid.
4988       if (!M->isInvalidDecl() && M->isExplicitlyDefaulted())
4989         CheckExplicitlyDefaultedSpecialMember(M);
4990 
4991       // For an explicitly defaulted or deleted special member, we defer
4992       // determining triviality until the class is complete. That time is now!
4993       CXXSpecialMember CSM = getSpecialMember(M);
4994       if (!M->isImplicit() && !M->isUserProvided()) {
4995         if (CSM != CXXInvalid) {
4996           M->setTrivial(SpecialMemberIsTrivial(M, CSM));
4997 
4998           // Inform the class that we've finished declaring this member.
4999           Record->finishedDefaultedOrDeletedMember(M);
5000         }
5001       }
5002 
5003       if (!M->isInvalidDecl() && M->isExplicitlyDefaulted() &&
5004           M->hasAttr<DLLExportAttr>()) {
5005         if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
5006             M->isTrivial() &&
5007             (CSM == CXXDefaultConstructor || CSM == CXXCopyConstructor ||
5008              CSM == CXXDestructor))
5009           M->dropAttr<DLLExportAttr>();
5010 
5011         if (M->hasAttr<DLLExportAttr>()) {
5012           DefineImplicitSpecialMember(*this, M, M->getLocation());
5013           ActOnFinishInlineFunctionDef(M);
5014         }
5015       }
5016     }
5017   }
5018 
5019   if (HasMethodWithOverrideControl &&
5020       HasOverridingMethodWithoutOverrideControl) {
5021     // At least one method has the 'override' control declared.
5022     // Diagnose all other overridden methods which do not have 'override' specified on them.
5023     for (auto *M : Record->methods())
5024       DiagnoseAbsenceOfOverrideControl(M);
5025   }
5026 
5027   // ms_struct is a request to use the same ABI rules as MSVC.  Check
5028   // whether this class uses any C++ features that are implemented
5029   // completely differently in MSVC, and if so, emit a diagnostic.
5030   // That diagnostic defaults to an error, but we allow projects to
5031   // map it down to a warning (or ignore it).  It's a fairly common
5032   // practice among users of the ms_struct pragma to mass-annotate
5033   // headers, sweeping up a bunch of types that the project doesn't
5034   // really rely on MSVC-compatible layout for.  We must therefore
5035   // support "ms_struct except for C++ stuff" as a secondary ABI.
5036   if (Record->isMsStruct(Context) &&
5037       (Record->isPolymorphic() || Record->getNumBases())) {
5038     Diag(Record->getLocation(), diag::warn_cxx_ms_struct);
5039   }
5040 
5041   checkClassLevelDLLAttribute(Record);
5042 }
5043 
5044 /// Look up the special member function that would be called by a special
5045 /// member function for a subobject of class type.
5046 ///
5047 /// \param Class The class type of the subobject.
5048 /// \param CSM The kind of special member function.
5049 /// \param FieldQuals If the subobject is a field, its cv-qualifiers.
5050 /// \param ConstRHS True if this is a copy operation with a const object
5051 ///        on its RHS, that is, if the argument to the outer special member
5052 ///        function is 'const' and this is not a field marked 'mutable'.
lookupCallFromSpecialMember(Sema & S,CXXRecordDecl * Class,Sema::CXXSpecialMember CSM,unsigned FieldQuals,bool ConstRHS)5053 static Sema::SpecialMemberOverloadResult *lookupCallFromSpecialMember(
5054     Sema &S, CXXRecordDecl *Class, Sema::CXXSpecialMember CSM,
5055     unsigned FieldQuals, bool ConstRHS) {
5056   unsigned LHSQuals = 0;
5057   if (CSM == Sema::CXXCopyAssignment || CSM == Sema::CXXMoveAssignment)
5058     LHSQuals = FieldQuals;
5059 
5060   unsigned RHSQuals = FieldQuals;
5061   if (CSM == Sema::CXXDefaultConstructor || CSM == Sema::CXXDestructor)
5062     RHSQuals = 0;
5063   else if (ConstRHS)
5064     RHSQuals |= Qualifiers::Const;
5065 
5066   return S.LookupSpecialMember(Class, CSM,
5067                                RHSQuals & Qualifiers::Const,
5068                                RHSQuals & Qualifiers::Volatile,
5069                                false,
5070                                LHSQuals & Qualifiers::Const,
5071                                LHSQuals & Qualifiers::Volatile);
5072 }
5073 
5074 class Sema::InheritedConstructorInfo {
5075   Sema &S;
5076   SourceLocation UseLoc;
5077 
5078   /// A mapping from the base classes through which the constructor was
5079   /// inherited to the using shadow declaration in that base class (or a null
5080   /// pointer if the constructor was declared in that base class).
5081   llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
5082       InheritedFromBases;
5083 
5084 public:
InheritedConstructorInfo(Sema & S,SourceLocation UseLoc,ConstructorUsingShadowDecl * Shadow)5085   InheritedConstructorInfo(Sema &S, SourceLocation UseLoc,
5086                            ConstructorUsingShadowDecl *Shadow)
5087       : S(S), UseLoc(UseLoc) {
5088     bool DiagnosedMultipleConstructedBases = false;
5089     CXXRecordDecl *ConstructedBase = nullptr;
5090     UsingDecl *ConstructedBaseUsing = nullptr;
5091 
5092     // Find the set of such base class subobjects and check that there's a
5093     // unique constructed subobject.
5094     for (auto *D : Shadow->redecls()) {
5095       auto *DShadow = cast<ConstructorUsingShadowDecl>(D);
5096       auto *DNominatedBase = DShadow->getNominatedBaseClass();
5097       auto *DConstructedBase = DShadow->getConstructedBaseClass();
5098 
5099       InheritedFromBases.insert(
5100           std::make_pair(DNominatedBase->getCanonicalDecl(),
5101                          DShadow->getNominatedBaseClassShadowDecl()));
5102       if (DShadow->constructsVirtualBase())
5103         InheritedFromBases.insert(
5104             std::make_pair(DConstructedBase->getCanonicalDecl(),
5105                            DShadow->getConstructedBaseClassShadowDecl()));
5106       else
5107         assert(DNominatedBase == DConstructedBase);
5108 
5109       // [class.inhctor.init]p2:
5110       //   If the constructor was inherited from multiple base class subobjects
5111       //   of type B, the program is ill-formed.
5112       if (!ConstructedBase) {
5113         ConstructedBase = DConstructedBase;
5114         ConstructedBaseUsing = D->getUsingDecl();
5115       } else if (ConstructedBase != DConstructedBase &&
5116                  !Shadow->isInvalidDecl()) {
5117         if (!DiagnosedMultipleConstructedBases) {
5118           S.Diag(UseLoc, diag::err_ambiguous_inherited_constructor)
5119               << Shadow->getTargetDecl();
5120           S.Diag(ConstructedBaseUsing->getLocation(),
5121                diag::note_ambiguous_inherited_constructor_using)
5122               << ConstructedBase;
5123           DiagnosedMultipleConstructedBases = true;
5124         }
5125         S.Diag(D->getUsingDecl()->getLocation(),
5126                diag::note_ambiguous_inherited_constructor_using)
5127             << DConstructedBase;
5128       }
5129     }
5130 
5131     if (DiagnosedMultipleConstructedBases)
5132       Shadow->setInvalidDecl();
5133   }
5134 
5135   /// Find the constructor to use for inherited construction of a base class,
5136   /// and whether that base class constructor inherits the constructor from a
5137   /// virtual base class (in which case it won't actually invoke it).
5138   std::pair<CXXConstructorDecl *, bool>
findConstructorForBase(CXXRecordDecl * Base,CXXConstructorDecl * Ctor) const5139   findConstructorForBase(CXXRecordDecl *Base, CXXConstructorDecl *Ctor) const {
5140     auto It = InheritedFromBases.find(Base->getCanonicalDecl());
5141     if (It == InheritedFromBases.end())
5142       return std::make_pair(nullptr, false);
5143 
5144     // This is an intermediary class.
5145     if (It->second)
5146       return std::make_pair(
5147           S.findInheritingConstructor(UseLoc, Ctor, It->second),
5148           It->second->constructsVirtualBase());
5149 
5150     // This is the base class from which the constructor was inherited.
5151     return std::make_pair(Ctor, false);
5152   }
5153 };
5154 
5155 /// Is the special member function which would be selected to perform the
5156 /// specified operation on the specified class type a constexpr constructor?
5157 static bool
specialMemberIsConstexpr(Sema & S,CXXRecordDecl * ClassDecl,Sema::CXXSpecialMember CSM,unsigned Quals,bool ConstRHS,CXXConstructorDecl * InheritedCtor=nullptr,Sema::InheritedConstructorInfo * Inherited=nullptr)5158 specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl,
5159                          Sema::CXXSpecialMember CSM, unsigned Quals,
5160                          bool ConstRHS,
5161                          CXXConstructorDecl *InheritedCtor = nullptr,
5162                          Sema::InheritedConstructorInfo *Inherited = nullptr) {
5163   // If we're inheriting a constructor, see if we need to call it for this base
5164   // class.
5165   if (InheritedCtor) {
5166     assert(CSM == Sema::CXXDefaultConstructor);
5167     auto BaseCtor =
5168         Inherited->findConstructorForBase(ClassDecl, InheritedCtor).first;
5169     if (BaseCtor)
5170       return BaseCtor->isConstexpr();
5171   }
5172 
5173   if (CSM == Sema::CXXDefaultConstructor)
5174     return ClassDecl->hasConstexprDefaultConstructor();
5175 
5176   Sema::SpecialMemberOverloadResult *SMOR =
5177       lookupCallFromSpecialMember(S, ClassDecl, CSM, Quals, ConstRHS);
5178   if (!SMOR || !SMOR->getMethod())
5179     // A constructor we wouldn't select can't be "involved in initializing"
5180     // anything.
5181     return true;
5182   return SMOR->getMethod()->isConstexpr();
5183 }
5184 
5185 /// Determine whether the specified special member function would be constexpr
5186 /// if it were implicitly defined.
defaultedSpecialMemberIsConstexpr(Sema & S,CXXRecordDecl * ClassDecl,Sema::CXXSpecialMember CSM,bool ConstArg,CXXConstructorDecl * InheritedCtor=nullptr,Sema::InheritedConstructorInfo * Inherited=nullptr)5187 static bool defaultedSpecialMemberIsConstexpr(
5188     Sema &S, CXXRecordDecl *ClassDecl, Sema::CXXSpecialMember CSM,
5189     bool ConstArg, CXXConstructorDecl *InheritedCtor = nullptr,
5190     Sema::InheritedConstructorInfo *Inherited = nullptr) {
5191   if (!S.getLangOpts().CPlusPlus11)
5192     return false;
5193 
5194   // C++11 [dcl.constexpr]p4:
5195   // In the definition of a constexpr constructor [...]
5196   bool Ctor = true;
5197   switch (CSM) {
5198   case Sema::CXXDefaultConstructor:
5199     if (Inherited)
5200       break;
5201     // Since default constructor lookup is essentially trivial (and cannot
5202     // involve, for instance, template instantiation), we compute whether a
5203     // defaulted default constructor is constexpr directly within CXXRecordDecl.
5204     //
5205     // This is important for performance; we need to know whether the default
5206     // constructor is constexpr to determine whether the type is a literal type.
5207     return ClassDecl->defaultedDefaultConstructorIsConstexpr();
5208 
5209   case Sema::CXXCopyConstructor:
5210   case Sema::CXXMoveConstructor:
5211     // For copy or move constructors, we need to perform overload resolution.
5212     break;
5213 
5214   case Sema::CXXCopyAssignment:
5215   case Sema::CXXMoveAssignment:
5216     if (!S.getLangOpts().CPlusPlus14)
5217       return false;
5218     // In C++1y, we need to perform overload resolution.
5219     Ctor = false;
5220     break;
5221 
5222   case Sema::CXXDestructor:
5223   case Sema::CXXInvalid:
5224     return false;
5225   }
5226 
5227   //   -- if the class is a non-empty union, or for each non-empty anonymous
5228   //      union member of a non-union class, exactly one non-static data member
5229   //      shall be initialized; [DR1359]
5230   //
5231   // If we squint, this is guaranteed, since exactly one non-static data member
5232   // will be initialized (if the constructor isn't deleted), we just don't know
5233   // which one.
5234   if (Ctor && ClassDecl->isUnion())
5235     return CSM == Sema::CXXDefaultConstructor
5236                ? ClassDecl->hasInClassInitializer() ||
5237                      !ClassDecl->hasVariantMembers()
5238                : true;
5239 
5240   //   -- the class shall not have any virtual base classes;
5241   if (Ctor && ClassDecl->getNumVBases())
5242     return false;
5243 
5244   // C++1y [class.copy]p26:
5245   //   -- [the class] is a literal type, and
5246   if (!Ctor && !ClassDecl->isLiteral())
5247     return false;
5248 
5249   //   -- every constructor involved in initializing [...] base class
5250   //      sub-objects shall be a constexpr constructor;
5251   //   -- the assignment operator selected to copy/move each direct base
5252   //      class is a constexpr function, and
5253   for (const auto &B : ClassDecl->bases()) {
5254     const RecordType *BaseType = B.getType()->getAs<RecordType>();
5255     if (!BaseType) continue;
5256 
5257     CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
5258     if (!specialMemberIsConstexpr(S, BaseClassDecl, CSM, 0, ConstArg,
5259                                   InheritedCtor, Inherited))
5260       return false;
5261   }
5262 
5263   //   -- every constructor involved in initializing non-static data members
5264   //      [...] shall be a constexpr constructor;
5265   //   -- every non-static data member and base class sub-object shall be
5266   //      initialized
5267   //   -- for each non-static data member of X that is of class type (or array
5268   //      thereof), the assignment operator selected to copy/move that member is
5269   //      a constexpr function
5270   for (const auto *F : ClassDecl->fields()) {
5271     if (F->isInvalidDecl())
5272       continue;
5273     if (CSM == Sema::CXXDefaultConstructor && F->hasInClassInitializer())
5274       continue;
5275     QualType BaseType = S.Context.getBaseElementType(F->getType());
5276     if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
5277       CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
5278       if (!specialMemberIsConstexpr(S, FieldRecDecl, CSM,
5279                                     BaseType.getCVRQualifiers(),
5280                                     ConstArg && !F->isMutable()))
5281         return false;
5282     } else if (CSM == Sema::CXXDefaultConstructor) {
5283       return false;
5284     }
5285   }
5286 
5287   // All OK, it's constexpr!
5288   return true;
5289 }
5290 
5291 static Sema::ImplicitExceptionSpecification
computeImplicitExceptionSpec(Sema & S,SourceLocation Loc,CXXMethodDecl * MD)5292 computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, CXXMethodDecl *MD) {
5293   switch (S.getSpecialMember(MD)) {
5294   case Sema::CXXDefaultConstructor:
5295     return S.ComputeDefaultedDefaultCtorExceptionSpec(Loc, MD);
5296   case Sema::CXXCopyConstructor:
5297     return S.ComputeDefaultedCopyCtorExceptionSpec(MD);
5298   case Sema::CXXCopyAssignment:
5299     return S.ComputeDefaultedCopyAssignmentExceptionSpec(MD);
5300   case Sema::CXXMoveConstructor:
5301     return S.ComputeDefaultedMoveCtorExceptionSpec(MD);
5302   case Sema::CXXMoveAssignment:
5303     return S.ComputeDefaultedMoveAssignmentExceptionSpec(MD);
5304   case Sema::CXXDestructor:
5305     return S.ComputeDefaultedDtorExceptionSpec(MD);
5306   case Sema::CXXInvalid:
5307     break;
5308   }
5309   assert(cast<CXXConstructorDecl>(MD)->getInheritedConstructor() &&
5310          "only special members have implicit exception specs");
5311   return S.ComputeInheritingCtorExceptionSpec(Loc,
5312                                               cast<CXXConstructorDecl>(MD));
5313 }
5314 
getImplicitMethodEPI(Sema & S,CXXMethodDecl * MD)5315 static FunctionProtoType::ExtProtoInfo getImplicitMethodEPI(Sema &S,
5316                                                             CXXMethodDecl *MD) {
5317   FunctionProtoType::ExtProtoInfo EPI;
5318 
5319   // Build an exception specification pointing back at this member.
5320   EPI.ExceptionSpec.Type = EST_Unevaluated;
5321   EPI.ExceptionSpec.SourceDecl = MD;
5322 
5323   // Set the calling convention to the default for C++ instance methods.
5324   EPI.ExtInfo = EPI.ExtInfo.withCallingConv(
5325       S.Context.getDefaultCallingConvention(/*IsVariadic=*/false,
5326                                             /*IsCXXMethod=*/true));
5327   return EPI;
5328 }
5329 
EvaluateImplicitExceptionSpec(SourceLocation Loc,CXXMethodDecl * MD)5330 void Sema::EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD) {
5331   const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
5332   if (FPT->getExceptionSpecType() != EST_Unevaluated)
5333     return;
5334 
5335   // Evaluate the exception specification.
5336   auto ESI = computeImplicitExceptionSpec(*this, Loc, MD).getExceptionSpec();
5337 
5338   // Update the type of the special member to use it.
5339   UpdateExceptionSpec(MD, ESI);
5340 
5341   // A user-provided destructor can be defined outside the class. When that
5342   // happens, be sure to update the exception specification on both
5343   // declarations.
5344   const FunctionProtoType *CanonicalFPT =
5345     MD->getCanonicalDecl()->getType()->castAs<FunctionProtoType>();
5346   if (CanonicalFPT->getExceptionSpecType() == EST_Unevaluated)
5347     UpdateExceptionSpec(MD->getCanonicalDecl(), ESI);
5348 }
5349 
CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl * MD)5350 void Sema::CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD) {
5351   CXXRecordDecl *RD = MD->getParent();
5352   CXXSpecialMember CSM = getSpecialMember(MD);
5353 
5354   assert(MD->isExplicitlyDefaulted() && CSM != CXXInvalid &&
5355          "not an explicitly-defaulted special member");
5356 
5357   // Whether this was the first-declared instance of the constructor.
5358   // This affects whether we implicitly add an exception spec and constexpr.
5359   bool First = MD == MD->getCanonicalDecl();
5360 
5361   bool HadError = false;
5362 
5363   // C++11 [dcl.fct.def.default]p1:
5364   //   A function that is explicitly defaulted shall
5365   //     -- be a special member function (checked elsewhere),
5366   //     -- have the same type (except for ref-qualifiers, and except that a
5367   //        copy operation can take a non-const reference) as an implicit
5368   //        declaration, and
5369   //     -- not have default arguments.
5370   unsigned ExpectedParams = 1;
5371   if (CSM == CXXDefaultConstructor || CSM == CXXDestructor)
5372     ExpectedParams = 0;
5373   if (MD->getNumParams() != ExpectedParams) {
5374     // This also checks for default arguments: a copy or move constructor with a
5375     // default argument is classified as a default constructor, and assignment
5376     // operations and destructors can't have default arguments.
5377     Diag(MD->getLocation(), diag::err_defaulted_special_member_params)
5378       << CSM << MD->getSourceRange();
5379     HadError = true;
5380   } else if (MD->isVariadic()) {
5381     Diag(MD->getLocation(), diag::err_defaulted_special_member_variadic)
5382       << CSM << MD->getSourceRange();
5383     HadError = true;
5384   }
5385 
5386   const FunctionProtoType *Type = MD->getType()->getAs<FunctionProtoType>();
5387 
5388   bool CanHaveConstParam = false;
5389   if (CSM == CXXCopyConstructor)
5390     CanHaveConstParam = RD->implicitCopyConstructorHasConstParam();
5391   else if (CSM == CXXCopyAssignment)
5392     CanHaveConstParam = RD->implicitCopyAssignmentHasConstParam();
5393 
5394   QualType ReturnType = Context.VoidTy;
5395   if (CSM == CXXCopyAssignment || CSM == CXXMoveAssignment) {
5396     // Check for return type matching.
5397     ReturnType = Type->getReturnType();
5398     QualType ExpectedReturnType =
5399         Context.getLValueReferenceType(Context.getTypeDeclType(RD));
5400     if (!Context.hasSameType(ReturnType, ExpectedReturnType)) {
5401       Diag(MD->getLocation(), diag::err_defaulted_special_member_return_type)
5402         << (CSM == CXXMoveAssignment) << ExpectedReturnType;
5403       HadError = true;
5404     }
5405 
5406     // A defaulted special member cannot have cv-qualifiers.
5407     if (Type->getTypeQuals()) {
5408       Diag(MD->getLocation(), diag::err_defaulted_special_member_quals)
5409         << (CSM == CXXMoveAssignment) << getLangOpts().CPlusPlus14;
5410       HadError = true;
5411     }
5412   }
5413 
5414   // Check for parameter type matching.
5415   QualType ArgType = ExpectedParams ? Type->getParamType(0) : QualType();
5416   bool HasConstParam = false;
5417   if (ExpectedParams && ArgType->isReferenceType()) {
5418     // Argument must be reference to possibly-const T.
5419     QualType ReferentType = ArgType->getPointeeType();
5420     HasConstParam = ReferentType.isConstQualified();
5421 
5422     if (ReferentType.isVolatileQualified()) {
5423       Diag(MD->getLocation(),
5424            diag::err_defaulted_special_member_volatile_param) << CSM;
5425       HadError = true;
5426     }
5427 
5428     if (HasConstParam && !CanHaveConstParam) {
5429       if (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment) {
5430         Diag(MD->getLocation(),
5431              diag::err_defaulted_special_member_copy_const_param)
5432           << (CSM == CXXCopyAssignment);
5433         // FIXME: Explain why this special member can't be const.
5434       } else {
5435         Diag(MD->getLocation(),
5436              diag::err_defaulted_special_member_move_const_param)
5437           << (CSM == CXXMoveAssignment);
5438       }
5439       HadError = true;
5440     }
5441   } else if (ExpectedParams) {
5442     // A copy assignment operator can take its argument by value, but a
5443     // defaulted one cannot.
5444     assert(CSM == CXXCopyAssignment && "unexpected non-ref argument");
5445     Diag(MD->getLocation(), diag::err_defaulted_copy_assign_not_ref);
5446     HadError = true;
5447   }
5448 
5449   // C++11 [dcl.fct.def.default]p2:
5450   //   An explicitly-defaulted function may be declared constexpr only if it
5451   //   would have been implicitly declared as constexpr,
5452   // Do not apply this rule to members of class templates, since core issue 1358
5453   // makes such functions always instantiate to constexpr functions. For
5454   // functions which cannot be constexpr (for non-constructors in C++11 and for
5455   // destructors in C++1y), this is checked elsewhere.
5456   bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
5457                                                      HasConstParam);
5458   if ((getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD)
5459                                  : isa<CXXConstructorDecl>(MD)) &&
5460       MD->isConstexpr() && !Constexpr &&
5461       MD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) {
5462     Diag(MD->getLocStart(), diag::err_incorrect_defaulted_constexpr) << CSM;
5463     // FIXME: Explain why the special member can't be constexpr.
5464     HadError = true;
5465   }
5466 
5467   //   and may have an explicit exception-specification only if it is compatible
5468   //   with the exception-specification on the implicit declaration.
5469   if (Type->hasExceptionSpec()) {
5470     // Delay the check if this is the first declaration of the special member,
5471     // since we may not have parsed some necessary in-class initializers yet.
5472     if (First) {
5473       // If the exception specification needs to be instantiated, do so now,
5474       // before we clobber it with an EST_Unevaluated specification below.
5475       if (Type->getExceptionSpecType() == EST_Uninstantiated) {
5476         InstantiateExceptionSpec(MD->getLocStart(), MD);
5477         Type = MD->getType()->getAs<FunctionProtoType>();
5478       }
5479       DelayedDefaultedMemberExceptionSpecs.push_back(std::make_pair(MD, Type));
5480     } else
5481       CheckExplicitlyDefaultedMemberExceptionSpec(MD, Type);
5482   }
5483 
5484   //   If a function is explicitly defaulted on its first declaration,
5485   if (First) {
5486     //  -- it is implicitly considered to be constexpr if the implicit
5487     //     definition would be,
5488     MD->setConstexpr(Constexpr);
5489 
5490     //  -- it is implicitly considered to have the same exception-specification
5491     //     as if it had been implicitly declared,
5492     FunctionProtoType::ExtProtoInfo EPI = Type->getExtProtoInfo();
5493     EPI.ExceptionSpec.Type = EST_Unevaluated;
5494     EPI.ExceptionSpec.SourceDecl = MD;
5495     MD->setType(Context.getFunctionType(ReturnType,
5496                                         llvm::makeArrayRef(&ArgType,
5497                                                            ExpectedParams),
5498                                         EPI));
5499   }
5500 
5501   if (ShouldDeleteSpecialMember(MD, CSM)) {
5502     if (First) {
5503       SetDeclDeleted(MD, MD->getLocation());
5504     } else {
5505       // C++11 [dcl.fct.def.default]p4:
5506       //   [For a] user-provided explicitly-defaulted function [...] if such a
5507       //   function is implicitly defined as deleted, the program is ill-formed.
5508       Diag(MD->getLocation(), diag::err_out_of_line_default_deletes) << CSM;
5509       ShouldDeleteSpecialMember(MD, CSM, nullptr, /*Diagnose*/true);
5510       HadError = true;
5511     }
5512   }
5513 
5514   if (HadError)
5515     MD->setInvalidDecl();
5516 }
5517 
5518 /// Check whether the exception specification provided for an
5519 /// explicitly-defaulted special member matches the exception specification
5520 /// that would have been generated for an implicit special member, per
5521 /// C++11 [dcl.fct.def.default]p2.
CheckExplicitlyDefaultedMemberExceptionSpec(CXXMethodDecl * MD,const FunctionProtoType * SpecifiedType)5522 void Sema::CheckExplicitlyDefaultedMemberExceptionSpec(
5523     CXXMethodDecl *MD, const FunctionProtoType *SpecifiedType) {
5524   // If the exception specification was explicitly specified but hadn't been
5525   // parsed when the method was defaulted, grab it now.
5526   if (SpecifiedType->getExceptionSpecType() == EST_Unparsed)
5527     SpecifiedType =
5528         MD->getTypeSourceInfo()->getType()->castAs<FunctionProtoType>();
5529 
5530   // Compute the implicit exception specification.
5531   CallingConv CC = Context.getDefaultCallingConvention(/*IsVariadic=*/false,
5532                                                        /*IsCXXMethod=*/true);
5533   FunctionProtoType::ExtProtoInfo EPI(CC);
5534   EPI.ExceptionSpec = computeImplicitExceptionSpec(*this, MD->getLocation(), MD)
5535                           .getExceptionSpec();
5536   const FunctionProtoType *ImplicitType = cast<FunctionProtoType>(
5537     Context.getFunctionType(Context.VoidTy, None, EPI));
5538 
5539   // Ensure that it matches.
5540   CheckEquivalentExceptionSpec(
5541     PDiag(diag::err_incorrect_defaulted_exception_spec)
5542       << getSpecialMember(MD), PDiag(),
5543     ImplicitType, SourceLocation(),
5544     SpecifiedType, MD->getLocation());
5545 }
5546 
CheckDelayedMemberExceptionSpecs()5547 void Sema::CheckDelayedMemberExceptionSpecs() {
5548   decltype(DelayedExceptionSpecChecks) Checks;
5549   decltype(DelayedDefaultedMemberExceptionSpecs) Specs;
5550 
5551   std::swap(Checks, DelayedExceptionSpecChecks);
5552   std::swap(Specs, DelayedDefaultedMemberExceptionSpecs);
5553 
5554   // Perform any deferred checking of exception specifications for virtual
5555   // destructors.
5556   for (auto &Check : Checks)
5557     CheckOverridingFunctionExceptionSpec(Check.first, Check.second);
5558 
5559   // Check that any explicitly-defaulted methods have exception specifications
5560   // compatible with their implicit exception specifications.
5561   for (auto &Spec : Specs)
5562     CheckExplicitlyDefaultedMemberExceptionSpec(Spec.first, Spec.second);
5563 }
5564 
5565 namespace {
5566 struct SpecialMemberDeletionInfo {
5567   Sema &S;
5568   CXXMethodDecl *MD;
5569   Sema::CXXSpecialMember CSM;
5570   Sema::InheritedConstructorInfo *ICI;
5571   bool Diagnose;
5572 
5573   // Properties of the special member, computed for convenience.
5574   bool IsConstructor, IsAssignment, IsMove, ConstArg;
5575   SourceLocation Loc;
5576 
5577   bool AllFieldsAreConst;
5578 
SpecialMemberDeletionInfo__anon92980ac10711::SpecialMemberDeletionInfo5579   SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD,
5580                             Sema::CXXSpecialMember CSM,
5581                             Sema::InheritedConstructorInfo *ICI, bool Diagnose)
5582       : S(S), MD(MD), CSM(CSM), ICI(ICI), Diagnose(Diagnose),
5583         IsConstructor(false), IsAssignment(false), IsMove(false),
5584         ConstArg(false), Loc(MD->getLocation()), AllFieldsAreConst(true) {
5585     switch (CSM) {
5586       case Sema::CXXDefaultConstructor:
5587       case Sema::CXXCopyConstructor:
5588         IsConstructor = true;
5589         break;
5590       case Sema::CXXMoveConstructor:
5591         IsConstructor = true;
5592         IsMove = true;
5593         break;
5594       case Sema::CXXCopyAssignment:
5595         IsAssignment = true;
5596         break;
5597       case Sema::CXXMoveAssignment:
5598         IsAssignment = true;
5599         IsMove = true;
5600         break;
5601       case Sema::CXXDestructor:
5602         break;
5603       case Sema::CXXInvalid:
5604         llvm_unreachable("invalid special member kind");
5605     }
5606 
5607     if (MD->getNumParams()) {
5608       if (const ReferenceType *RT =
5609               MD->getParamDecl(0)->getType()->getAs<ReferenceType>())
5610         ConstArg = RT->getPointeeType().isConstQualified();
5611     }
5612   }
5613 
inUnion__anon92980ac10711::SpecialMemberDeletionInfo5614   bool inUnion() const { return MD->getParent()->isUnion(); }
5615 
getEffectiveCSM__anon92980ac10711::SpecialMemberDeletionInfo5616   Sema::CXXSpecialMember getEffectiveCSM() {
5617     return ICI ? Sema::CXXInvalid : CSM;
5618   }
5619 
5620   /// Look up the corresponding special member in the given class.
lookupIn__anon92980ac10711::SpecialMemberDeletionInfo5621   Sema::SpecialMemberOverloadResult *lookupIn(CXXRecordDecl *Class,
5622                                               unsigned Quals, bool IsMutable) {
5623     return lookupCallFromSpecialMember(S, Class, CSM, Quals,
5624                                        ConstArg && !IsMutable);
5625   }
5626 
5627   typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
5628 
5629   bool shouldDeleteForBase(CXXBaseSpecifier *Base);
5630   bool shouldDeleteForField(FieldDecl *FD);
5631   bool shouldDeleteForAllConstMembers();
5632 
5633   bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
5634                                      unsigned Quals);
5635   bool shouldDeleteForSubobjectCall(Subobject Subobj,
5636                                     Sema::SpecialMemberOverloadResult *SMOR,
5637                                     bool IsDtorCallInCtor);
5638 
5639   bool isAccessible(Subobject Subobj, CXXMethodDecl *D);
5640 };
5641 }
5642 
5643 /// Is the given special member inaccessible when used on the given
5644 /// sub-object.
isAccessible(Subobject Subobj,CXXMethodDecl * target)5645 bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
5646                                              CXXMethodDecl *target) {
5647   /// If we're operating on a base class, the object type is the
5648   /// type of this special member.
5649   QualType objectTy;
5650   AccessSpecifier access = target->getAccess();
5651   if (CXXBaseSpecifier *base = Subobj.dyn_cast<CXXBaseSpecifier*>()) {
5652     objectTy = S.Context.getTypeDeclType(MD->getParent());
5653     access = CXXRecordDecl::MergeAccess(base->getAccessSpecifier(), access);
5654 
5655   // If we're operating on a field, the object type is the type of the field.
5656   } else {
5657     objectTy = S.Context.getTypeDeclType(target->getParent());
5658   }
5659 
5660   return S.isSpecialMemberAccessibleForDeletion(target, access, objectTy);
5661 }
5662 
5663 /// Check whether we should delete a special member due to the implicit
5664 /// definition containing a call to a special member of a subobject.
shouldDeleteForSubobjectCall(Subobject Subobj,Sema::SpecialMemberOverloadResult * SMOR,bool IsDtorCallInCtor)5665 bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
5666     Subobject Subobj, Sema::SpecialMemberOverloadResult *SMOR,
5667     bool IsDtorCallInCtor) {
5668   CXXMethodDecl *Decl = SMOR->getMethod();
5669   FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
5670 
5671   int DiagKind = -1;
5672 
5673   if (SMOR->getKind() == Sema::SpecialMemberOverloadResult::NoMemberOrDeleted)
5674     DiagKind = !Decl ? 0 : 1;
5675   else if (SMOR->getKind() == Sema::SpecialMemberOverloadResult::Ambiguous)
5676     DiagKind = 2;
5677   else if (!isAccessible(Subobj, Decl))
5678     DiagKind = 3;
5679   else if (!IsDtorCallInCtor && Field && Field->getParent()->isUnion() &&
5680            !Decl->isTrivial()) {
5681     // A member of a union must have a trivial corresponding special member.
5682     // As a weird special case, a destructor call from a union's constructor
5683     // must be accessible and non-deleted, but need not be trivial. Such a
5684     // destructor is never actually called, but is semantically checked as
5685     // if it were.
5686     DiagKind = 4;
5687   }
5688 
5689   if (DiagKind == -1)
5690     return false;
5691 
5692   if (Diagnose) {
5693     if (Field) {
5694       S.Diag(Field->getLocation(),
5695              diag::note_deleted_special_member_class_subobject)
5696         << getEffectiveCSM() << MD->getParent() << /*IsField*/true
5697         << Field << DiagKind << IsDtorCallInCtor;
5698     } else {
5699       CXXBaseSpecifier *Base = Subobj.get<CXXBaseSpecifier*>();
5700       S.Diag(Base->getLocStart(),
5701              diag::note_deleted_special_member_class_subobject)
5702         << getEffectiveCSM() << MD->getParent() << /*IsField*/false
5703         << Base->getType() << DiagKind << IsDtorCallInCtor;
5704     }
5705 
5706     if (DiagKind == 1)
5707       S.NoteDeletedFunction(Decl);
5708     // FIXME: Explain inaccessibility if DiagKind == 3.
5709   }
5710 
5711   return true;
5712 }
5713 
5714 /// Check whether we should delete a special member function due to having a
5715 /// direct or virtual base class or non-static data member of class type M.
shouldDeleteForClassSubobject(CXXRecordDecl * Class,Subobject Subobj,unsigned Quals)5716 bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
5717     CXXRecordDecl *Class, Subobject Subobj, unsigned Quals) {
5718   FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
5719   bool IsMutable = Field && Field->isMutable();
5720 
5721   // C++11 [class.ctor]p5:
5722   // -- any direct or virtual base class, or non-static data member with no
5723   //    brace-or-equal-initializer, has class type M (or array thereof) and
5724   //    either M has no default constructor or overload resolution as applied
5725   //    to M's default constructor results in an ambiguity or in a function
5726   //    that is deleted or inaccessible
5727   // C++11 [class.copy]p11, C++11 [class.copy]p23:
5728   // -- a direct or virtual base class B that cannot be copied/moved because
5729   //    overload resolution, as applied to B's corresponding special member,
5730   //    results in an ambiguity or a function that is deleted or inaccessible
5731   //    from the defaulted special member
5732   // C++11 [class.dtor]p5:
5733   // -- any direct or virtual base class [...] has a type with a destructor
5734   //    that is deleted or inaccessible
5735   if (!(CSM == Sema::CXXDefaultConstructor &&
5736         Field && Field->hasInClassInitializer()) &&
5737       shouldDeleteForSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable),
5738                                    false))
5739     return true;
5740 
5741   // C++11 [class.ctor]p5, C++11 [class.copy]p11:
5742   // -- any direct or virtual base class or non-static data member has a
5743   //    type with a destructor that is deleted or inaccessible
5744   if (IsConstructor) {
5745     Sema::SpecialMemberOverloadResult *SMOR =
5746         S.LookupSpecialMember(Class, Sema::CXXDestructor,
5747                               false, false, false, false, false);
5748     if (shouldDeleteForSubobjectCall(Subobj, SMOR, true))
5749       return true;
5750   }
5751 
5752   return false;
5753 }
5754 
5755 /// Check whether we should delete a special member function due to the class
5756 /// having a particular direct or virtual base class.
shouldDeleteForBase(CXXBaseSpecifier * Base)5757 bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
5758   CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
5759   // If program is correct, BaseClass cannot be null, but if it is, the error
5760   // must be reported elsewhere.
5761   if (!BaseClass)
5762     return false;
5763   // If we have an inheriting constructor, check whether we're calling an
5764   // inherited constructor instead of a default constructor.
5765   if (ICI) {
5766     assert(CSM == Sema::CXXDefaultConstructor);
5767     auto *BaseCtor =
5768         ICI->findConstructorForBase(BaseClass, cast<CXXConstructorDecl>(MD)
5769                                                    ->getInheritedConstructor()
5770                                                    .getConstructor())
5771             .first;
5772     if (BaseCtor) {
5773       if (BaseCtor->isDeleted() && Diagnose) {
5774         S.Diag(Base->getLocStart(),
5775                diag::note_deleted_special_member_class_subobject)
5776           << getEffectiveCSM() << MD->getParent() << /*IsField*/false
5777           << Base->getType() << /*Deleted*/1 << /*IsDtorCallInCtor*/false;
5778         S.NoteDeletedFunction(BaseCtor);
5779       }
5780       return BaseCtor->isDeleted();
5781     }
5782   }
5783   return shouldDeleteForClassSubobject(BaseClass, Base, 0);
5784 }
5785 
5786 /// Check whether we should delete a special member function due to the class
5787 /// having a particular non-static data member.
shouldDeleteForField(FieldDecl * FD)5788 bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) {
5789   QualType FieldType = S.Context.getBaseElementType(FD->getType());
5790   CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl();
5791 
5792   if (CSM == Sema::CXXDefaultConstructor) {
5793     // For a default constructor, all references must be initialized in-class
5794     // and, if a union, it must have a non-const member.
5795     if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) {
5796       if (Diagnose)
5797         S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
5798           << !!ICI << MD->getParent() << FD << FieldType << /*Reference*/0;
5799       return true;
5800     }
5801     // C++11 [class.ctor]p5: any non-variant non-static data member of
5802     // const-qualified type (or array thereof) with no
5803     // brace-or-equal-initializer does not have a user-provided default
5804     // constructor.
5805     if (!inUnion() && FieldType.isConstQualified() &&
5806         !FD->hasInClassInitializer() &&
5807         (!FieldRecord || !FieldRecord->hasUserProvidedDefaultConstructor())) {
5808       if (Diagnose)
5809         S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
5810           << !!ICI << MD->getParent() << FD << FD->getType() << /*Const*/1;
5811       return true;
5812     }
5813 
5814     if (inUnion() && !FieldType.isConstQualified())
5815       AllFieldsAreConst = false;
5816   } else if (CSM == Sema::CXXCopyConstructor) {
5817     // For a copy constructor, data members must not be of rvalue reference
5818     // type.
5819     if (FieldType->isRValueReferenceType()) {
5820       if (Diagnose)
5821         S.Diag(FD->getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
5822           << MD->getParent() << FD << FieldType;
5823       return true;
5824     }
5825   } else if (IsAssignment) {
5826     // For an assignment operator, data members must not be of reference type.
5827     if (FieldType->isReferenceType()) {
5828       if (Diagnose)
5829         S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
5830           << IsMove << MD->getParent() << FD << FieldType << /*Reference*/0;
5831       return true;
5832     }
5833     if (!FieldRecord && FieldType.isConstQualified()) {
5834       // C++11 [class.copy]p23:
5835       // -- a non-static data member of const non-class type (or array thereof)
5836       if (Diagnose)
5837         S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
5838           << IsMove << MD->getParent() << FD << FD->getType() << /*Const*/1;
5839       return true;
5840     }
5841   }
5842 
5843   if (FieldRecord) {
5844     // Some additional restrictions exist on the variant members.
5845     if (!inUnion() && FieldRecord->isUnion() &&
5846         FieldRecord->isAnonymousStructOrUnion()) {
5847       bool AllVariantFieldsAreConst = true;
5848 
5849       // FIXME: Handle anonymous unions declared within anonymous unions.
5850       for (auto *UI : FieldRecord->fields()) {
5851         QualType UnionFieldType = S.Context.getBaseElementType(UI->getType());
5852 
5853         if (!UnionFieldType.isConstQualified())
5854           AllVariantFieldsAreConst = false;
5855 
5856         CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl();
5857         if (UnionFieldRecord &&
5858             shouldDeleteForClassSubobject(UnionFieldRecord, UI,
5859                                           UnionFieldType.getCVRQualifiers()))
5860           return true;
5861       }
5862 
5863       // At least one member in each anonymous union must be non-const
5864       if (CSM == Sema::CXXDefaultConstructor && AllVariantFieldsAreConst &&
5865           !FieldRecord->field_empty()) {
5866         if (Diagnose)
5867           S.Diag(FieldRecord->getLocation(),
5868                  diag::note_deleted_default_ctor_all_const)
5869             << !!ICI << MD->getParent() << /*anonymous union*/1;
5870         return true;
5871       }
5872 
5873       // Don't check the implicit member of the anonymous union type.
5874       // This is technically non-conformant, but sanity demands it.
5875       return false;
5876     }
5877 
5878     if (shouldDeleteForClassSubobject(FieldRecord, FD,
5879                                       FieldType.getCVRQualifiers()))
5880       return true;
5881   }
5882 
5883   return false;
5884 }
5885 
5886 /// C++11 [class.ctor] p5:
5887 ///   A defaulted default constructor for a class X is defined as deleted if
5888 /// X is a union and all of its variant members are of const-qualified type.
shouldDeleteForAllConstMembers()5889 bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
5890   // This is a silly definition, because it gives an empty union a deleted
5891   // default constructor. Don't do that.
5892   if (CSM == Sema::CXXDefaultConstructor && inUnion() && AllFieldsAreConst &&
5893       !MD->getParent()->field_empty()) {
5894     if (Diagnose)
5895       S.Diag(MD->getParent()->getLocation(),
5896              diag::note_deleted_default_ctor_all_const)
5897         << !!ICI << MD->getParent() << /*not anonymous union*/0;
5898     return true;
5899   }
5900   return false;
5901 }
5902 
5903 /// Determine whether a defaulted special member function should be defined as
5904 /// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11,
5905 /// C++11 [class.copy]p23, and C++11 [class.dtor]p5.
ShouldDeleteSpecialMember(CXXMethodDecl * MD,CXXSpecialMember CSM,InheritedConstructorInfo * ICI,bool Diagnose)5906 bool Sema::ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
5907                                      InheritedConstructorInfo *ICI,
5908                                      bool Diagnose) {
5909   if (MD->isInvalidDecl())
5910     return false;
5911   CXXRecordDecl *RD = MD->getParent();
5912   assert(!RD->isDependentType() && "do deletion after instantiation");
5913   if (!LangOpts.CPlusPlus11 || RD->isInvalidDecl())
5914     return false;
5915 
5916   // C++11 [expr.lambda.prim]p19:
5917   //   The closure type associated with a lambda-expression has a
5918   //   deleted (8.4.3) default constructor and a deleted copy
5919   //   assignment operator.
5920   if (RD->isLambda() &&
5921       (CSM == CXXDefaultConstructor || CSM == CXXCopyAssignment)) {
5922     if (Diagnose)
5923       Diag(RD->getLocation(), diag::note_lambda_decl);
5924     return true;
5925   }
5926 
5927   // For an anonymous struct or union, the copy and assignment special members
5928   // will never be used, so skip the check. For an anonymous union declared at
5929   // namespace scope, the constructor and destructor are used.
5930   if (CSM != CXXDefaultConstructor && CSM != CXXDestructor &&
5931       RD->isAnonymousStructOrUnion())
5932     return false;
5933 
5934   // C++11 [class.copy]p7, p18:
5935   //   If the class definition declares a move constructor or move assignment
5936   //   operator, an implicitly declared copy constructor or copy assignment
5937   //   operator is defined as deleted.
5938   if (MD->isImplicit() &&
5939       (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment)) {
5940     CXXMethodDecl *UserDeclaredMove = nullptr;
5941 
5942     // In Microsoft mode, a user-declared move only causes the deletion of the
5943     // corresponding copy operation, not both copy operations.
5944     if (RD->hasUserDeclaredMoveConstructor() &&
5945         (!getLangOpts().MSVCCompat || CSM == CXXCopyConstructor)) {
5946       if (!Diagnose) return true;
5947 
5948       // Find any user-declared move constructor.
5949       for (auto *I : RD->ctors()) {
5950         if (I->isMoveConstructor()) {
5951           UserDeclaredMove = I;
5952           break;
5953         }
5954       }
5955       assert(UserDeclaredMove);
5956     } else if (RD->hasUserDeclaredMoveAssignment() &&
5957                (!getLangOpts().MSVCCompat || CSM == CXXCopyAssignment)) {
5958       if (!Diagnose) return true;
5959 
5960       // Find any user-declared move assignment operator.
5961       for (auto *I : RD->methods()) {
5962         if (I->isMoveAssignmentOperator()) {
5963           UserDeclaredMove = I;
5964           break;
5965         }
5966       }
5967       assert(UserDeclaredMove);
5968     }
5969 
5970     if (UserDeclaredMove) {
5971       Diag(UserDeclaredMove->getLocation(),
5972            diag::note_deleted_copy_user_declared_move)
5973         << (CSM == CXXCopyAssignment) << RD
5974         << UserDeclaredMove->isMoveAssignmentOperator();
5975       return true;
5976     }
5977   }
5978 
5979   // Do access control from the special member function
5980   ContextRAII MethodContext(*this, MD);
5981 
5982   // C++11 [class.dtor]p5:
5983   // -- for a virtual destructor, lookup of the non-array deallocation function
5984   //    results in an ambiguity or in a function that is deleted or inaccessible
5985   if (CSM == CXXDestructor && MD->isVirtual()) {
5986     FunctionDecl *OperatorDelete = nullptr;
5987     DeclarationName Name =
5988       Context.DeclarationNames.getCXXOperatorName(OO_Delete);
5989     if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name,
5990                                  OperatorDelete, false)) {
5991       if (Diagnose)
5992         Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete);
5993       return true;
5994     }
5995   }
5996 
5997   SpecialMemberDeletionInfo SMI(*this, MD, CSM, ICI, Diagnose);
5998 
5999   for (auto &BI : RD->bases())
6000     if (!BI.isVirtual() &&
6001         SMI.shouldDeleteForBase(&BI))
6002       return true;
6003 
6004   // Per DR1611, do not consider virtual bases of constructors of abstract
6005   // classes, since we are not going to construct them.
6006   if (!RD->isAbstract() || !SMI.IsConstructor) {
6007     for (auto &BI : RD->vbases())
6008       if (SMI.shouldDeleteForBase(&BI))
6009         return true;
6010   }
6011 
6012   for (auto *FI : RD->fields())
6013     if (!FI->isInvalidDecl() && !FI->isUnnamedBitfield() &&
6014         SMI.shouldDeleteForField(FI))
6015       return true;
6016 
6017   if (SMI.shouldDeleteForAllConstMembers())
6018     return true;
6019 
6020   if (getLangOpts().CUDA) {
6021     // We should delete the special member in CUDA mode if target inference
6022     // failed.
6023     return inferCUDATargetForImplicitSpecialMember(RD, CSM, MD, SMI.ConstArg,
6024                                                    Diagnose);
6025   }
6026 
6027   return false;
6028 }
6029 
6030 /// Perform lookup for a special member of the specified kind, and determine
6031 /// whether it is trivial. If the triviality can be determined without the
6032 /// lookup, skip it. This is intended for use when determining whether a
6033 /// special member of a containing object is trivial, and thus does not ever
6034 /// perform overload resolution for default constructors.
6035 ///
6036 /// If \p Selected is not \c NULL, \c *Selected will be filled in with the
6037 /// member that was most likely to be intended to be trivial, if any.
findTrivialSpecialMember(Sema & S,CXXRecordDecl * RD,Sema::CXXSpecialMember CSM,unsigned Quals,bool ConstRHS,CXXMethodDecl ** Selected)6038 static bool findTrivialSpecialMember(Sema &S, CXXRecordDecl *RD,
6039                                      Sema::CXXSpecialMember CSM, unsigned Quals,
6040                                      bool ConstRHS, CXXMethodDecl **Selected) {
6041   if (Selected)
6042     *Selected = nullptr;
6043 
6044   switch (CSM) {
6045   case Sema::CXXInvalid:
6046     llvm_unreachable("not a special member");
6047 
6048   case Sema::CXXDefaultConstructor:
6049     // C++11 [class.ctor]p5:
6050     //   A default constructor is trivial if:
6051     //    - all the [direct subobjects] have trivial default constructors
6052     //
6053     // Note, no overload resolution is performed in this case.
6054     if (RD->hasTrivialDefaultConstructor())
6055       return true;
6056 
6057     if (Selected) {
6058       // If there's a default constructor which could have been trivial, dig it
6059       // out. Otherwise, if there's any user-provided default constructor, point
6060       // to that as an example of why there's not a trivial one.
6061       CXXConstructorDecl *DefCtor = nullptr;
6062       if (RD->needsImplicitDefaultConstructor())
6063         S.DeclareImplicitDefaultConstructor(RD);
6064       for (auto *CI : RD->ctors()) {
6065         if (!CI->isDefaultConstructor())
6066           continue;
6067         DefCtor = CI;
6068         if (!DefCtor->isUserProvided())
6069           break;
6070       }
6071 
6072       *Selected = DefCtor;
6073     }
6074 
6075     return false;
6076 
6077   case Sema::CXXDestructor:
6078     // C++11 [class.dtor]p5:
6079     //   A destructor is trivial if:
6080     //    - all the direct [subobjects] have trivial destructors
6081     if (RD->hasTrivialDestructor())
6082       return true;
6083 
6084     if (Selected) {
6085       if (RD->needsImplicitDestructor())
6086         S.DeclareImplicitDestructor(RD);
6087       *Selected = RD->getDestructor();
6088     }
6089 
6090     return false;
6091 
6092   case Sema::CXXCopyConstructor:
6093     // C++11 [class.copy]p12:
6094     //   A copy constructor is trivial if:
6095     //    - the constructor selected to copy each direct [subobject] is trivial
6096     if (RD->hasTrivialCopyConstructor()) {
6097       if (Quals == Qualifiers::Const)
6098         // We must either select the trivial copy constructor or reach an
6099         // ambiguity; no need to actually perform overload resolution.
6100         return true;
6101     } else if (!Selected) {
6102       return false;
6103     }
6104     // In C++98, we are not supposed to perform overload resolution here, but we
6105     // treat that as a language defect, as suggested on cxx-abi-dev, to treat
6106     // cases like B as having a non-trivial copy constructor:
6107     //   struct A { template<typename T> A(T&); };
6108     //   struct B { mutable A a; };
6109     goto NeedOverloadResolution;
6110 
6111   case Sema::CXXCopyAssignment:
6112     // C++11 [class.copy]p25:
6113     //   A copy assignment operator is trivial if:
6114     //    - the assignment operator selected to copy each direct [subobject] is
6115     //      trivial
6116     if (RD->hasTrivialCopyAssignment()) {
6117       if (Quals == Qualifiers::Const)
6118         return true;
6119     } else if (!Selected) {
6120       return false;
6121     }
6122     // In C++98, we are not supposed to perform overload resolution here, but we
6123     // treat that as a language defect.
6124     goto NeedOverloadResolution;
6125 
6126   case Sema::CXXMoveConstructor:
6127   case Sema::CXXMoveAssignment:
6128   NeedOverloadResolution:
6129     Sema::SpecialMemberOverloadResult *SMOR =
6130         lookupCallFromSpecialMember(S, RD, CSM, Quals, ConstRHS);
6131 
6132     // The standard doesn't describe how to behave if the lookup is ambiguous.
6133     // We treat it as not making the member non-trivial, just like the standard
6134     // mandates for the default constructor. This should rarely matter, because
6135     // the member will also be deleted.
6136     if (SMOR->getKind() == Sema::SpecialMemberOverloadResult::Ambiguous)
6137       return true;
6138 
6139     if (!SMOR->getMethod()) {
6140       assert(SMOR->getKind() ==
6141              Sema::SpecialMemberOverloadResult::NoMemberOrDeleted);
6142       return false;
6143     }
6144 
6145     // We deliberately don't check if we found a deleted special member. We're
6146     // not supposed to!
6147     if (Selected)
6148       *Selected = SMOR->getMethod();
6149     return SMOR->getMethod()->isTrivial();
6150   }
6151 
6152   llvm_unreachable("unknown special method kind");
6153 }
6154 
findUserDeclaredCtor(CXXRecordDecl * RD)6155 static CXXConstructorDecl *findUserDeclaredCtor(CXXRecordDecl *RD) {
6156   for (auto *CI : RD->ctors())
6157     if (!CI->isImplicit())
6158       return CI;
6159 
6160   // Look for constructor templates.
6161   typedef CXXRecordDecl::specific_decl_iterator<FunctionTemplateDecl> tmpl_iter;
6162   for (tmpl_iter TI(RD->decls_begin()), TE(RD->decls_end()); TI != TE; ++TI) {
6163     if (CXXConstructorDecl *CD =
6164           dyn_cast<CXXConstructorDecl>(TI->getTemplatedDecl()))
6165       return CD;
6166   }
6167 
6168   return nullptr;
6169 }
6170 
6171 /// The kind of subobject we are checking for triviality. The values of this
6172 /// enumeration are used in diagnostics.
6173 enum TrivialSubobjectKind {
6174   /// The subobject is a base class.
6175   TSK_BaseClass,
6176   /// The subobject is a non-static data member.
6177   TSK_Field,
6178   /// The object is actually the complete object.
6179   TSK_CompleteObject
6180 };
6181 
6182 /// Check whether the special member selected for a given type would be trivial.
checkTrivialSubobjectCall(Sema & S,SourceLocation SubobjLoc,QualType SubType,bool ConstRHS,Sema::CXXSpecialMember CSM,TrivialSubobjectKind Kind,bool Diagnose)6183 static bool checkTrivialSubobjectCall(Sema &S, SourceLocation SubobjLoc,
6184                                       QualType SubType, bool ConstRHS,
6185                                       Sema::CXXSpecialMember CSM,
6186                                       TrivialSubobjectKind Kind,
6187                                       bool Diagnose) {
6188   CXXRecordDecl *SubRD = SubType->getAsCXXRecordDecl();
6189   if (!SubRD)
6190     return true;
6191 
6192   CXXMethodDecl *Selected;
6193   if (findTrivialSpecialMember(S, SubRD, CSM, SubType.getCVRQualifiers(),
6194                                ConstRHS, Diagnose ? &Selected : nullptr))
6195     return true;
6196 
6197   if (Diagnose) {
6198     if (ConstRHS)
6199       SubType.addConst();
6200 
6201     if (!Selected && CSM == Sema::CXXDefaultConstructor) {
6202       S.Diag(SubobjLoc, diag::note_nontrivial_no_def_ctor)
6203         << Kind << SubType.getUnqualifiedType();
6204       if (CXXConstructorDecl *CD = findUserDeclaredCtor(SubRD))
6205         S.Diag(CD->getLocation(), diag::note_user_declared_ctor);
6206     } else if (!Selected)
6207       S.Diag(SubobjLoc, diag::note_nontrivial_no_copy)
6208         << Kind << SubType.getUnqualifiedType() << CSM << SubType;
6209     else if (Selected->isUserProvided()) {
6210       if (Kind == TSK_CompleteObject)
6211         S.Diag(Selected->getLocation(), diag::note_nontrivial_user_provided)
6212           << Kind << SubType.getUnqualifiedType() << CSM;
6213       else {
6214         S.Diag(SubobjLoc, diag::note_nontrivial_user_provided)
6215           << Kind << SubType.getUnqualifiedType() << CSM;
6216         S.Diag(Selected->getLocation(), diag::note_declared_at);
6217       }
6218     } else {
6219       if (Kind != TSK_CompleteObject)
6220         S.Diag(SubobjLoc, diag::note_nontrivial_subobject)
6221           << Kind << SubType.getUnqualifiedType() << CSM;
6222 
6223       // Explain why the defaulted or deleted special member isn't trivial.
6224       S.SpecialMemberIsTrivial(Selected, CSM, Diagnose);
6225     }
6226   }
6227 
6228   return false;
6229 }
6230 
6231 /// Check whether the members of a class type allow a special member to be
6232 /// trivial.
checkTrivialClassMembers(Sema & S,CXXRecordDecl * RD,Sema::CXXSpecialMember CSM,bool ConstArg,bool Diagnose)6233 static bool checkTrivialClassMembers(Sema &S, CXXRecordDecl *RD,
6234                                      Sema::CXXSpecialMember CSM,
6235                                      bool ConstArg, bool Diagnose) {
6236   for (const auto *FI : RD->fields()) {
6237     if (FI->isInvalidDecl() || FI->isUnnamedBitfield())
6238       continue;
6239 
6240     QualType FieldType = S.Context.getBaseElementType(FI->getType());
6241 
6242     // Pretend anonymous struct or union members are members of this class.
6243     if (FI->isAnonymousStructOrUnion()) {
6244       if (!checkTrivialClassMembers(S, FieldType->getAsCXXRecordDecl(),
6245                                     CSM, ConstArg, Diagnose))
6246         return false;
6247       continue;
6248     }
6249 
6250     // C++11 [class.ctor]p5:
6251     //   A default constructor is trivial if [...]
6252     //    -- no non-static data member of its class has a
6253     //       brace-or-equal-initializer
6254     if (CSM == Sema::CXXDefaultConstructor && FI->hasInClassInitializer()) {
6255       if (Diagnose)
6256         S.Diag(FI->getLocation(), diag::note_nontrivial_in_class_init) << FI;
6257       return false;
6258     }
6259 
6260     // Objective C ARC 4.3.5:
6261     //   [...] nontrivally ownership-qualified types are [...] not trivially
6262     //   default constructible, copy constructible, move constructible, copy
6263     //   assignable, move assignable, or destructible [...]
6264     if (S.getLangOpts().ObjCAutoRefCount &&
6265         FieldType.hasNonTrivialObjCLifetime()) {
6266       if (Diagnose)
6267         S.Diag(FI->getLocation(), diag::note_nontrivial_objc_ownership)
6268           << RD << FieldType.getObjCLifetime();
6269       return false;
6270     }
6271 
6272     bool ConstRHS = ConstArg && !FI->isMutable();
6273     if (!checkTrivialSubobjectCall(S, FI->getLocation(), FieldType, ConstRHS,
6274                                    CSM, TSK_Field, Diagnose))
6275       return false;
6276   }
6277 
6278   return true;
6279 }
6280 
6281 /// Diagnose why the specified class does not have a trivial special member of
6282 /// the given kind.
DiagnoseNontrivial(const CXXRecordDecl * RD,CXXSpecialMember CSM)6283 void Sema::DiagnoseNontrivial(const CXXRecordDecl *RD, CXXSpecialMember CSM) {
6284   QualType Ty = Context.getRecordType(RD);
6285 
6286   bool ConstArg = (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment);
6287   checkTrivialSubobjectCall(*this, RD->getLocation(), Ty, ConstArg, CSM,
6288                             TSK_CompleteObject, /*Diagnose*/true);
6289 }
6290 
6291 /// Determine whether a defaulted or deleted special member function is trivial,
6292 /// as specified in C++11 [class.ctor]p5, C++11 [class.copy]p12,
6293 /// C++11 [class.copy]p25, and C++11 [class.dtor]p5.
SpecialMemberIsTrivial(CXXMethodDecl * MD,CXXSpecialMember CSM,bool Diagnose)6294 bool Sema::SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM,
6295                                   bool Diagnose) {
6296   assert(!MD->isUserProvided() && CSM != CXXInvalid && "not special enough");
6297 
6298   CXXRecordDecl *RD = MD->getParent();
6299 
6300   bool ConstArg = false;
6301 
6302   // C++11 [class.copy]p12, p25: [DR1593]
6303   //   A [special member] is trivial if [...] its parameter-type-list is
6304   //   equivalent to the parameter-type-list of an implicit declaration [...]
6305   switch (CSM) {
6306   case CXXDefaultConstructor:
6307   case CXXDestructor:
6308     // Trivial default constructors and destructors cannot have parameters.
6309     break;
6310 
6311   case CXXCopyConstructor:
6312   case CXXCopyAssignment: {
6313     // Trivial copy operations always have const, non-volatile parameter types.
6314     ConstArg = true;
6315     const ParmVarDecl *Param0 = MD->getParamDecl(0);
6316     const ReferenceType *RT = Param0->getType()->getAs<ReferenceType>();
6317     if (!RT || RT->getPointeeType().getCVRQualifiers() != Qualifiers::Const) {
6318       if (Diagnose)
6319         Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
6320           << Param0->getSourceRange() << Param0->getType()
6321           << Context.getLValueReferenceType(
6322                Context.getRecordType(RD).withConst());
6323       return false;
6324     }
6325     break;
6326   }
6327 
6328   case CXXMoveConstructor:
6329   case CXXMoveAssignment: {
6330     // Trivial move operations always have non-cv-qualified parameters.
6331     const ParmVarDecl *Param0 = MD->getParamDecl(0);
6332     const RValueReferenceType *RT =
6333       Param0->getType()->getAs<RValueReferenceType>();
6334     if (!RT || RT->getPointeeType().getCVRQualifiers()) {
6335       if (Diagnose)
6336         Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
6337           << Param0->getSourceRange() << Param0->getType()
6338           << Context.getRValueReferenceType(Context.getRecordType(RD));
6339       return false;
6340     }
6341     break;
6342   }
6343 
6344   case CXXInvalid:
6345     llvm_unreachable("not a special member");
6346   }
6347 
6348   if (MD->getMinRequiredArguments() < MD->getNumParams()) {
6349     if (Diagnose)
6350       Diag(MD->getParamDecl(MD->getMinRequiredArguments())->getLocation(),
6351            diag::note_nontrivial_default_arg)
6352         << MD->getParamDecl(MD->getMinRequiredArguments())->getSourceRange();
6353     return false;
6354   }
6355   if (MD->isVariadic()) {
6356     if (Diagnose)
6357       Diag(MD->getLocation(), diag::note_nontrivial_variadic);
6358     return false;
6359   }
6360 
6361   // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
6362   //   A copy/move [constructor or assignment operator] is trivial if
6363   //    -- the [member] selected to copy/move each direct base class subobject
6364   //       is trivial
6365   //
6366   // C++11 [class.copy]p12, C++11 [class.copy]p25:
6367   //   A [default constructor or destructor] is trivial if
6368   //    -- all the direct base classes have trivial [default constructors or
6369   //       destructors]
6370   for (const auto &BI : RD->bases())
6371     if (!checkTrivialSubobjectCall(*this, BI.getLocStart(), BI.getType(),
6372                                    ConstArg, CSM, TSK_BaseClass, Diagnose))
6373       return false;
6374 
6375   // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
6376   //   A copy/move [constructor or assignment operator] for a class X is
6377   //   trivial if
6378   //    -- for each non-static data member of X that is of class type (or array
6379   //       thereof), the constructor selected to copy/move that member is
6380   //       trivial
6381   //
6382   // C++11 [class.copy]p12, C++11 [class.copy]p25:
6383   //   A [default constructor or destructor] is trivial if
6384   //    -- for all of the non-static data members of its class that are of class
6385   //       type (or array thereof), each such class has a trivial [default
6386   //       constructor or destructor]
6387   if (!checkTrivialClassMembers(*this, RD, CSM, ConstArg, Diagnose))
6388     return false;
6389 
6390   // C++11 [class.dtor]p5:
6391   //   A destructor is trivial if [...]
6392   //    -- the destructor is not virtual
6393   if (CSM == CXXDestructor && MD->isVirtual()) {
6394     if (Diagnose)
6395       Diag(MD->getLocation(), diag::note_nontrivial_virtual_dtor) << RD;
6396     return false;
6397   }
6398 
6399   // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
6400   //   A [special member] for class X is trivial if [...]
6401   //    -- class X has no virtual functions and no virtual base classes
6402   if (CSM != CXXDestructor && MD->getParent()->isDynamicClass()) {
6403     if (!Diagnose)
6404       return false;
6405 
6406     if (RD->getNumVBases()) {
6407       // Check for virtual bases. We already know that the corresponding
6408       // member in all bases is trivial, so vbases must all be direct.
6409       CXXBaseSpecifier &BS = *RD->vbases_begin();
6410       assert(BS.isVirtual());
6411       Diag(BS.getLocStart(), diag::note_nontrivial_has_virtual) << RD << 1;
6412       return false;
6413     }
6414 
6415     // Must have a virtual method.
6416     for (const auto *MI : RD->methods()) {
6417       if (MI->isVirtual()) {
6418         SourceLocation MLoc = MI->getLocStart();
6419         Diag(MLoc, diag::note_nontrivial_has_virtual) << RD << 0;
6420         return false;
6421       }
6422     }
6423 
6424     llvm_unreachable("dynamic class with no vbases and no virtual functions");
6425   }
6426 
6427   // Looks like it's trivial!
6428   return true;
6429 }
6430 
6431 namespace {
6432 struct FindHiddenVirtualMethod {
6433   Sema *S;
6434   CXXMethodDecl *Method;
6435   llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
6436   SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
6437 
6438 private:
6439   /// Check whether any most overriden method from MD in Methods
CheckMostOverridenMethods__anon92980ac10811::FindHiddenVirtualMethod6440   static bool CheckMostOverridenMethods(
6441       const CXXMethodDecl *MD,
6442       const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
6443     if (MD->size_overridden_methods() == 0)
6444       return Methods.count(MD->getCanonicalDecl());
6445     for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
6446                                         E = MD->end_overridden_methods();
6447          I != E; ++I)
6448       if (CheckMostOverridenMethods(*I, Methods))
6449         return true;
6450     return false;
6451   }
6452 
6453 public:
6454   /// Member lookup function that determines whether a given C++
6455   /// method overloads virtual methods in a base class without overriding any,
6456   /// to be used with CXXRecordDecl::lookupInBases().
operator ()__anon92980ac10811::FindHiddenVirtualMethod6457   bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
6458     RecordDecl *BaseRecord =
6459         Specifier->getType()->getAs<RecordType>()->getDecl();
6460 
6461     DeclarationName Name = Method->getDeclName();
6462     assert(Name.getNameKind() == DeclarationName::Identifier);
6463 
6464     bool foundSameNameMethod = false;
6465     SmallVector<CXXMethodDecl *, 8> overloadedMethods;
6466     for (Path.Decls = BaseRecord->lookup(Name); !Path.Decls.empty();
6467          Path.Decls = Path.Decls.slice(1)) {
6468       NamedDecl *D = Path.Decls.front();
6469       if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
6470         MD = MD->getCanonicalDecl();
6471         foundSameNameMethod = true;
6472         // Interested only in hidden virtual methods.
6473         if (!MD->isVirtual())
6474           continue;
6475         // If the method we are checking overrides a method from its base
6476         // don't warn about the other overloaded methods. Clang deviates from
6477         // GCC by only diagnosing overloads of inherited virtual functions that
6478         // do not override any other virtual functions in the base. GCC's
6479         // -Woverloaded-virtual diagnoses any derived function hiding a virtual
6480         // function from a base class. These cases may be better served by a
6481         // warning (not specific to virtual functions) on call sites when the
6482         // call would select a different function from the base class, were it
6483         // visible.
6484         // See FIXME in test/SemaCXX/warn-overload-virtual.cpp for an example.
6485         if (!S->IsOverload(Method, MD, false))
6486           return true;
6487         // Collect the overload only if its hidden.
6488         if (!CheckMostOverridenMethods(MD, OverridenAndUsingBaseMethods))
6489           overloadedMethods.push_back(MD);
6490       }
6491     }
6492 
6493     if (foundSameNameMethod)
6494       OverloadedMethods.append(overloadedMethods.begin(),
6495                                overloadedMethods.end());
6496     return foundSameNameMethod;
6497   }
6498 };
6499 } // end anonymous namespace
6500 
6501 /// \brief Add the most overriden methods from MD to Methods
AddMostOverridenMethods(const CXXMethodDecl * MD,llvm::SmallPtrSetImpl<const CXXMethodDecl * > & Methods)6502 static void AddMostOverridenMethods(const CXXMethodDecl *MD,
6503                         llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
6504   if (MD->size_overridden_methods() == 0)
6505     Methods.insert(MD->getCanonicalDecl());
6506   for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
6507                                       E = MD->end_overridden_methods();
6508        I != E; ++I)
6509     AddMostOverridenMethods(*I, Methods);
6510 }
6511 
6512 /// \brief Check if a method overloads virtual methods in a base class without
6513 /// overriding any.
FindHiddenVirtualMethods(CXXMethodDecl * MD,SmallVectorImpl<CXXMethodDecl * > & OverloadedMethods)6514 void Sema::FindHiddenVirtualMethods(CXXMethodDecl *MD,
6515                           SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
6516   if (!MD->getDeclName().isIdentifier())
6517     return;
6518 
6519   CXXBasePaths Paths(/*FindAmbiguities=*/true, // true to look in all bases.
6520                      /*bool RecordPaths=*/false,
6521                      /*bool DetectVirtual=*/false);
6522   FindHiddenVirtualMethod FHVM;
6523   FHVM.Method = MD;
6524   FHVM.S = this;
6525 
6526   // Keep the base methods that were overriden or introduced in the subclass
6527   // by 'using' in a set. A base method not in this set is hidden.
6528   CXXRecordDecl *DC = MD->getParent();
6529   DeclContext::lookup_result R = DC->lookup(MD->getDeclName());
6530   for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
6531     NamedDecl *ND = *I;
6532     if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*I))
6533       ND = shad->getTargetDecl();
6534     if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND))
6535       AddMostOverridenMethods(MD, FHVM.OverridenAndUsingBaseMethods);
6536   }
6537 
6538   if (DC->lookupInBases(FHVM, Paths))
6539     OverloadedMethods = FHVM.OverloadedMethods;
6540 }
6541 
NoteHiddenVirtualMethods(CXXMethodDecl * MD,SmallVectorImpl<CXXMethodDecl * > & OverloadedMethods)6542 void Sema::NoteHiddenVirtualMethods(CXXMethodDecl *MD,
6543                           SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
6544   for (unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) {
6545     CXXMethodDecl *overloadedMD = OverloadedMethods[i];
6546     PartialDiagnostic PD = PDiag(
6547          diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
6548     HandleFunctionTypeMismatch(PD, MD->getType(), overloadedMD->getType());
6549     Diag(overloadedMD->getLocation(), PD);
6550   }
6551 }
6552 
6553 /// \brief Diagnose methods which overload virtual methods in a base class
6554 /// without overriding any.
DiagnoseHiddenVirtualMethods(CXXMethodDecl * MD)6555 void Sema::DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD) {
6556   if (MD->isInvalidDecl())
6557     return;
6558 
6559   if (Diags.isIgnored(diag::warn_overloaded_virtual, MD->getLocation()))
6560     return;
6561 
6562   SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
6563   FindHiddenVirtualMethods(MD, OverloadedMethods);
6564   if (!OverloadedMethods.empty()) {
6565     Diag(MD->getLocation(), diag::warn_overloaded_virtual)
6566       << MD << (OverloadedMethods.size() > 1);
6567 
6568     NoteHiddenVirtualMethods(MD, OverloadedMethods);
6569   }
6570 }
6571 
ActOnFinishCXXMemberSpecification(Scope * S,SourceLocation RLoc,Decl * TagDecl,SourceLocation LBrac,SourceLocation RBrac,AttributeList * AttrList)6572 void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
6573                                              Decl *TagDecl,
6574                                              SourceLocation LBrac,
6575                                              SourceLocation RBrac,
6576                                              AttributeList *AttrList) {
6577   if (!TagDecl)
6578     return;
6579 
6580   AdjustDeclIfTemplate(TagDecl);
6581 
6582   for (const AttributeList* l = AttrList; l; l = l->getNext()) {
6583     if (l->getKind() != AttributeList::AT_Visibility)
6584       continue;
6585     l->setInvalid();
6586     Diag(l->getLoc(), diag::warn_attribute_after_definition_ignored) <<
6587       l->getName();
6588   }
6589 
6590   ActOnFields(S, RLoc, TagDecl, llvm::makeArrayRef(
6591               // strict aliasing violation!
6592               reinterpret_cast<Decl**>(FieldCollector->getCurFields()),
6593               FieldCollector->getCurNumFields()), LBrac, RBrac, AttrList);
6594 
6595   CheckCompletedCXXClass(
6596                         dyn_cast_or_null<CXXRecordDecl>(TagDecl));
6597 }
6598 
6599 /// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
6600 /// special functions, such as the default constructor, copy
6601 /// constructor, or destructor, to the given C++ class (C++
6602 /// [special]p1).  This routine can only be executed just before the
6603 /// definition of the class is complete.
AddImplicitlyDeclaredMembersToClass(CXXRecordDecl * ClassDecl)6604 void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
6605   if (ClassDecl->needsImplicitDefaultConstructor()) {
6606     ++ASTContext::NumImplicitDefaultConstructors;
6607 
6608     if (ClassDecl->hasInheritedConstructor())
6609       DeclareImplicitDefaultConstructor(ClassDecl);
6610   }
6611 
6612   if (ClassDecl->needsImplicitCopyConstructor()) {
6613     ++ASTContext::NumImplicitCopyConstructors;
6614 
6615     // If the properties or semantics of the copy constructor couldn't be
6616     // determined while the class was being declared, force a declaration
6617     // of it now.
6618     if (ClassDecl->needsOverloadResolutionForCopyConstructor() ||
6619         ClassDecl->hasInheritedConstructor())
6620       DeclareImplicitCopyConstructor(ClassDecl);
6621   }
6622 
6623   if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveConstructor()) {
6624     ++ASTContext::NumImplicitMoveConstructors;
6625 
6626     if (ClassDecl->needsOverloadResolutionForMoveConstructor() ||
6627         ClassDecl->hasInheritedConstructor())
6628       DeclareImplicitMoveConstructor(ClassDecl);
6629   }
6630 
6631   if (ClassDecl->needsImplicitCopyAssignment()) {
6632     ++ASTContext::NumImplicitCopyAssignmentOperators;
6633 
6634     // If we have a dynamic class, then the copy assignment operator may be
6635     // virtual, so we have to declare it immediately. This ensures that, e.g.,
6636     // it shows up in the right place in the vtable and that we diagnose
6637     // problems with the implicit exception specification.
6638     if (ClassDecl->isDynamicClass() ||
6639         ClassDecl->needsOverloadResolutionForCopyAssignment() ||
6640         ClassDecl->hasInheritedAssignment())
6641       DeclareImplicitCopyAssignment(ClassDecl);
6642   }
6643 
6644   if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveAssignment()) {
6645     ++ASTContext::NumImplicitMoveAssignmentOperators;
6646 
6647     // Likewise for the move assignment operator.
6648     if (ClassDecl->isDynamicClass() ||
6649         ClassDecl->needsOverloadResolutionForMoveAssignment() ||
6650         ClassDecl->hasInheritedAssignment())
6651       DeclareImplicitMoveAssignment(ClassDecl);
6652   }
6653 
6654   if (ClassDecl->needsImplicitDestructor()) {
6655     ++ASTContext::NumImplicitDestructors;
6656 
6657     // If we have a dynamic class, then the destructor may be virtual, so we
6658     // have to declare the destructor immediately. This ensures that, e.g., it
6659     // shows up in the right place in the vtable and that we diagnose problems
6660     // with the implicit exception specification.
6661     if (ClassDecl->isDynamicClass() ||
6662         ClassDecl->needsOverloadResolutionForDestructor())
6663       DeclareImplicitDestructor(ClassDecl);
6664   }
6665 }
6666 
ActOnReenterTemplateScope(Scope * S,Decl * D)6667 unsigned Sema::ActOnReenterTemplateScope(Scope *S, Decl *D) {
6668   if (!D)
6669     return 0;
6670 
6671   // The order of template parameters is not important here. All names
6672   // get added to the same scope.
6673   SmallVector<TemplateParameterList *, 4> ParameterLists;
6674 
6675   if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
6676     D = TD->getTemplatedDecl();
6677 
6678   if (auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
6679     ParameterLists.push_back(PSD->getTemplateParameters());
6680 
6681   if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
6682     for (unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
6683       ParameterLists.push_back(DD->getTemplateParameterList(i));
6684 
6685     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
6686       if (FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
6687         ParameterLists.push_back(FTD->getTemplateParameters());
6688     }
6689   }
6690 
6691   if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
6692     for (unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
6693       ParameterLists.push_back(TD->getTemplateParameterList(i));
6694 
6695     if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD)) {
6696       if (ClassTemplateDecl *CTD = RD->getDescribedClassTemplate())
6697         ParameterLists.push_back(CTD->getTemplateParameters());
6698     }
6699   }
6700 
6701   unsigned Count = 0;
6702   for (TemplateParameterList *Params : ParameterLists) {
6703     if (Params->size() > 0)
6704       // Ignore explicit specializations; they don't contribute to the template
6705       // depth.
6706       ++Count;
6707     for (NamedDecl *Param : *Params) {
6708       if (Param->getDeclName()) {
6709         S->AddDecl(Param);
6710         IdResolver.AddDecl(Param);
6711       }
6712     }
6713   }
6714 
6715   return Count;
6716 }
6717 
ActOnStartDelayedMemberDeclarations(Scope * S,Decl * RecordD)6718 void Sema::ActOnStartDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
6719   if (!RecordD) return;
6720   AdjustDeclIfTemplate(RecordD);
6721   CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD);
6722   PushDeclContext(S, Record);
6723 }
6724 
ActOnFinishDelayedMemberDeclarations(Scope * S,Decl * RecordD)6725 void Sema::ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
6726   if (!RecordD) return;
6727   PopDeclContext();
6728 }
6729 
6730 /// This is used to implement the constant expression evaluation part of the
6731 /// attribute enable_if extension. There is nothing in standard C++ which would
6732 /// require reentering parameters.
ActOnReenterCXXMethodParameter(Scope * S,ParmVarDecl * Param)6733 void Sema::ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param) {
6734   if (!Param)
6735     return;
6736 
6737   S->AddDecl(Param);
6738   if (Param->getDeclName())
6739     IdResolver.AddDecl(Param);
6740 }
6741 
6742 /// ActOnStartDelayedCXXMethodDeclaration - We have completed
6743 /// parsing a top-level (non-nested) C++ class, and we are now
6744 /// parsing those parts of the given Method declaration that could
6745 /// not be parsed earlier (C++ [class.mem]p2), such as default
6746 /// arguments. This action should enter the scope of the given
6747 /// Method declaration as if we had just parsed the qualified method
6748 /// name. However, it should not bring the parameters into scope;
6749 /// that will be performed by ActOnDelayedCXXMethodParameter.
ActOnStartDelayedCXXMethodDeclaration(Scope * S,Decl * MethodD)6750 void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
6751 }
6752 
6753 /// ActOnDelayedCXXMethodParameter - We've already started a delayed
6754 /// C++ method declaration. We're (re-)introducing the given
6755 /// function parameter into scope for use in parsing later parts of
6756 /// the method declaration. For example, we could see an
6757 /// ActOnParamDefaultArgument event for this parameter.
ActOnDelayedCXXMethodParameter(Scope * S,Decl * ParamD)6758 void Sema::ActOnDelayedCXXMethodParameter(Scope *S, Decl *ParamD) {
6759   if (!ParamD)
6760     return;
6761 
6762   ParmVarDecl *Param = cast<ParmVarDecl>(ParamD);
6763 
6764   // If this parameter has an unparsed default argument, clear it out
6765   // to make way for the parsed default argument.
6766   if (Param->hasUnparsedDefaultArg())
6767     Param->setDefaultArg(nullptr);
6768 
6769   S->AddDecl(Param);
6770   if (Param->getDeclName())
6771     IdResolver.AddDecl(Param);
6772 }
6773 
6774 /// ActOnFinishDelayedCXXMethodDeclaration - We have finished
6775 /// processing the delayed method declaration for Method. The method
6776 /// declaration is now considered finished. There may be a separate
6777 /// ActOnStartOfFunctionDef action later (not necessarily
6778 /// immediately!) for this method, if it was also defined inside the
6779 /// class body.
ActOnFinishDelayedCXXMethodDeclaration(Scope * S,Decl * MethodD)6780 void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
6781   if (!MethodD)
6782     return;
6783 
6784   AdjustDeclIfTemplate(MethodD);
6785 
6786   FunctionDecl *Method = cast<FunctionDecl>(MethodD);
6787 
6788   // Now that we have our default arguments, check the constructor
6789   // again. It could produce additional diagnostics or affect whether
6790   // the class has implicitly-declared destructors, among other
6791   // things.
6792   if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
6793     CheckConstructor(Constructor);
6794 
6795   // Check the default arguments, which we may have added.
6796   if (!Method->isInvalidDecl())
6797     CheckCXXDefaultArguments(Method);
6798 }
6799 
6800 /// CheckConstructorDeclarator - Called by ActOnDeclarator to check
6801 /// the well-formedness of the constructor declarator @p D with type @p
6802 /// R. If there are any errors in the declarator, this routine will
6803 /// emit diagnostics and set the invalid bit to true.  In any case, the type
6804 /// will be updated to reflect a well-formed type for the constructor and
6805 /// returned.
CheckConstructorDeclarator(Declarator & D,QualType R,StorageClass & SC)6806 QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
6807                                           StorageClass &SC) {
6808   bool isVirtual = D.getDeclSpec().isVirtualSpecified();
6809 
6810   // C++ [class.ctor]p3:
6811   //   A constructor shall not be virtual (10.3) or static (9.4). A
6812   //   constructor can be invoked for a const, volatile or const
6813   //   volatile object. A constructor shall not be declared const,
6814   //   volatile, or const volatile (9.3.2).
6815   if (isVirtual) {
6816     if (!D.isInvalidType())
6817       Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
6818         << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
6819         << SourceRange(D.getIdentifierLoc());
6820     D.setInvalidType();
6821   }
6822   if (SC == SC_Static) {
6823     if (!D.isInvalidType())
6824       Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
6825         << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
6826         << SourceRange(D.getIdentifierLoc());
6827     D.setInvalidType();
6828     SC = SC_None;
6829   }
6830 
6831   if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
6832     diagnoseIgnoredQualifiers(
6833         diag::err_constructor_return_type, TypeQuals, SourceLocation(),
6834         D.getDeclSpec().getConstSpecLoc(), D.getDeclSpec().getVolatileSpecLoc(),
6835         D.getDeclSpec().getRestrictSpecLoc(),
6836         D.getDeclSpec().getAtomicSpecLoc());
6837     D.setInvalidType();
6838   }
6839 
6840   DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
6841   if (FTI.TypeQuals != 0) {
6842     if (FTI.TypeQuals & Qualifiers::Const)
6843       Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
6844         << "const" << SourceRange(D.getIdentifierLoc());
6845     if (FTI.TypeQuals & Qualifiers::Volatile)
6846       Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
6847         << "volatile" << SourceRange(D.getIdentifierLoc());
6848     if (FTI.TypeQuals & Qualifiers::Restrict)
6849       Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
6850         << "restrict" << SourceRange(D.getIdentifierLoc());
6851     D.setInvalidType();
6852   }
6853 
6854   // C++0x [class.ctor]p4:
6855   //   A constructor shall not be declared with a ref-qualifier.
6856   if (FTI.hasRefQualifier()) {
6857     Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_constructor)
6858       << FTI.RefQualifierIsLValueRef
6859       << FixItHint::CreateRemoval(FTI.getRefQualifierLoc());
6860     D.setInvalidType();
6861   }
6862 
6863   // Rebuild the function type "R" without any type qualifiers (in
6864   // case any of the errors above fired) and with "void" as the
6865   // return type, since constructors don't have return types.
6866   const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
6867   if (Proto->getReturnType() == Context.VoidTy && !D.isInvalidType())
6868     return R;
6869 
6870   FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
6871   EPI.TypeQuals = 0;
6872   EPI.RefQualifier = RQ_None;
6873 
6874   return Context.getFunctionType(Context.VoidTy, Proto->getParamTypes(), EPI);
6875 }
6876 
6877 /// CheckConstructor - Checks a fully-formed constructor for
6878 /// well-formedness, issuing any diagnostics required. Returns true if
6879 /// the constructor declarator is invalid.
CheckConstructor(CXXConstructorDecl * Constructor)6880 void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
6881   CXXRecordDecl *ClassDecl
6882     = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
6883   if (!ClassDecl)
6884     return Constructor->setInvalidDecl();
6885 
6886   // C++ [class.copy]p3:
6887   //   A declaration of a constructor for a class X is ill-formed if
6888   //   its first parameter is of type (optionally cv-qualified) X and
6889   //   either there are no other parameters or else all other
6890   //   parameters have default arguments.
6891   if (!Constructor->isInvalidDecl() &&
6892       ((Constructor->getNumParams() == 1) ||
6893        (Constructor->getNumParams() > 1 &&
6894         Constructor->getParamDecl(1)->hasDefaultArg())) &&
6895       Constructor->getTemplateSpecializationKind()
6896                                               != TSK_ImplicitInstantiation) {
6897     QualType ParamType = Constructor->getParamDecl(0)->getType();
6898     QualType ClassTy = Context.getTagDeclType(ClassDecl);
6899     if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
6900       SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
6901       const char *ConstRef
6902         = Constructor->getParamDecl(0)->getIdentifier() ? "const &"
6903                                                         : " const &";
6904       Diag(ParamLoc, diag::err_constructor_byvalue_arg)
6905         << FixItHint::CreateInsertion(ParamLoc, ConstRef);
6906 
6907       // FIXME: Rather that making the constructor invalid, we should endeavor
6908       // to fix the type.
6909       Constructor->setInvalidDecl();
6910     }
6911   }
6912 }
6913 
6914 /// CheckDestructor - Checks a fully-formed destructor definition for
6915 /// well-formedness, issuing any diagnostics required.  Returns true
6916 /// on error.
CheckDestructor(CXXDestructorDecl * Destructor)6917 bool Sema::CheckDestructor(CXXDestructorDecl *Destructor) {
6918   CXXRecordDecl *RD = Destructor->getParent();
6919 
6920   if (!Destructor->getOperatorDelete() && Destructor->isVirtual()) {
6921     SourceLocation Loc;
6922 
6923     if (!Destructor->isImplicit())
6924       Loc = Destructor->getLocation();
6925     else
6926       Loc = RD->getLocation();
6927 
6928     // If we have a virtual destructor, look up the deallocation function
6929     FunctionDecl *OperatorDelete = nullptr;
6930     DeclarationName Name =
6931     Context.DeclarationNames.getCXXOperatorName(OO_Delete);
6932     if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
6933       return true;
6934     // If there's no class-specific operator delete, look up the global
6935     // non-array delete.
6936     if (!OperatorDelete)
6937       OperatorDelete = FindUsualDeallocationFunction(Loc, true, Name);
6938 
6939     MarkFunctionReferenced(Loc, OperatorDelete);
6940 
6941     Destructor->setOperatorDelete(OperatorDelete);
6942   }
6943 
6944   return false;
6945 }
6946 
6947 /// CheckDestructorDeclarator - Called by ActOnDeclarator to check
6948 /// the well-formednes of the destructor declarator @p D with type @p
6949 /// R. If there are any errors in the declarator, this routine will
6950 /// emit diagnostics and set the declarator to invalid.  Even if this happens,
6951 /// will be updated to reflect a well-formed type for the destructor and
6952 /// returned.
CheckDestructorDeclarator(Declarator & D,QualType R,StorageClass & SC)6953 QualType Sema::CheckDestructorDeclarator(Declarator &D, QualType R,
6954                                          StorageClass& SC) {
6955   // C++ [class.dtor]p1:
6956   //   [...] A typedef-name that names a class is a class-name
6957   //   (7.1.3); however, a typedef-name that names a class shall not
6958   //   be used as the identifier in the declarator for a destructor
6959   //   declaration.
6960   QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
6961   if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
6962     Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
6963       << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
6964   else if (const TemplateSpecializationType *TST =
6965              DeclaratorType->getAs<TemplateSpecializationType>())
6966     if (TST->isTypeAlias())
6967       Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
6968         << DeclaratorType << 1;
6969 
6970   // C++ [class.dtor]p2:
6971   //   A destructor is used to destroy objects of its class type. A
6972   //   destructor takes no parameters, and no return type can be
6973   //   specified for it (not even void). The address of a destructor
6974   //   shall not be taken. A destructor shall not be static. A
6975   //   destructor can be invoked for a const, volatile or const
6976   //   volatile object. A destructor shall not be declared const,
6977   //   volatile or const volatile (9.3.2).
6978   if (SC == SC_Static) {
6979     if (!D.isInvalidType())
6980       Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
6981         << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
6982         << SourceRange(D.getIdentifierLoc())
6983         << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
6984 
6985     SC = SC_None;
6986   }
6987   if (!D.isInvalidType()) {
6988     // Destructors don't have return types, but the parser will
6989     // happily parse something like:
6990     //
6991     //   class X {
6992     //     float ~X();
6993     //   };
6994     //
6995     // The return type will be eliminated later.
6996     if (D.getDeclSpec().hasTypeSpecifier())
6997       Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
6998         << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
6999         << SourceRange(D.getIdentifierLoc());
7000     else if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
7001       diagnoseIgnoredQualifiers(diag::err_destructor_return_type, TypeQuals,
7002                                 SourceLocation(),
7003                                 D.getDeclSpec().getConstSpecLoc(),
7004                                 D.getDeclSpec().getVolatileSpecLoc(),
7005                                 D.getDeclSpec().getRestrictSpecLoc(),
7006                                 D.getDeclSpec().getAtomicSpecLoc());
7007       D.setInvalidType();
7008     }
7009   }
7010 
7011   DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
7012   if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
7013     if (FTI.TypeQuals & Qualifiers::Const)
7014       Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
7015         << "const" << SourceRange(D.getIdentifierLoc());
7016     if (FTI.TypeQuals & Qualifiers::Volatile)
7017       Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
7018         << "volatile" << SourceRange(D.getIdentifierLoc());
7019     if (FTI.TypeQuals & Qualifiers::Restrict)
7020       Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
7021         << "restrict" << SourceRange(D.getIdentifierLoc());
7022     D.setInvalidType();
7023   }
7024 
7025   // C++0x [class.dtor]p2:
7026   //   A destructor shall not be declared with a ref-qualifier.
7027   if (FTI.hasRefQualifier()) {
7028     Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_destructor)
7029       << FTI.RefQualifierIsLValueRef
7030       << FixItHint::CreateRemoval(FTI.getRefQualifierLoc());
7031     D.setInvalidType();
7032   }
7033 
7034   // Make sure we don't have any parameters.
7035   if (FTIHasNonVoidParameters(FTI)) {
7036     Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
7037 
7038     // Delete the parameters.
7039     FTI.freeParams();
7040     D.setInvalidType();
7041   }
7042 
7043   // Make sure the destructor isn't variadic.
7044   if (FTI.isVariadic) {
7045     Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
7046     D.setInvalidType();
7047   }
7048 
7049   // Rebuild the function type "R" without any type qualifiers or
7050   // parameters (in case any of the errors above fired) and with
7051   // "void" as the return type, since destructors don't have return
7052   // types.
7053   if (!D.isInvalidType())
7054     return R;
7055 
7056   const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
7057   FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
7058   EPI.Variadic = false;
7059   EPI.TypeQuals = 0;
7060   EPI.RefQualifier = RQ_None;
7061   return Context.getFunctionType(Context.VoidTy, None, EPI);
7062 }
7063 
extendLeft(SourceRange & R,SourceRange Before)7064 static void extendLeft(SourceRange &R, SourceRange Before) {
7065   if (Before.isInvalid())
7066     return;
7067   R.setBegin(Before.getBegin());
7068   if (R.getEnd().isInvalid())
7069     R.setEnd(Before.getEnd());
7070 }
7071 
extendRight(SourceRange & R,SourceRange After)7072 static void extendRight(SourceRange &R, SourceRange After) {
7073   if (After.isInvalid())
7074     return;
7075   if (R.getBegin().isInvalid())
7076     R.setBegin(After.getBegin());
7077   R.setEnd(After.getEnd());
7078 }
7079 
7080 /// CheckConversionDeclarator - Called by ActOnDeclarator to check the
7081 /// well-formednes of the conversion function declarator @p D with
7082 /// type @p R. If there are any errors in the declarator, this routine
7083 /// will emit diagnostics and return true. Otherwise, it will return
7084 /// false. Either way, the type @p R will be updated to reflect a
7085 /// well-formed type for the conversion operator.
CheckConversionDeclarator(Declarator & D,QualType & R,StorageClass & SC)7086 void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
7087                                      StorageClass& SC) {
7088   // C++ [class.conv.fct]p1:
7089   //   Neither parameter types nor return type can be specified. The
7090   //   type of a conversion function (8.3.5) is "function taking no
7091   //   parameter returning conversion-type-id."
7092   if (SC == SC_Static) {
7093     if (!D.isInvalidType())
7094       Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
7095         << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
7096         << D.getName().getSourceRange();
7097     D.setInvalidType();
7098     SC = SC_None;
7099   }
7100 
7101   TypeSourceInfo *ConvTSI = nullptr;
7102   QualType ConvType =
7103       GetTypeFromParser(D.getName().ConversionFunctionId, &ConvTSI);
7104 
7105   if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
7106     // Conversion functions don't have return types, but the parser will
7107     // happily parse something like:
7108     //
7109     //   class X {
7110     //     float operator bool();
7111     //   };
7112     //
7113     // The return type will be changed later anyway.
7114     Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
7115       << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
7116       << SourceRange(D.getIdentifierLoc());
7117     D.setInvalidType();
7118   }
7119 
7120   const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
7121 
7122   // Make sure we don't have any parameters.
7123   if (Proto->getNumParams() > 0) {
7124     Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
7125 
7126     // Delete the parameters.
7127     D.getFunctionTypeInfo().freeParams();
7128     D.setInvalidType();
7129   } else if (Proto->isVariadic()) {
7130     Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
7131     D.setInvalidType();
7132   }
7133 
7134   // Diagnose "&operator bool()" and other such nonsense.  This
7135   // is actually a gcc extension which we don't support.
7136   if (Proto->getReturnType() != ConvType) {
7137     bool NeedsTypedef = false;
7138     SourceRange Before, After;
7139 
7140     // Walk the chunks and extract information on them for our diagnostic.
7141     bool PastFunctionChunk = false;
7142     for (auto &Chunk : D.type_objects()) {
7143       switch (Chunk.Kind) {
7144       case DeclaratorChunk::Function:
7145         if (!PastFunctionChunk) {
7146           if (Chunk.Fun.HasTrailingReturnType) {
7147             TypeSourceInfo *TRT = nullptr;
7148             GetTypeFromParser(Chunk.Fun.getTrailingReturnType(), &TRT);
7149             if (TRT) extendRight(After, TRT->getTypeLoc().getSourceRange());
7150           }
7151           PastFunctionChunk = true;
7152           break;
7153         }
7154         // Fall through.
7155       case DeclaratorChunk::Array:
7156         NeedsTypedef = true;
7157         extendRight(After, Chunk.getSourceRange());
7158         break;
7159 
7160       case DeclaratorChunk::Pointer:
7161       case DeclaratorChunk::BlockPointer:
7162       case DeclaratorChunk::Reference:
7163       case DeclaratorChunk::MemberPointer:
7164       case DeclaratorChunk::Pipe:
7165         extendLeft(Before, Chunk.getSourceRange());
7166         break;
7167 
7168       case DeclaratorChunk::Paren:
7169         extendLeft(Before, Chunk.Loc);
7170         extendRight(After, Chunk.EndLoc);
7171         break;
7172       }
7173     }
7174 
7175     SourceLocation Loc = Before.isValid() ? Before.getBegin() :
7176                          After.isValid()  ? After.getBegin() :
7177                                             D.getIdentifierLoc();
7178     auto &&DB = Diag(Loc, diag::err_conv_function_with_complex_decl);
7179     DB << Before << After;
7180 
7181     if (!NeedsTypedef) {
7182       DB << /*don't need a typedef*/0;
7183 
7184       // If we can provide a correct fix-it hint, do so.
7185       if (After.isInvalid() && ConvTSI) {
7186         SourceLocation InsertLoc =
7187             getLocForEndOfToken(ConvTSI->getTypeLoc().getLocEnd());
7188         DB << FixItHint::CreateInsertion(InsertLoc, " ")
7189            << FixItHint::CreateInsertionFromRange(
7190                   InsertLoc, CharSourceRange::getTokenRange(Before))
7191            << FixItHint::CreateRemoval(Before);
7192       }
7193     } else if (!Proto->getReturnType()->isDependentType()) {
7194       DB << /*typedef*/1 << Proto->getReturnType();
7195     } else if (getLangOpts().CPlusPlus11) {
7196       DB << /*alias template*/2 << Proto->getReturnType();
7197     } else {
7198       DB << /*might not be fixable*/3;
7199     }
7200 
7201     // Recover by incorporating the other type chunks into the result type.
7202     // Note, this does *not* change the name of the function. This is compatible
7203     // with the GCC extension:
7204     //   struct S { &operator int(); } s;
7205     //   int &r = s.operator int(); // ok in GCC
7206     //   S::operator int&() {} // error in GCC, function name is 'operator int'.
7207     ConvType = Proto->getReturnType();
7208   }
7209 
7210   // C++ [class.conv.fct]p4:
7211   //   The conversion-type-id shall not represent a function type nor
7212   //   an array type.
7213   if (ConvType->isArrayType()) {
7214     Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
7215     ConvType = Context.getPointerType(ConvType);
7216     D.setInvalidType();
7217   } else if (ConvType->isFunctionType()) {
7218     Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
7219     ConvType = Context.getPointerType(ConvType);
7220     D.setInvalidType();
7221   }
7222 
7223   // Rebuild the function type "R" without any parameters (in case any
7224   // of the errors above fired) and with the conversion type as the
7225   // return type.
7226   if (D.isInvalidType())
7227     R = Context.getFunctionType(ConvType, None, Proto->getExtProtoInfo());
7228 
7229   // C++0x explicit conversion operators.
7230   if (D.getDeclSpec().isExplicitSpecified())
7231     Diag(D.getDeclSpec().getExplicitSpecLoc(),
7232          getLangOpts().CPlusPlus11 ?
7233            diag::warn_cxx98_compat_explicit_conversion_functions :
7234            diag::ext_explicit_conversion_functions)
7235       << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
7236 }
7237 
7238 /// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
7239 /// the declaration of the given C++ conversion function. This routine
7240 /// is responsible for recording the conversion function in the C++
7241 /// class, if possible.
ActOnConversionDeclarator(CXXConversionDecl * Conversion)7242 Decl *Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
7243   assert(Conversion && "Expected to receive a conversion function declaration");
7244 
7245   CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
7246 
7247   // Make sure we aren't redeclaring the conversion function.
7248   QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
7249 
7250   // C++ [class.conv.fct]p1:
7251   //   [...] A conversion function is never used to convert a
7252   //   (possibly cv-qualified) object to the (possibly cv-qualified)
7253   //   same object type (or a reference to it), to a (possibly
7254   //   cv-qualified) base class of that type (or a reference to it),
7255   //   or to (possibly cv-qualified) void.
7256   // FIXME: Suppress this warning if the conversion function ends up being a
7257   // virtual function that overrides a virtual function in a base class.
7258   QualType ClassType
7259     = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
7260   if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
7261     ConvType = ConvTypeRef->getPointeeType();
7262   if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared &&
7263       Conversion->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)
7264     /* Suppress diagnostics for instantiations. */;
7265   else if (ConvType->isRecordType()) {
7266     ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
7267     if (ConvType == ClassType)
7268       Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
7269         << ClassType;
7270     else if (IsDerivedFrom(Conversion->getLocation(), ClassType, ConvType))
7271       Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
7272         <<  ClassType << ConvType;
7273   } else if (ConvType->isVoidType()) {
7274     Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
7275       << ClassType << ConvType;
7276   }
7277 
7278   if (FunctionTemplateDecl *ConversionTemplate
7279                                 = Conversion->getDescribedFunctionTemplate())
7280     return ConversionTemplate;
7281 
7282   return Conversion;
7283 }
7284 
7285 //===----------------------------------------------------------------------===//
7286 // Namespace Handling
7287 //===----------------------------------------------------------------------===//
7288 
7289 /// \brief Diagnose a mismatch in 'inline' qualifiers when a namespace is
7290 /// reopened.
DiagnoseNamespaceInlineMismatch(Sema & S,SourceLocation KeywordLoc,SourceLocation Loc,IdentifierInfo * II,bool * IsInline,NamespaceDecl * PrevNS)7291 static void DiagnoseNamespaceInlineMismatch(Sema &S, SourceLocation KeywordLoc,
7292                                             SourceLocation Loc,
7293                                             IdentifierInfo *II, bool *IsInline,
7294                                             NamespaceDecl *PrevNS) {
7295   assert(*IsInline != PrevNS->isInline());
7296 
7297   // HACK: Work around a bug in libstdc++4.6's <atomic>, where
7298   // std::__atomic[0,1,2] are defined as non-inline namespaces, then reopened as
7299   // inline namespaces, with the intention of bringing names into namespace std.
7300   //
7301   // We support this just well enough to get that case working; this is not
7302   // sufficient to support reopening namespaces as inline in general.
7303   if (*IsInline && II && II->getName().startswith("__atomic") &&
7304       S.getSourceManager().isInSystemHeader(Loc)) {
7305     // Mark all prior declarations of the namespace as inline.
7306     for (NamespaceDecl *NS = PrevNS->getMostRecentDecl(); NS;
7307          NS = NS->getPreviousDecl())
7308       NS->setInline(*IsInline);
7309     // Patch up the lookup table for the containing namespace. This isn't really
7310     // correct, but it's good enough for this particular case.
7311     for (auto *I : PrevNS->decls())
7312       if (auto *ND = dyn_cast<NamedDecl>(I))
7313         PrevNS->getParent()->makeDeclVisibleInContext(ND);
7314     return;
7315   }
7316 
7317   if (PrevNS->isInline())
7318     // The user probably just forgot the 'inline', so suggest that it
7319     // be added back.
7320     S.Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
7321       << FixItHint::CreateInsertion(KeywordLoc, "inline ");
7322   else
7323     S.Diag(Loc, diag::err_inline_namespace_mismatch) << *IsInline;
7324 
7325   S.Diag(PrevNS->getLocation(), diag::note_previous_definition);
7326   *IsInline = PrevNS->isInline();
7327 }
7328 
7329 /// ActOnStartNamespaceDef - This is called at the start of a namespace
7330 /// definition.
ActOnStartNamespaceDef(Scope * NamespcScope,SourceLocation InlineLoc,SourceLocation NamespaceLoc,SourceLocation IdentLoc,IdentifierInfo * II,SourceLocation LBrace,AttributeList * AttrList,UsingDirectiveDecl * & UD)7331 Decl *Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
7332                                    SourceLocation InlineLoc,
7333                                    SourceLocation NamespaceLoc,
7334                                    SourceLocation IdentLoc,
7335                                    IdentifierInfo *II,
7336                                    SourceLocation LBrace,
7337                                    AttributeList *AttrList,
7338                                    UsingDirectiveDecl *&UD) {
7339   SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc;
7340   // For anonymous namespace, take the location of the left brace.
7341   SourceLocation Loc = II ? IdentLoc : LBrace;
7342   bool IsInline = InlineLoc.isValid();
7343   bool IsInvalid = false;
7344   bool IsStd = false;
7345   bool AddToKnown = false;
7346   Scope *DeclRegionScope = NamespcScope->getParent();
7347 
7348   NamespaceDecl *PrevNS = nullptr;
7349   if (II) {
7350     // C++ [namespace.def]p2:
7351     //   The identifier in an original-namespace-definition shall not
7352     //   have been previously defined in the declarative region in
7353     //   which the original-namespace-definition appears. The
7354     //   identifier in an original-namespace-definition is the name of
7355     //   the namespace. Subsequently in that declarative region, it is
7356     //   treated as an original-namespace-name.
7357     //
7358     // Since namespace names are unique in their scope, and we don't
7359     // look through using directives, just look for any ordinary names
7360     // as if by qualified name lookup.
7361     LookupResult R(*this, II, IdentLoc, LookupOrdinaryName, ForRedeclaration);
7362     LookupQualifiedName(R, CurContext->getRedeclContext());
7363     NamedDecl *PrevDecl =
7364         R.isSingleResult() ? R.getRepresentativeDecl() : nullptr;
7365     PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
7366 
7367     if (PrevNS) {
7368       // This is an extended namespace definition.
7369       if (IsInline != PrevNS->isInline())
7370         DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, Loc, II,
7371                                         &IsInline, PrevNS);
7372     } else if (PrevDecl) {
7373       // This is an invalid name redefinition.
7374       Diag(Loc, diag::err_redefinition_different_kind)
7375         << II;
7376       Diag(PrevDecl->getLocation(), diag::note_previous_definition);
7377       IsInvalid = true;
7378       // Continue on to push Namespc as current DeclContext and return it.
7379     } else if (II->isStr("std") &&
7380                CurContext->getRedeclContext()->isTranslationUnit()) {
7381       // This is the first "real" definition of the namespace "std", so update
7382       // our cache of the "std" namespace to point at this definition.
7383       PrevNS = getStdNamespace();
7384       IsStd = true;
7385       AddToKnown = !IsInline;
7386     } else {
7387       // We've seen this namespace for the first time.
7388       AddToKnown = !IsInline;
7389     }
7390   } else {
7391     // Anonymous namespaces.
7392 
7393     // Determine whether the parent already has an anonymous namespace.
7394     DeclContext *Parent = CurContext->getRedeclContext();
7395     if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
7396       PrevNS = TU->getAnonymousNamespace();
7397     } else {
7398       NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
7399       PrevNS = ND->getAnonymousNamespace();
7400     }
7401 
7402     if (PrevNS && IsInline != PrevNS->isInline())
7403       DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, NamespaceLoc, II,
7404                                       &IsInline, PrevNS);
7405   }
7406 
7407   NamespaceDecl *Namespc = NamespaceDecl::Create(Context, CurContext, IsInline,
7408                                                  StartLoc, Loc, II, PrevNS);
7409   if (IsInvalid)
7410     Namespc->setInvalidDecl();
7411 
7412   ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
7413 
7414   // FIXME: Should we be merging attributes?
7415   if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
7416     PushNamespaceVisibilityAttr(Attr, Loc);
7417 
7418   if (IsStd)
7419     StdNamespace = Namespc;
7420   if (AddToKnown)
7421     KnownNamespaces[Namespc] = false;
7422 
7423   if (II) {
7424     PushOnScopeChains(Namespc, DeclRegionScope);
7425   } else {
7426     // Link the anonymous namespace into its parent.
7427     DeclContext *Parent = CurContext->getRedeclContext();
7428     if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
7429       TU->setAnonymousNamespace(Namespc);
7430     } else {
7431       cast<NamespaceDecl>(Parent)->setAnonymousNamespace(Namespc);
7432     }
7433 
7434     CurContext->addDecl(Namespc);
7435 
7436     // C++ [namespace.unnamed]p1.  An unnamed-namespace-definition
7437     //   behaves as if it were replaced by
7438     //     namespace unique { /* empty body */ }
7439     //     using namespace unique;
7440     //     namespace unique { namespace-body }
7441     //   where all occurrences of 'unique' in a translation unit are
7442     //   replaced by the same identifier and this identifier differs
7443     //   from all other identifiers in the entire program.
7444 
7445     // We just create the namespace with an empty name and then add an
7446     // implicit using declaration, just like the standard suggests.
7447     //
7448     // CodeGen enforces the "universally unique" aspect by giving all
7449     // declarations semantically contained within an anonymous
7450     // namespace internal linkage.
7451 
7452     if (!PrevNS) {
7453       UD = UsingDirectiveDecl::Create(Context, Parent,
7454                                       /* 'using' */ LBrace,
7455                                       /* 'namespace' */ SourceLocation(),
7456                                       /* qualifier */ NestedNameSpecifierLoc(),
7457                                       /* identifier */ SourceLocation(),
7458                                       Namespc,
7459                                       /* Ancestor */ Parent);
7460       UD->setImplicit();
7461       Parent->addDecl(UD);
7462     }
7463   }
7464 
7465   ActOnDocumentableDecl(Namespc);
7466 
7467   // Although we could have an invalid decl (i.e. the namespace name is a
7468   // redefinition), push it as current DeclContext and try to continue parsing.
7469   // FIXME: We should be able to push Namespc here, so that the each DeclContext
7470   // for the namespace has the declarations that showed up in that particular
7471   // namespace definition.
7472   PushDeclContext(NamespcScope, Namespc);
7473   return Namespc;
7474 }
7475 
7476 /// getNamespaceDecl - Returns the namespace a decl represents. If the decl
7477 /// is a namespace alias, returns the namespace it points to.
getNamespaceDecl(NamedDecl * D)7478 static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
7479   if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
7480     return AD->getNamespace();
7481   return dyn_cast_or_null<NamespaceDecl>(D);
7482 }
7483 
7484 /// ActOnFinishNamespaceDef - This callback is called after a namespace is
7485 /// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
ActOnFinishNamespaceDef(Decl * Dcl,SourceLocation RBrace)7486 void Sema::ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace) {
7487   NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
7488   assert(Namespc && "Invalid parameter, expected NamespaceDecl");
7489   Namespc->setRBraceLoc(RBrace);
7490   PopDeclContext();
7491   if (Namespc->hasAttr<VisibilityAttr>())
7492     PopPragmaVisibility(true, RBrace);
7493 }
7494 
getStdBadAlloc() const7495 CXXRecordDecl *Sema::getStdBadAlloc() const {
7496   return cast_or_null<CXXRecordDecl>(
7497                                   StdBadAlloc.get(Context.getExternalSource()));
7498 }
7499 
getStdNamespace() const7500 NamespaceDecl *Sema::getStdNamespace() const {
7501   return cast_or_null<NamespaceDecl>(
7502                                  StdNamespace.get(Context.getExternalSource()));
7503 }
7504 
7505 /// \brief Retrieve the special "std" namespace, which may require us to
7506 /// implicitly define the namespace.
getOrCreateStdNamespace()7507 NamespaceDecl *Sema::getOrCreateStdNamespace() {
7508   if (!StdNamespace) {
7509     // The "std" namespace has not yet been defined, so build one implicitly.
7510     StdNamespace = NamespaceDecl::Create(Context,
7511                                          Context.getTranslationUnitDecl(),
7512                                          /*Inline=*/false,
7513                                          SourceLocation(), SourceLocation(),
7514                                          &PP.getIdentifierTable().get("std"),
7515                                          /*PrevDecl=*/nullptr);
7516     getStdNamespace()->setImplicit(true);
7517   }
7518 
7519   return getStdNamespace();
7520 }
7521 
isStdInitializerList(QualType Ty,QualType * Element)7522 bool Sema::isStdInitializerList(QualType Ty, QualType *Element) {
7523   assert(getLangOpts().CPlusPlus &&
7524          "Looking for std::initializer_list outside of C++.");
7525 
7526   // We're looking for implicit instantiations of
7527   // template <typename E> class std::initializer_list.
7528 
7529   if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it.
7530     return false;
7531 
7532   ClassTemplateDecl *Template = nullptr;
7533   const TemplateArgument *Arguments = nullptr;
7534 
7535   if (const RecordType *RT = Ty->getAs<RecordType>()) {
7536 
7537     ClassTemplateSpecializationDecl *Specialization =
7538         dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
7539     if (!Specialization)
7540       return false;
7541 
7542     Template = Specialization->getSpecializedTemplate();
7543     Arguments = Specialization->getTemplateArgs().data();
7544   } else if (const TemplateSpecializationType *TST =
7545                  Ty->getAs<TemplateSpecializationType>()) {
7546     Template = dyn_cast_or_null<ClassTemplateDecl>(
7547         TST->getTemplateName().getAsTemplateDecl());
7548     Arguments = TST->getArgs();
7549   }
7550   if (!Template)
7551     return false;
7552 
7553   if (!StdInitializerList) {
7554     // Haven't recognized std::initializer_list yet, maybe this is it.
7555     CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
7556     if (TemplateClass->getIdentifier() !=
7557             &PP.getIdentifierTable().get("initializer_list") ||
7558         !getStdNamespace()->InEnclosingNamespaceSetOf(
7559             TemplateClass->getDeclContext()))
7560       return false;
7561     // This is a template called std::initializer_list, but is it the right
7562     // template?
7563     TemplateParameterList *Params = Template->getTemplateParameters();
7564     if (Params->getMinRequiredArguments() != 1)
7565       return false;
7566     if (!isa<TemplateTypeParmDecl>(Params->getParam(0)))
7567       return false;
7568 
7569     // It's the right template.
7570     StdInitializerList = Template;
7571   }
7572 
7573   if (Template->getCanonicalDecl() != StdInitializerList->getCanonicalDecl())
7574     return false;
7575 
7576   // This is an instance of std::initializer_list. Find the argument type.
7577   if (Element)
7578     *Element = Arguments[0].getAsType();
7579   return true;
7580 }
7581 
LookupStdInitializerList(Sema & S,SourceLocation Loc)7582 static ClassTemplateDecl *LookupStdInitializerList(Sema &S, SourceLocation Loc){
7583   NamespaceDecl *Std = S.getStdNamespace();
7584   if (!Std) {
7585     S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
7586     return nullptr;
7587   }
7588 
7589   LookupResult Result(S, &S.PP.getIdentifierTable().get("initializer_list"),
7590                       Loc, Sema::LookupOrdinaryName);
7591   if (!S.LookupQualifiedName(Result, Std)) {
7592     S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
7593     return nullptr;
7594   }
7595   ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>();
7596   if (!Template) {
7597     Result.suppressDiagnostics();
7598     // We found something weird. Complain about the first thing we found.
7599     NamedDecl *Found = *Result.begin();
7600     S.Diag(Found->getLocation(), diag::err_malformed_std_initializer_list);
7601     return nullptr;
7602   }
7603 
7604   // We found some template called std::initializer_list. Now verify that it's
7605   // correct.
7606   TemplateParameterList *Params = Template->getTemplateParameters();
7607   if (Params->getMinRequiredArguments() != 1 ||
7608       !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
7609     S.Diag(Template->getLocation(), diag::err_malformed_std_initializer_list);
7610     return nullptr;
7611   }
7612 
7613   return Template;
7614 }
7615 
BuildStdInitializerList(QualType Element,SourceLocation Loc)7616 QualType Sema::BuildStdInitializerList(QualType Element, SourceLocation Loc) {
7617   if (!StdInitializerList) {
7618     StdInitializerList = LookupStdInitializerList(*this, Loc);
7619     if (!StdInitializerList)
7620       return QualType();
7621   }
7622 
7623   TemplateArgumentListInfo Args(Loc, Loc);
7624   Args.addArgument(TemplateArgumentLoc(TemplateArgument(Element),
7625                                        Context.getTrivialTypeSourceInfo(Element,
7626                                                                         Loc)));
7627   return Context.getCanonicalType(
7628       CheckTemplateIdType(TemplateName(StdInitializerList), Loc, Args));
7629 }
7630 
isInitListConstructor(const CXXConstructorDecl * Ctor)7631 bool Sema::isInitListConstructor(const CXXConstructorDecl* Ctor) {
7632   // C++ [dcl.init.list]p2:
7633   //   A constructor is an initializer-list constructor if its first parameter
7634   //   is of type std::initializer_list<E> or reference to possibly cv-qualified
7635   //   std::initializer_list<E> for some type E, and either there are no other
7636   //   parameters or else all other parameters have default arguments.
7637   if (Ctor->getNumParams() < 1 ||
7638       (Ctor->getNumParams() > 1 && !Ctor->getParamDecl(1)->hasDefaultArg()))
7639     return false;
7640 
7641   QualType ArgType = Ctor->getParamDecl(0)->getType();
7642   if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
7643     ArgType = RT->getPointeeType().getUnqualifiedType();
7644 
7645   return isStdInitializerList(ArgType, nullptr);
7646 }
7647 
7648 /// \brief Determine whether a using statement is in a context where it will be
7649 /// apply in all contexts.
IsUsingDirectiveInToplevelContext(DeclContext * CurContext)7650 static bool IsUsingDirectiveInToplevelContext(DeclContext *CurContext) {
7651   switch (CurContext->getDeclKind()) {
7652     case Decl::TranslationUnit:
7653       return true;
7654     case Decl::LinkageSpec:
7655       return IsUsingDirectiveInToplevelContext(CurContext->getParent());
7656     default:
7657       return false;
7658   }
7659 }
7660 
7661 namespace {
7662 
7663 // Callback to only accept typo corrections that are namespaces.
7664 class NamespaceValidatorCCC : public CorrectionCandidateCallback {
7665 public:
ValidateCandidate(const TypoCorrection & candidate)7666   bool ValidateCandidate(const TypoCorrection &candidate) override {
7667     if (NamedDecl *ND = candidate.getCorrectionDecl())
7668       return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
7669     return false;
7670   }
7671 };
7672 
7673 }
7674 
TryNamespaceTypoCorrection(Sema & S,LookupResult & R,Scope * Sc,CXXScopeSpec & SS,SourceLocation IdentLoc,IdentifierInfo * Ident)7675 static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc,
7676                                        CXXScopeSpec &SS,
7677                                        SourceLocation IdentLoc,
7678                                        IdentifierInfo *Ident) {
7679   R.clear();
7680   if (TypoCorrection Corrected =
7681           S.CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), Sc, &SS,
7682                         llvm::make_unique<NamespaceValidatorCCC>(),
7683                         Sema::CTK_ErrorRecovery)) {
7684     if (DeclContext *DC = S.computeDeclContext(SS, false)) {
7685       std::string CorrectedStr(Corrected.getAsString(S.getLangOpts()));
7686       bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
7687                               Ident->getName().equals(CorrectedStr);
7688       S.diagnoseTypo(Corrected,
7689                      S.PDiag(diag::err_using_directive_member_suggest)
7690                        << Ident << DC << DroppedSpecifier << SS.getRange(),
7691                      S.PDiag(diag::note_namespace_defined_here));
7692     } else {
7693       S.diagnoseTypo(Corrected,
7694                      S.PDiag(diag::err_using_directive_suggest) << Ident,
7695                      S.PDiag(diag::note_namespace_defined_here));
7696     }
7697     R.addDecl(Corrected.getFoundDecl());
7698     return true;
7699   }
7700   return false;
7701 }
7702 
ActOnUsingDirective(Scope * S,SourceLocation UsingLoc,SourceLocation NamespcLoc,CXXScopeSpec & SS,SourceLocation IdentLoc,IdentifierInfo * NamespcName,AttributeList * AttrList)7703 Decl *Sema::ActOnUsingDirective(Scope *S,
7704                                           SourceLocation UsingLoc,
7705                                           SourceLocation NamespcLoc,
7706                                           CXXScopeSpec &SS,
7707                                           SourceLocation IdentLoc,
7708                                           IdentifierInfo *NamespcName,
7709                                           AttributeList *AttrList) {
7710   assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
7711   assert(NamespcName && "Invalid NamespcName.");
7712   assert(IdentLoc.isValid() && "Invalid NamespceName location.");
7713 
7714   // This can only happen along a recovery path.
7715   while (S->isTemplateParamScope())
7716     S = S->getParent();
7717   assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
7718 
7719   UsingDirectiveDecl *UDir = nullptr;
7720   NestedNameSpecifier *Qualifier = nullptr;
7721   if (SS.isSet())
7722     Qualifier = SS.getScopeRep();
7723 
7724   // Lookup namespace name.
7725   LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
7726   LookupParsedName(R, S, &SS);
7727   if (R.isAmbiguous())
7728     return nullptr;
7729 
7730   if (R.empty()) {
7731     R.clear();
7732     // Allow "using namespace std;" or "using namespace ::std;" even if
7733     // "std" hasn't been defined yet, for GCC compatibility.
7734     if ((!Qualifier || Qualifier->getKind() == NestedNameSpecifier::Global) &&
7735         NamespcName->isStr("std")) {
7736       Diag(IdentLoc, diag::ext_using_undefined_std);
7737       R.addDecl(getOrCreateStdNamespace());
7738       R.resolveKind();
7739     }
7740     // Otherwise, attempt typo correction.
7741     else TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, NamespcName);
7742   }
7743 
7744   if (!R.empty()) {
7745     NamedDecl *Named = R.getRepresentativeDecl();
7746     NamespaceDecl *NS = R.getAsSingle<NamespaceDecl>();
7747     assert(NS && "expected namespace decl");
7748 
7749     // The use of a nested name specifier may trigger deprecation warnings.
7750     DiagnoseUseOfDecl(Named, IdentLoc);
7751 
7752     // C++ [namespace.udir]p1:
7753     //   A using-directive specifies that the names in the nominated
7754     //   namespace can be used in the scope in which the
7755     //   using-directive appears after the using-directive. During
7756     //   unqualified name lookup (3.4.1), the names appear as if they
7757     //   were declared in the nearest enclosing namespace which
7758     //   contains both the using-directive and the nominated
7759     //   namespace. [Note: in this context, "contains" means "contains
7760     //   directly or indirectly". ]
7761 
7762     // Find enclosing context containing both using-directive and
7763     // nominated namespace.
7764     DeclContext *CommonAncestor = cast<DeclContext>(NS);
7765     while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
7766       CommonAncestor = CommonAncestor->getParent();
7767 
7768     UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
7769                                       SS.getWithLocInContext(Context),
7770                                       IdentLoc, Named, CommonAncestor);
7771 
7772     if (IsUsingDirectiveInToplevelContext(CurContext) &&
7773         !SourceMgr.isInMainFile(SourceMgr.getExpansionLoc(IdentLoc))) {
7774       Diag(IdentLoc, diag::warn_using_directive_in_header);
7775     }
7776 
7777     PushUsingDirective(S, UDir);
7778   } else {
7779     Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
7780   }
7781 
7782   if (UDir)
7783     ProcessDeclAttributeList(S, UDir, AttrList);
7784 
7785   return UDir;
7786 }
7787 
PushUsingDirective(Scope * S,UsingDirectiveDecl * UDir)7788 void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
7789   // If the scope has an associated entity and the using directive is at
7790   // namespace or translation unit scope, add the UsingDirectiveDecl into
7791   // its lookup structure so qualified name lookup can find it.
7792   DeclContext *Ctx = S->getEntity();
7793   if (Ctx && !Ctx->isFunctionOrMethod())
7794     Ctx->addDecl(UDir);
7795   else
7796     // Otherwise, it is at block scope. The using-directives will affect lookup
7797     // only to the end of the scope.
7798     S->PushUsingDirective(UDir);
7799 }
7800 
7801 
ActOnUsingDeclaration(Scope * S,AccessSpecifier AS,bool HasUsingKeyword,SourceLocation UsingLoc,CXXScopeSpec & SS,UnqualifiedId & Name,AttributeList * AttrList,bool HasTypenameKeyword,SourceLocation TypenameLoc)7802 Decl *Sema::ActOnUsingDeclaration(Scope *S,
7803                                   AccessSpecifier AS,
7804                                   bool HasUsingKeyword,
7805                                   SourceLocation UsingLoc,
7806                                   CXXScopeSpec &SS,
7807                                   UnqualifiedId &Name,
7808                                   AttributeList *AttrList,
7809                                   bool HasTypenameKeyword,
7810                                   SourceLocation TypenameLoc) {
7811   assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
7812 
7813   switch (Name.getKind()) {
7814   case UnqualifiedId::IK_ImplicitSelfParam:
7815   case UnqualifiedId::IK_Identifier:
7816   case UnqualifiedId::IK_OperatorFunctionId:
7817   case UnqualifiedId::IK_LiteralOperatorId:
7818   case UnqualifiedId::IK_ConversionFunctionId:
7819     break;
7820 
7821   case UnqualifiedId::IK_ConstructorName:
7822   case UnqualifiedId::IK_ConstructorTemplateId:
7823     // C++11 inheriting constructors.
7824     Diag(Name.getLocStart(),
7825          getLangOpts().CPlusPlus11 ?
7826            diag::warn_cxx98_compat_using_decl_constructor :
7827            diag::err_using_decl_constructor)
7828       << SS.getRange();
7829 
7830     if (getLangOpts().CPlusPlus11) break;
7831 
7832     return nullptr;
7833 
7834   case UnqualifiedId::IK_DestructorName:
7835     Diag(Name.getLocStart(), diag::err_using_decl_destructor)
7836       << SS.getRange();
7837     return nullptr;
7838 
7839   case UnqualifiedId::IK_TemplateId:
7840     Diag(Name.getLocStart(), diag::err_using_decl_template_id)
7841       << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
7842     return nullptr;
7843   }
7844 
7845   DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
7846   DeclarationName TargetName = TargetNameInfo.getName();
7847   if (!TargetName)
7848     return nullptr;
7849 
7850   // Warn about access declarations.
7851   if (!HasUsingKeyword) {
7852     Diag(Name.getLocStart(),
7853          getLangOpts().CPlusPlus11 ? diag::err_access_decl
7854                                    : diag::warn_access_decl_deprecated)
7855       << FixItHint::CreateInsertion(SS.getRange().getBegin(), "using ");
7856   }
7857 
7858   if (DiagnoseUnexpandedParameterPack(SS, UPPC_UsingDeclaration) ||
7859       DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC_UsingDeclaration))
7860     return nullptr;
7861 
7862   NamedDecl *UD = BuildUsingDeclaration(S, AS, UsingLoc, SS,
7863                                         TargetNameInfo, AttrList,
7864                                         /* IsInstantiation */ false,
7865                                         HasTypenameKeyword, TypenameLoc);
7866   if (UD)
7867     PushOnScopeChains(UD, S, /*AddToContext*/ false);
7868 
7869   return UD;
7870 }
7871 
7872 /// \brief Determine whether a using declaration considers the given
7873 /// declarations as "equivalent", e.g., if they are redeclarations of
7874 /// the same entity or are both typedefs of the same type.
7875 static bool
IsEquivalentForUsingDecl(ASTContext & Context,NamedDecl * D1,NamedDecl * D2)7876 IsEquivalentForUsingDecl(ASTContext &Context, NamedDecl *D1, NamedDecl *D2) {
7877   if (D1->getCanonicalDecl() == D2->getCanonicalDecl())
7878     return true;
7879 
7880   if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(D1))
7881     if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2))
7882       return Context.hasSameType(TD1->getUnderlyingType(),
7883                                  TD2->getUnderlyingType());
7884 
7885   return false;
7886 }
7887 
7888 
7889 /// Determines whether to create a using shadow decl for a particular
7890 /// decl, given the set of decls existing prior to this using lookup.
CheckUsingShadowDecl(UsingDecl * Using,NamedDecl * Orig,const LookupResult & Previous,UsingShadowDecl * & PrevShadow)7891 bool Sema::CheckUsingShadowDecl(UsingDecl *Using, NamedDecl *Orig,
7892                                 const LookupResult &Previous,
7893                                 UsingShadowDecl *&PrevShadow) {
7894   // Diagnose finding a decl which is not from a base class of the
7895   // current class.  We do this now because there are cases where this
7896   // function will silently decide not to build a shadow decl, which
7897   // will pre-empt further diagnostics.
7898   //
7899   // We don't need to do this in C++11 because we do the check once on
7900   // the qualifier.
7901   //
7902   // FIXME: diagnose the following if we care enough:
7903   //   struct A { int foo; };
7904   //   struct B : A { using A::foo; };
7905   //   template <class T> struct C : A {};
7906   //   template <class T> struct D : C<T> { using B::foo; } // <---
7907   // This is invalid (during instantiation) in C++03 because B::foo
7908   // resolves to the using decl in B, which is not a base class of D<T>.
7909   // We can't diagnose it immediately because C<T> is an unknown
7910   // specialization.  The UsingShadowDecl in D<T> then points directly
7911   // to A::foo, which will look well-formed when we instantiate.
7912   // The right solution is to not collapse the shadow-decl chain.
7913   if (!getLangOpts().CPlusPlus11 && CurContext->isRecord()) {
7914     DeclContext *OrigDC = Orig->getDeclContext();
7915 
7916     // Handle enums and anonymous structs.
7917     if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
7918     CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
7919     while (OrigRec->isAnonymousStructOrUnion())
7920       OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
7921 
7922     if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
7923       if (OrigDC == CurContext) {
7924         Diag(Using->getLocation(),
7925              diag::err_using_decl_nested_name_specifier_is_current_class)
7926           << Using->getQualifierLoc().getSourceRange();
7927         Diag(Orig->getLocation(), diag::note_using_decl_target);
7928         return true;
7929       }
7930 
7931       Diag(Using->getQualifierLoc().getBeginLoc(),
7932            diag::err_using_decl_nested_name_specifier_is_not_base_class)
7933         << Using->getQualifier()
7934         << cast<CXXRecordDecl>(CurContext)
7935         << Using->getQualifierLoc().getSourceRange();
7936       Diag(Orig->getLocation(), diag::note_using_decl_target);
7937       return true;
7938     }
7939   }
7940 
7941   if (Previous.empty()) return false;
7942 
7943   NamedDecl *Target = Orig;
7944   if (isa<UsingShadowDecl>(Target))
7945     Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
7946 
7947   // If the target happens to be one of the previous declarations, we
7948   // don't have a conflict.
7949   //
7950   // FIXME: but we might be increasing its access, in which case we
7951   // should redeclare it.
7952   NamedDecl *NonTag = nullptr, *Tag = nullptr;
7953   bool FoundEquivalentDecl = false;
7954   for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
7955          I != E; ++I) {
7956     NamedDecl *D = (*I)->getUnderlyingDecl();
7957     // We can have UsingDecls in our Previous results because we use the same
7958     // LookupResult for checking whether the UsingDecl itself is a valid
7959     // redeclaration.
7960     if (isa<UsingDecl>(D))
7961       continue;
7962 
7963     if (IsEquivalentForUsingDecl(Context, D, Target)) {
7964       if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(*I))
7965         PrevShadow = Shadow;
7966       FoundEquivalentDecl = true;
7967     } else if (isEquivalentInternalLinkageDeclaration(D, Target)) {
7968       // We don't conflict with an existing using shadow decl of an equivalent
7969       // declaration, but we're not a redeclaration of it.
7970       FoundEquivalentDecl = true;
7971     }
7972 
7973     if (isVisible(D))
7974       (isa<TagDecl>(D) ? Tag : NonTag) = D;
7975   }
7976 
7977   if (FoundEquivalentDecl)
7978     return false;
7979 
7980   if (FunctionDecl *FD = Target->getAsFunction()) {
7981     NamedDecl *OldDecl = nullptr;
7982     switch (CheckOverload(nullptr, FD, Previous, OldDecl,
7983                           /*IsForUsingDecl*/ true)) {
7984     case Ovl_Overload:
7985       return false;
7986 
7987     case Ovl_NonFunction:
7988       Diag(Using->getLocation(), diag::err_using_decl_conflict);
7989       break;
7990 
7991     // We found a decl with the exact signature.
7992     case Ovl_Match:
7993       // If we're in a record, we want to hide the target, so we
7994       // return true (without a diagnostic) to tell the caller not to
7995       // build a shadow decl.
7996       if (CurContext->isRecord())
7997         return true;
7998 
7999       // If we're not in a record, this is an error.
8000       Diag(Using->getLocation(), diag::err_using_decl_conflict);
8001       break;
8002     }
8003 
8004     Diag(Target->getLocation(), diag::note_using_decl_target);
8005     Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
8006     return true;
8007   }
8008 
8009   // Target is not a function.
8010 
8011   if (isa<TagDecl>(Target)) {
8012     // No conflict between a tag and a non-tag.
8013     if (!Tag) return false;
8014 
8015     Diag(Using->getLocation(), diag::err_using_decl_conflict);
8016     Diag(Target->getLocation(), diag::note_using_decl_target);
8017     Diag(Tag->getLocation(), diag::note_using_decl_conflict);
8018     return true;
8019   }
8020 
8021   // No conflict between a tag and a non-tag.
8022   if (!NonTag) return false;
8023 
8024   Diag(Using->getLocation(), diag::err_using_decl_conflict);
8025   Diag(Target->getLocation(), diag::note_using_decl_target);
8026   Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
8027   return true;
8028 }
8029 
8030 /// Determine whether a direct base class is a virtual base class.
isVirtualDirectBase(CXXRecordDecl * Derived,CXXRecordDecl * Base)8031 static bool isVirtualDirectBase(CXXRecordDecl *Derived, CXXRecordDecl *Base) {
8032   if (!Derived->getNumVBases())
8033     return false;
8034   for (auto &B : Derived->bases())
8035     if (B.getType()->getAsCXXRecordDecl() == Base)
8036       return B.isVirtual();
8037   llvm_unreachable("not a direct base class");
8038 }
8039 
8040 /// Builds a shadow declaration corresponding to a 'using' declaration.
BuildUsingShadowDecl(Scope * S,UsingDecl * UD,NamedDecl * Orig,UsingShadowDecl * PrevDecl)8041 UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S,
8042                                             UsingDecl *UD,
8043                                             NamedDecl *Orig,
8044                                             UsingShadowDecl *PrevDecl) {
8045   // If we resolved to another shadow declaration, just coalesce them.
8046   NamedDecl *Target = Orig;
8047   if (isa<UsingShadowDecl>(Target)) {
8048     Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
8049     assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
8050   }
8051 
8052   NamedDecl *NonTemplateTarget = Target;
8053   if (auto *TargetTD = dyn_cast<TemplateDecl>(Target))
8054     NonTemplateTarget = TargetTD->getTemplatedDecl();
8055 
8056   UsingShadowDecl *Shadow;
8057   if (isa<CXXConstructorDecl>(NonTemplateTarget)) {
8058     bool IsVirtualBase =
8059         isVirtualDirectBase(cast<CXXRecordDecl>(CurContext),
8060                             UD->getQualifier()->getAsRecordDecl());
8061     Shadow = ConstructorUsingShadowDecl::Create(
8062         Context, CurContext, UD->getLocation(), UD, Orig, IsVirtualBase);
8063   } else {
8064     Shadow = UsingShadowDecl::Create(Context, CurContext, UD->getLocation(), UD,
8065                                      Target);
8066   }
8067   UD->addShadowDecl(Shadow);
8068 
8069   Shadow->setAccess(UD->getAccess());
8070   if (Orig->isInvalidDecl() || UD->isInvalidDecl())
8071     Shadow->setInvalidDecl();
8072 
8073   Shadow->setPreviousDecl(PrevDecl);
8074 
8075   if (S)
8076     PushOnScopeChains(Shadow, S);
8077   else
8078     CurContext->addDecl(Shadow);
8079 
8080 
8081   return Shadow;
8082 }
8083 
8084 /// Hides a using shadow declaration.  This is required by the current
8085 /// using-decl implementation when a resolvable using declaration in a
8086 /// class is followed by a declaration which would hide or override
8087 /// one or more of the using decl's targets; for example:
8088 ///
8089 ///   struct Base { void foo(int); };
8090 ///   struct Derived : Base {
8091 ///     using Base::foo;
8092 ///     void foo(int);
8093 ///   };
8094 ///
8095 /// The governing language is C++03 [namespace.udecl]p12:
8096 ///
8097 ///   When a using-declaration brings names from a base class into a
8098 ///   derived class scope, member functions in the derived class
8099 ///   override and/or hide member functions with the same name and
8100 ///   parameter types in a base class (rather than conflicting).
8101 ///
8102 /// There are two ways to implement this:
8103 ///   (1) optimistically create shadow decls when they're not hidden
8104 ///       by existing declarations, or
8105 ///   (2) don't create any shadow decls (or at least don't make them
8106 ///       visible) until we've fully parsed/instantiated the class.
8107 /// The problem with (1) is that we might have to retroactively remove
8108 /// a shadow decl, which requires several O(n) operations because the
8109 /// decl structures are (very reasonably) not designed for removal.
8110 /// (2) avoids this but is very fiddly and phase-dependent.
HideUsingShadowDecl(Scope * S,UsingShadowDecl * Shadow)8111 void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
8112   if (Shadow->getDeclName().getNameKind() ==
8113         DeclarationName::CXXConversionFunctionName)
8114     cast<CXXRecordDecl>(Shadow->getDeclContext())->removeConversion(Shadow);
8115 
8116   // Remove it from the DeclContext...
8117   Shadow->getDeclContext()->removeDecl(Shadow);
8118 
8119   // ...and the scope, if applicable...
8120   if (S) {
8121     S->RemoveDecl(Shadow);
8122     IdResolver.RemoveDecl(Shadow);
8123   }
8124 
8125   // ...and the using decl.
8126   Shadow->getUsingDecl()->removeShadowDecl(Shadow);
8127 
8128   // TODO: complain somehow if Shadow was used.  It shouldn't
8129   // be possible for this to happen, because...?
8130 }
8131 
8132 /// Find the base specifier for a base class with the given type.
findDirectBaseWithType(CXXRecordDecl * Derived,QualType DesiredBase,bool & AnyDependentBases)8133 static CXXBaseSpecifier *findDirectBaseWithType(CXXRecordDecl *Derived,
8134                                                 QualType DesiredBase,
8135                                                 bool &AnyDependentBases) {
8136   // Check whether the named type is a direct base class.
8137   CanQualType CanonicalDesiredBase = DesiredBase->getCanonicalTypeUnqualified();
8138   for (auto &Base : Derived->bases()) {
8139     CanQualType BaseType = Base.getType()->getCanonicalTypeUnqualified();
8140     if (CanonicalDesiredBase == BaseType)
8141       return &Base;
8142     if (BaseType->isDependentType())
8143       AnyDependentBases = true;
8144   }
8145   return nullptr;
8146 }
8147 
8148 namespace {
8149 class UsingValidatorCCC : public CorrectionCandidateCallback {
8150 public:
UsingValidatorCCC(bool HasTypenameKeyword,bool IsInstantiation,NestedNameSpecifier * NNS,CXXRecordDecl * RequireMemberOf)8151   UsingValidatorCCC(bool HasTypenameKeyword, bool IsInstantiation,
8152                     NestedNameSpecifier *NNS, CXXRecordDecl *RequireMemberOf)
8153       : HasTypenameKeyword(HasTypenameKeyword),
8154         IsInstantiation(IsInstantiation), OldNNS(NNS),
8155         RequireMemberOf(RequireMemberOf) {}
8156 
ValidateCandidate(const TypoCorrection & Candidate)8157   bool ValidateCandidate(const TypoCorrection &Candidate) override {
8158     NamedDecl *ND = Candidate.getCorrectionDecl();
8159 
8160     // Keywords are not valid here.
8161     if (!ND || isa<NamespaceDecl>(ND))
8162       return false;
8163 
8164     // Completely unqualified names are invalid for a 'using' declaration.
8165     if (Candidate.WillReplaceSpecifier() && !Candidate.getCorrectionSpecifier())
8166       return false;
8167 
8168     // FIXME: Don't correct to a name that CheckUsingDeclRedeclaration would
8169     // reject.
8170 
8171     if (RequireMemberOf) {
8172       auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
8173       if (FoundRecord && FoundRecord->isInjectedClassName()) {
8174         // No-one ever wants a using-declaration to name an injected-class-name
8175         // of a base class, unless they're declaring an inheriting constructor.
8176         ASTContext &Ctx = ND->getASTContext();
8177         if (!Ctx.getLangOpts().CPlusPlus11)
8178           return false;
8179         QualType FoundType = Ctx.getRecordType(FoundRecord);
8180 
8181         // Check that the injected-class-name is named as a member of its own
8182         // type; we don't want to suggest 'using Derived::Base;', since that
8183         // means something else.
8184         NestedNameSpecifier *Specifier =
8185             Candidate.WillReplaceSpecifier()
8186                 ? Candidate.getCorrectionSpecifier()
8187                 : OldNNS;
8188         if (!Specifier->getAsType() ||
8189             !Ctx.hasSameType(QualType(Specifier->getAsType(), 0), FoundType))
8190           return false;
8191 
8192         // Check that this inheriting constructor declaration actually names a
8193         // direct base class of the current class.
8194         bool AnyDependentBases = false;
8195         if (!findDirectBaseWithType(RequireMemberOf,
8196                                     Ctx.getRecordType(FoundRecord),
8197                                     AnyDependentBases) &&
8198             !AnyDependentBases)
8199           return false;
8200       } else {
8201         auto *RD = dyn_cast<CXXRecordDecl>(ND->getDeclContext());
8202         if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(RD))
8203           return false;
8204 
8205         // FIXME: Check that the base class member is accessible?
8206       }
8207     } else {
8208       auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
8209       if (FoundRecord && FoundRecord->isInjectedClassName())
8210         return false;
8211     }
8212 
8213     if (isa<TypeDecl>(ND))
8214       return HasTypenameKeyword || !IsInstantiation;
8215 
8216     return !HasTypenameKeyword;
8217   }
8218 
8219 private:
8220   bool HasTypenameKeyword;
8221   bool IsInstantiation;
8222   NestedNameSpecifier *OldNNS;
8223   CXXRecordDecl *RequireMemberOf;
8224 };
8225 } // end anonymous namespace
8226 
8227 /// Builds a using declaration.
8228 ///
8229 /// \param IsInstantiation - Whether this call arises from an
8230 ///   instantiation of an unresolved using declaration.  We treat
8231 ///   the lookup differently for these declarations.
BuildUsingDeclaration(Scope * S,AccessSpecifier AS,SourceLocation UsingLoc,CXXScopeSpec & SS,DeclarationNameInfo NameInfo,AttributeList * AttrList,bool IsInstantiation,bool HasTypenameKeyword,SourceLocation TypenameLoc)8232 NamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
8233                                        SourceLocation UsingLoc,
8234                                        CXXScopeSpec &SS,
8235                                        DeclarationNameInfo NameInfo,
8236                                        AttributeList *AttrList,
8237                                        bool IsInstantiation,
8238                                        bool HasTypenameKeyword,
8239                                        SourceLocation TypenameLoc) {
8240   assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
8241   SourceLocation IdentLoc = NameInfo.getLoc();
8242   assert(IdentLoc.isValid() && "Invalid TargetName location.");
8243 
8244   // FIXME: We ignore attributes for now.
8245 
8246   if (SS.isEmpty()) {
8247     Diag(IdentLoc, diag::err_using_requires_qualname);
8248     return nullptr;
8249   }
8250 
8251   // For an inheriting constructor declaration, the name of the using
8252   // declaration is the name of a constructor in this class, not in the
8253   // base class.
8254   DeclarationNameInfo UsingName = NameInfo;
8255   if (UsingName.getName().getNameKind() == DeclarationName::CXXConstructorName)
8256     if (auto *RD = dyn_cast<CXXRecordDecl>(CurContext))
8257       UsingName.setName(Context.DeclarationNames.getCXXConstructorName(
8258           Context.getCanonicalType(Context.getRecordType(RD))));
8259 
8260   // Do the redeclaration lookup in the current scope.
8261   LookupResult Previous(*this, UsingName, LookupUsingDeclName,
8262                         ForRedeclaration);
8263   Previous.setHideTags(false);
8264   if (S) {
8265     LookupName(Previous, S);
8266 
8267     // It is really dumb that we have to do this.
8268     LookupResult::Filter F = Previous.makeFilter();
8269     while (F.hasNext()) {
8270       NamedDecl *D = F.next();
8271       if (!isDeclInScope(D, CurContext, S))
8272         F.erase();
8273       // If we found a local extern declaration that's not ordinarily visible,
8274       // and this declaration is being added to a non-block scope, ignore it.
8275       // We're only checking for scope conflicts here, not also for violations
8276       // of the linkage rules.
8277       else if (!CurContext->isFunctionOrMethod() && D->isLocalExternDecl() &&
8278                !(D->getIdentifierNamespace() & Decl::IDNS_Ordinary))
8279         F.erase();
8280     }
8281     F.done();
8282   } else {
8283     assert(IsInstantiation && "no scope in non-instantiation");
8284     assert(CurContext->isRecord() && "scope not record in instantiation");
8285     LookupQualifiedName(Previous, CurContext);
8286   }
8287 
8288   // Check for invalid redeclarations.
8289   if (CheckUsingDeclRedeclaration(UsingLoc, HasTypenameKeyword,
8290                                   SS, IdentLoc, Previous))
8291     return nullptr;
8292 
8293   // Check for bad qualifiers.
8294   if (CheckUsingDeclQualifier(UsingLoc, SS, NameInfo, IdentLoc))
8295     return nullptr;
8296 
8297   DeclContext *LookupContext = computeDeclContext(SS);
8298   NamedDecl *D;
8299   NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
8300   if (!LookupContext) {
8301     if (HasTypenameKeyword) {
8302       // FIXME: not all declaration name kinds are legal here
8303       D = UnresolvedUsingTypenameDecl::Create(Context, CurContext,
8304                                               UsingLoc, TypenameLoc,
8305                                               QualifierLoc,
8306                                               IdentLoc, NameInfo.getName());
8307     } else {
8308       D = UnresolvedUsingValueDecl::Create(Context, CurContext, UsingLoc,
8309                                            QualifierLoc, NameInfo);
8310     }
8311     D->setAccess(AS);
8312     CurContext->addDecl(D);
8313     return D;
8314   }
8315 
8316   auto Build = [&](bool Invalid) {
8317     UsingDecl *UD =
8318         UsingDecl::Create(Context, CurContext, UsingLoc, QualifierLoc,
8319                           UsingName, HasTypenameKeyword);
8320     UD->setAccess(AS);
8321     CurContext->addDecl(UD);
8322     UD->setInvalidDecl(Invalid);
8323     return UD;
8324   };
8325   auto BuildInvalid = [&]{ return Build(true); };
8326   auto BuildValid = [&]{ return Build(false); };
8327 
8328   if (RequireCompleteDeclContext(SS, LookupContext))
8329     return BuildInvalid();
8330 
8331   // Look up the target name.
8332   LookupResult R(*this, NameInfo, LookupOrdinaryName);
8333 
8334   // Unlike most lookups, we don't always want to hide tag
8335   // declarations: tag names are visible through the using declaration
8336   // even if hidden by ordinary names, *except* in a dependent context
8337   // where it's important for the sanity of two-phase lookup.
8338   if (!IsInstantiation)
8339     R.setHideTags(false);
8340 
8341   // For the purposes of this lookup, we have a base object type
8342   // equal to that of the current context.
8343   if (CurContext->isRecord()) {
8344     R.setBaseObjectType(
8345                    Context.getTypeDeclType(cast<CXXRecordDecl>(CurContext)));
8346   }
8347 
8348   LookupQualifiedName(R, LookupContext);
8349 
8350   // Try to correct typos if possible. If constructor name lookup finds no
8351   // results, that means the named class has no explicit constructors, and we
8352   // suppressed declaring implicit ones (probably because it's dependent or
8353   // invalid).
8354   if (R.empty() &&
8355       NameInfo.getName().getNameKind() != DeclarationName::CXXConstructorName) {
8356     if (TypoCorrection Corrected = CorrectTypo(
8357             R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
8358             llvm::make_unique<UsingValidatorCCC>(
8359                 HasTypenameKeyword, IsInstantiation, SS.getScopeRep(),
8360                 dyn_cast<CXXRecordDecl>(CurContext)),
8361             CTK_ErrorRecovery)) {
8362       // We reject any correction for which ND would be NULL.
8363       NamedDecl *ND = Corrected.getCorrectionDecl();
8364 
8365       // We reject candidates where DroppedSpecifier == true, hence the
8366       // literal '0' below.
8367       diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
8368                                 << NameInfo.getName() << LookupContext << 0
8369                                 << SS.getRange());
8370 
8371       // If we corrected to an inheriting constructor, handle it as one.
8372       auto *RD = dyn_cast<CXXRecordDecl>(ND);
8373       if (RD && RD->isInjectedClassName()) {
8374         // The parent of the injected class name is the class itself.
8375         RD = cast<CXXRecordDecl>(RD->getParent());
8376 
8377         // Fix up the information we'll use to build the using declaration.
8378         if (Corrected.WillReplaceSpecifier()) {
8379           NestedNameSpecifierLocBuilder Builder;
8380           Builder.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
8381                               QualifierLoc.getSourceRange());
8382           QualifierLoc = Builder.getWithLocInContext(Context);
8383         }
8384 
8385         // In this case, the name we introduce is the name of a derived class
8386         // constructor.
8387         auto *CurClass = cast<CXXRecordDecl>(CurContext);
8388         UsingName.setName(Context.DeclarationNames.getCXXConstructorName(
8389             Context.getCanonicalType(Context.getRecordType(CurClass))));
8390         UsingName.setNamedTypeInfo(nullptr);
8391         for (auto *Ctor : LookupConstructors(RD))
8392           R.addDecl(Ctor);
8393         R.resolveKind();
8394       } else {
8395         // FIXME: Pick up all the declarations if we found an overloaded
8396         // function.
8397         UsingName.setName(ND->getDeclName());
8398         R.addDecl(ND);
8399       }
8400     } else {
8401       Diag(IdentLoc, diag::err_no_member)
8402         << NameInfo.getName() << LookupContext << SS.getRange();
8403       return BuildInvalid();
8404     }
8405   }
8406 
8407   if (R.isAmbiguous())
8408     return BuildInvalid();
8409 
8410   if (HasTypenameKeyword) {
8411     // If we asked for a typename and got a non-type decl, error out.
8412     if (!R.getAsSingle<TypeDecl>()) {
8413       Diag(IdentLoc, diag::err_using_typename_non_type);
8414       for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
8415         Diag((*I)->getUnderlyingDecl()->getLocation(),
8416              diag::note_using_decl_target);
8417       return BuildInvalid();
8418     }
8419   } else {
8420     // If we asked for a non-typename and we got a type, error out,
8421     // but only if this is an instantiation of an unresolved using
8422     // decl.  Otherwise just silently find the type name.
8423     if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
8424       Diag(IdentLoc, diag::err_using_dependent_value_is_type);
8425       Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
8426       return BuildInvalid();
8427     }
8428   }
8429 
8430   // C++14 [namespace.udecl]p6:
8431   // A using-declaration shall not name a namespace.
8432   if (R.getAsSingle<NamespaceDecl>()) {
8433     Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
8434       << SS.getRange();
8435     return BuildInvalid();
8436   }
8437 
8438   // C++14 [namespace.udecl]p7:
8439   // A using-declaration shall not name a scoped enumerator.
8440   if (auto *ED = R.getAsSingle<EnumConstantDecl>()) {
8441     if (cast<EnumDecl>(ED->getDeclContext())->isScoped()) {
8442       Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_scoped_enum)
8443         << SS.getRange();
8444       return BuildInvalid();
8445     }
8446   }
8447 
8448   UsingDecl *UD = BuildValid();
8449 
8450   // Some additional rules apply to inheriting constructors.
8451   if (UsingName.getName().getNameKind() ==
8452         DeclarationName::CXXConstructorName) {
8453     // Suppress access diagnostics; the access check is instead performed at the
8454     // point of use for an inheriting constructor.
8455     R.suppressDiagnostics();
8456     if (CheckInheritingConstructorUsingDecl(UD))
8457       return UD;
8458   }
8459 
8460   for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
8461     UsingShadowDecl *PrevDecl = nullptr;
8462     if (!CheckUsingShadowDecl(UD, *I, Previous, PrevDecl))
8463       BuildUsingShadowDecl(S, UD, *I, PrevDecl);
8464   }
8465 
8466   return UD;
8467 }
8468 
8469 /// Additional checks for a using declaration referring to a constructor name.
CheckInheritingConstructorUsingDecl(UsingDecl * UD)8470 bool Sema::CheckInheritingConstructorUsingDecl(UsingDecl *UD) {
8471   assert(!UD->hasTypename() && "expecting a constructor name");
8472 
8473   const Type *SourceType = UD->getQualifier()->getAsType();
8474   assert(SourceType &&
8475          "Using decl naming constructor doesn't have type in scope spec.");
8476   CXXRecordDecl *TargetClass = cast<CXXRecordDecl>(CurContext);
8477 
8478   // Check whether the named type is a direct base class.
8479   bool AnyDependentBases = false;
8480   auto *Base = findDirectBaseWithType(TargetClass, QualType(SourceType, 0),
8481                                       AnyDependentBases);
8482   if (!Base && !AnyDependentBases) {
8483     Diag(UD->getUsingLoc(),
8484          diag::err_using_decl_constructor_not_in_direct_base)
8485       << UD->getNameInfo().getSourceRange()
8486       << QualType(SourceType, 0) << TargetClass;
8487     UD->setInvalidDecl();
8488     return true;
8489   }
8490 
8491   if (Base)
8492     Base->setInheritConstructors();
8493 
8494   return false;
8495 }
8496 
8497 /// Checks that the given using declaration is not an invalid
8498 /// redeclaration.  Note that this is checking only for the using decl
8499 /// itself, not for any ill-formedness among the UsingShadowDecls.
CheckUsingDeclRedeclaration(SourceLocation UsingLoc,bool HasTypenameKeyword,const CXXScopeSpec & SS,SourceLocation NameLoc,const LookupResult & Prev)8500 bool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
8501                                        bool HasTypenameKeyword,
8502                                        const CXXScopeSpec &SS,
8503                                        SourceLocation NameLoc,
8504                                        const LookupResult &Prev) {
8505   // C++03 [namespace.udecl]p8:
8506   // C++0x [namespace.udecl]p10:
8507   //   A using-declaration is a declaration and can therefore be used
8508   //   repeatedly where (and only where) multiple declarations are
8509   //   allowed.
8510   //
8511   // That's in non-member contexts.
8512   if (!CurContext->getRedeclContext()->isRecord())
8513     return false;
8514 
8515   NestedNameSpecifier *Qual = SS.getScopeRep();
8516 
8517   for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
8518     NamedDecl *D = *I;
8519 
8520     bool DTypename;
8521     NestedNameSpecifier *DQual;
8522     if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
8523       DTypename = UD->hasTypename();
8524       DQual = UD->getQualifier();
8525     } else if (UnresolvedUsingValueDecl *UD
8526                  = dyn_cast<UnresolvedUsingValueDecl>(D)) {
8527       DTypename = false;
8528       DQual = UD->getQualifier();
8529     } else if (UnresolvedUsingTypenameDecl *UD
8530                  = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
8531       DTypename = true;
8532       DQual = UD->getQualifier();
8533     } else continue;
8534 
8535     // using decls differ if one says 'typename' and the other doesn't.
8536     // FIXME: non-dependent using decls?
8537     if (HasTypenameKeyword != DTypename) continue;
8538 
8539     // using decls differ if they name different scopes (but note that
8540     // template instantiation can cause this check to trigger when it
8541     // didn't before instantiation).
8542     if (Context.getCanonicalNestedNameSpecifier(Qual) !=
8543         Context.getCanonicalNestedNameSpecifier(DQual))
8544       continue;
8545 
8546     Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
8547     Diag(D->getLocation(), diag::note_using_decl) << 1;
8548     return true;
8549   }
8550 
8551   return false;
8552 }
8553 
8554 
8555 /// Checks that the given nested-name qualifier used in a using decl
8556 /// in the current context is appropriately related to the current
8557 /// scope.  If an error is found, diagnoses it and returns true.
CheckUsingDeclQualifier(SourceLocation UsingLoc,const CXXScopeSpec & SS,const DeclarationNameInfo & NameInfo,SourceLocation NameLoc)8558 bool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc,
8559                                    const CXXScopeSpec &SS,
8560                                    const DeclarationNameInfo &NameInfo,
8561                                    SourceLocation NameLoc) {
8562   DeclContext *NamedContext = computeDeclContext(SS);
8563 
8564   if (!CurContext->isRecord()) {
8565     // C++03 [namespace.udecl]p3:
8566     // C++0x [namespace.udecl]p8:
8567     //   A using-declaration for a class member shall be a member-declaration.
8568 
8569     // If we weren't able to compute a valid scope, it must be a
8570     // dependent class scope.
8571     if (!NamedContext || NamedContext->getRedeclContext()->isRecord()) {
8572       auto *RD = NamedContext
8573                      ? cast<CXXRecordDecl>(NamedContext->getRedeclContext())
8574                      : nullptr;
8575       if (RD && RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), RD))
8576         RD = nullptr;
8577 
8578       Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member)
8579         << SS.getRange();
8580 
8581       // If we have a complete, non-dependent source type, try to suggest a
8582       // way to get the same effect.
8583       if (!RD)
8584         return true;
8585 
8586       // Find what this using-declaration was referring to.
8587       LookupResult R(*this, NameInfo, LookupOrdinaryName);
8588       R.setHideTags(false);
8589       R.suppressDiagnostics();
8590       LookupQualifiedName(R, RD);
8591 
8592       if (R.getAsSingle<TypeDecl>()) {
8593         if (getLangOpts().CPlusPlus11) {
8594           // Convert 'using X::Y;' to 'using Y = X::Y;'.
8595           Diag(SS.getBeginLoc(), diag::note_using_decl_class_member_workaround)
8596             << 0 // alias declaration
8597             << FixItHint::CreateInsertion(SS.getBeginLoc(),
8598                                           NameInfo.getName().getAsString() +
8599                                               " = ");
8600         } else {
8601           // Convert 'using X::Y;' to 'typedef X::Y Y;'.
8602           SourceLocation InsertLoc =
8603               getLocForEndOfToken(NameInfo.getLocEnd());
8604           Diag(InsertLoc, diag::note_using_decl_class_member_workaround)
8605             << 1 // typedef declaration
8606             << FixItHint::CreateReplacement(UsingLoc, "typedef")
8607             << FixItHint::CreateInsertion(
8608                    InsertLoc, " " + NameInfo.getName().getAsString());
8609         }
8610       } else if (R.getAsSingle<VarDecl>()) {
8611         // Don't provide a fixit outside C++11 mode; we don't want to suggest
8612         // repeating the type of the static data member here.
8613         FixItHint FixIt;
8614         if (getLangOpts().CPlusPlus11) {
8615           // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
8616           FixIt = FixItHint::CreateReplacement(
8617               UsingLoc, "auto &" + NameInfo.getName().getAsString() + " = ");
8618         }
8619 
8620         Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
8621           << 2 // reference declaration
8622           << FixIt;
8623       } else if (R.getAsSingle<EnumConstantDecl>()) {
8624         // Don't provide a fixit outside C++11 mode; we don't want to suggest
8625         // repeating the type of the enumeration here, and we can't do so if
8626         // the type is anonymous.
8627         FixItHint FixIt;
8628         if (getLangOpts().CPlusPlus11) {
8629           // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
8630           FixIt = FixItHint::CreateReplacement(
8631               UsingLoc, "constexpr auto " + NameInfo.getName().getAsString() + " = ");
8632         }
8633 
8634         Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
8635           << (getLangOpts().CPlusPlus11 ? 4 : 3) // const[expr] variable
8636           << FixIt;
8637       }
8638       return true;
8639     }
8640 
8641     // Otherwise, everything is known to be fine.
8642     return false;
8643   }
8644 
8645   // The current scope is a record.
8646 
8647   // If the named context is dependent, we can't decide much.
8648   if (!NamedContext) {
8649     // FIXME: in C++0x, we can diagnose if we can prove that the
8650     // nested-name-specifier does not refer to a base class, which is
8651     // still possible in some cases.
8652 
8653     // Otherwise we have to conservatively report that things might be
8654     // okay.
8655     return false;
8656   }
8657 
8658   if (!NamedContext->isRecord()) {
8659     // Ideally this would point at the last name in the specifier,
8660     // but we don't have that level of source info.
8661     Diag(SS.getRange().getBegin(),
8662          diag::err_using_decl_nested_name_specifier_is_not_class)
8663       << SS.getScopeRep() << SS.getRange();
8664     return true;
8665   }
8666 
8667   if (!NamedContext->isDependentContext() &&
8668       RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), NamedContext))
8669     return true;
8670 
8671   if (getLangOpts().CPlusPlus11) {
8672     // C++11 [namespace.udecl]p3:
8673     //   In a using-declaration used as a member-declaration, the
8674     //   nested-name-specifier shall name a base class of the class
8675     //   being defined.
8676 
8677     if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
8678                                  cast<CXXRecordDecl>(NamedContext))) {
8679       if (CurContext == NamedContext) {
8680         Diag(NameLoc,
8681              diag::err_using_decl_nested_name_specifier_is_current_class)
8682           << SS.getRange();
8683         return true;
8684       }
8685 
8686       Diag(SS.getRange().getBegin(),
8687            diag::err_using_decl_nested_name_specifier_is_not_base_class)
8688         << SS.getScopeRep()
8689         << cast<CXXRecordDecl>(CurContext)
8690         << SS.getRange();
8691       return true;
8692     }
8693 
8694     return false;
8695   }
8696 
8697   // C++03 [namespace.udecl]p4:
8698   //   A using-declaration used as a member-declaration shall refer
8699   //   to a member of a base class of the class being defined [etc.].
8700 
8701   // Salient point: SS doesn't have to name a base class as long as
8702   // lookup only finds members from base classes.  Therefore we can
8703   // diagnose here only if we can prove that that can't happen,
8704   // i.e. if the class hierarchies provably don't intersect.
8705 
8706   // TODO: it would be nice if "definitely valid" results were cached
8707   // in the UsingDecl and UsingShadowDecl so that these checks didn't
8708   // need to be repeated.
8709 
8710   llvm::SmallPtrSet<const CXXRecordDecl *, 4> Bases;
8711   auto Collect = [&Bases](const CXXRecordDecl *Base) {
8712     Bases.insert(Base);
8713     return true;
8714   };
8715 
8716   // Collect all bases. Return false if we find a dependent base.
8717   if (!cast<CXXRecordDecl>(CurContext)->forallBases(Collect))
8718     return false;
8719 
8720   // Returns true if the base is dependent or is one of the accumulated base
8721   // classes.
8722   auto IsNotBase = [&Bases](const CXXRecordDecl *Base) {
8723     return !Bases.count(Base);
8724   };
8725 
8726   // Return false if the class has a dependent base or if it or one
8727   // of its bases is present in the base set of the current context.
8728   if (Bases.count(cast<CXXRecordDecl>(NamedContext)) ||
8729       !cast<CXXRecordDecl>(NamedContext)->forallBases(IsNotBase))
8730     return false;
8731 
8732   Diag(SS.getRange().getBegin(),
8733        diag::err_using_decl_nested_name_specifier_is_not_base_class)
8734     << SS.getScopeRep()
8735     << cast<CXXRecordDecl>(CurContext)
8736     << SS.getRange();
8737 
8738   return true;
8739 }
8740 
ActOnAliasDeclaration(Scope * S,AccessSpecifier AS,MultiTemplateParamsArg TemplateParamLists,SourceLocation UsingLoc,UnqualifiedId & Name,AttributeList * AttrList,TypeResult Type,Decl * DeclFromDeclSpec)8741 Decl *Sema::ActOnAliasDeclaration(Scope *S,
8742                                   AccessSpecifier AS,
8743                                   MultiTemplateParamsArg TemplateParamLists,
8744                                   SourceLocation UsingLoc,
8745                                   UnqualifiedId &Name,
8746                                   AttributeList *AttrList,
8747                                   TypeResult Type,
8748                                   Decl *DeclFromDeclSpec) {
8749   // Skip up to the relevant declaration scope.
8750   while (S->isTemplateParamScope())
8751     S = S->getParent();
8752   assert((S->getFlags() & Scope::DeclScope) &&
8753          "got alias-declaration outside of declaration scope");
8754 
8755   if (Type.isInvalid())
8756     return nullptr;
8757 
8758   bool Invalid = false;
8759   DeclarationNameInfo NameInfo = GetNameFromUnqualifiedId(Name);
8760   TypeSourceInfo *TInfo = nullptr;
8761   GetTypeFromParser(Type.get(), &TInfo);
8762 
8763   if (DiagnoseClassNameShadow(CurContext, NameInfo))
8764     return nullptr;
8765 
8766   if (DiagnoseUnexpandedParameterPack(Name.StartLocation, TInfo,
8767                                       UPPC_DeclarationType)) {
8768     Invalid = true;
8769     TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
8770                                              TInfo->getTypeLoc().getBeginLoc());
8771   }
8772 
8773   LookupResult Previous(*this, NameInfo, LookupOrdinaryName, ForRedeclaration);
8774   LookupName(Previous, S);
8775 
8776   // Warn about shadowing the name of a template parameter.
8777   if (Previous.isSingleResult() &&
8778       Previous.getFoundDecl()->isTemplateParameter()) {
8779     DiagnoseTemplateParameterShadow(Name.StartLocation,Previous.getFoundDecl());
8780     Previous.clear();
8781   }
8782 
8783   assert(Name.Kind == UnqualifiedId::IK_Identifier &&
8784          "name in alias declaration must be an identifier");
8785   TypeAliasDecl *NewTD = TypeAliasDecl::Create(Context, CurContext, UsingLoc,
8786                                                Name.StartLocation,
8787                                                Name.Identifier, TInfo);
8788 
8789   NewTD->setAccess(AS);
8790 
8791   if (Invalid)
8792     NewTD->setInvalidDecl();
8793 
8794   ProcessDeclAttributeList(S, NewTD, AttrList);
8795 
8796   CheckTypedefForVariablyModifiedType(S, NewTD);
8797   Invalid |= NewTD->isInvalidDecl();
8798 
8799   bool Redeclaration = false;
8800 
8801   NamedDecl *NewND;
8802   if (TemplateParamLists.size()) {
8803     TypeAliasTemplateDecl *OldDecl = nullptr;
8804     TemplateParameterList *OldTemplateParams = nullptr;
8805 
8806     if (TemplateParamLists.size() != 1) {
8807       Diag(UsingLoc, diag::err_alias_template_extra_headers)
8808         << SourceRange(TemplateParamLists[1]->getTemplateLoc(),
8809          TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
8810     }
8811     TemplateParameterList *TemplateParams = TemplateParamLists[0];
8812 
8813     // Check that we can declare a template here.
8814     if (CheckTemplateDeclScope(S, TemplateParams))
8815       return nullptr;
8816 
8817     // Only consider previous declarations in the same scope.
8818     FilterLookupForScope(Previous, CurContext, S, /*ConsiderLinkage*/false,
8819                          /*ExplicitInstantiationOrSpecialization*/false);
8820     if (!Previous.empty()) {
8821       Redeclaration = true;
8822 
8823       OldDecl = Previous.getAsSingle<TypeAliasTemplateDecl>();
8824       if (!OldDecl && !Invalid) {
8825         Diag(UsingLoc, diag::err_redefinition_different_kind)
8826           << Name.Identifier;
8827 
8828         NamedDecl *OldD = Previous.getRepresentativeDecl();
8829         if (OldD->getLocation().isValid())
8830           Diag(OldD->getLocation(), diag::note_previous_definition);
8831 
8832         Invalid = true;
8833       }
8834 
8835       if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) {
8836         if (TemplateParameterListsAreEqual(TemplateParams,
8837                                            OldDecl->getTemplateParameters(),
8838                                            /*Complain=*/true,
8839                                            TPL_TemplateMatch))
8840           OldTemplateParams = OldDecl->getTemplateParameters();
8841         else
8842           Invalid = true;
8843 
8844         TypeAliasDecl *OldTD = OldDecl->getTemplatedDecl();
8845         if (!Invalid &&
8846             !Context.hasSameType(OldTD->getUnderlyingType(),
8847                                  NewTD->getUnderlyingType())) {
8848           // FIXME: The C++0x standard does not clearly say this is ill-formed,
8849           // but we can't reasonably accept it.
8850           Diag(NewTD->getLocation(), diag::err_redefinition_different_typedef)
8851             << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType();
8852           if (OldTD->getLocation().isValid())
8853             Diag(OldTD->getLocation(), diag::note_previous_definition);
8854           Invalid = true;
8855         }
8856       }
8857     }
8858 
8859     // Merge any previous default template arguments into our parameters,
8860     // and check the parameter list.
8861     if (CheckTemplateParameterList(TemplateParams, OldTemplateParams,
8862                                    TPC_TypeAliasTemplate))
8863       return nullptr;
8864 
8865     TypeAliasTemplateDecl *NewDecl =
8866       TypeAliasTemplateDecl::Create(Context, CurContext, UsingLoc,
8867                                     Name.Identifier, TemplateParams,
8868                                     NewTD);
8869     NewTD->setDescribedAliasTemplate(NewDecl);
8870 
8871     NewDecl->setAccess(AS);
8872 
8873     if (Invalid)
8874       NewDecl->setInvalidDecl();
8875     else if (OldDecl)
8876       NewDecl->setPreviousDecl(OldDecl);
8877 
8878     NewND = NewDecl;
8879   } else {
8880     if (auto *TD = dyn_cast_or_null<TagDecl>(DeclFromDeclSpec)) {
8881       setTagNameForLinkagePurposes(TD, NewTD);
8882       handleTagNumbering(TD, S);
8883     }
8884     ActOnTypedefNameDecl(S, CurContext, NewTD, Previous, Redeclaration);
8885     NewND = NewTD;
8886   }
8887 
8888   if (!Redeclaration)
8889     PushOnScopeChains(NewND, S);
8890 
8891   ActOnDocumentableDecl(NewND);
8892   return NewND;
8893 }
8894 
ActOnNamespaceAliasDef(Scope * S,SourceLocation NamespaceLoc,SourceLocation AliasLoc,IdentifierInfo * Alias,CXXScopeSpec & SS,SourceLocation IdentLoc,IdentifierInfo * Ident)8895 Decl *Sema::ActOnNamespaceAliasDef(Scope *S, SourceLocation NamespaceLoc,
8896                                    SourceLocation AliasLoc,
8897                                    IdentifierInfo *Alias, CXXScopeSpec &SS,
8898                                    SourceLocation IdentLoc,
8899                                    IdentifierInfo *Ident) {
8900 
8901   // Lookup the namespace name.
8902   LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
8903   LookupParsedName(R, S, &SS);
8904 
8905   if (R.isAmbiguous())
8906     return nullptr;
8907 
8908   if (R.empty()) {
8909     if (!TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, Ident)) {
8910       Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
8911       return nullptr;
8912     }
8913   }
8914   assert(!R.isAmbiguous() && !R.empty());
8915   NamedDecl *ND = R.getRepresentativeDecl();
8916 
8917   // Check if we have a previous declaration with the same name.
8918   LookupResult PrevR(*this, Alias, AliasLoc, LookupOrdinaryName,
8919                      ForRedeclaration);
8920   LookupName(PrevR, S);
8921 
8922   // Check we're not shadowing a template parameter.
8923   if (PrevR.isSingleResult() && PrevR.getFoundDecl()->isTemplateParameter()) {
8924     DiagnoseTemplateParameterShadow(AliasLoc, PrevR.getFoundDecl());
8925     PrevR.clear();
8926   }
8927 
8928   // Filter out any other lookup result from an enclosing scope.
8929   FilterLookupForScope(PrevR, CurContext, S, /*ConsiderLinkage*/false,
8930                        /*AllowInlineNamespace*/false);
8931 
8932   // Find the previous declaration and check that we can redeclare it.
8933   NamespaceAliasDecl *Prev = nullptr;
8934   if (PrevR.isSingleResult()) {
8935     NamedDecl *PrevDecl = PrevR.getRepresentativeDecl();
8936     if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
8937       // We already have an alias with the same name that points to the same
8938       // namespace; check that it matches.
8939       if (AD->getNamespace()->Equals(getNamespaceDecl(ND))) {
8940         Prev = AD;
8941       } else if (isVisible(PrevDecl)) {
8942         Diag(AliasLoc, diag::err_redefinition_different_namespace_alias)
8943           << Alias;
8944         Diag(AD->getLocation(), diag::note_previous_namespace_alias)
8945           << AD->getNamespace();
8946         return nullptr;
8947       }
8948     } else if (isVisible(PrevDecl)) {
8949       unsigned DiagID = isa<NamespaceDecl>(PrevDecl->getUnderlyingDecl())
8950                             ? diag::err_redefinition
8951                             : diag::err_redefinition_different_kind;
8952       Diag(AliasLoc, DiagID) << Alias;
8953       Diag(PrevDecl->getLocation(), diag::note_previous_definition);
8954       return nullptr;
8955     }
8956   }
8957 
8958   // The use of a nested name specifier may trigger deprecation warnings.
8959   DiagnoseUseOfDecl(ND, IdentLoc);
8960 
8961   NamespaceAliasDecl *AliasDecl =
8962     NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
8963                                Alias, SS.getWithLocInContext(Context),
8964                                IdentLoc, ND);
8965   if (Prev)
8966     AliasDecl->setPreviousDecl(Prev);
8967 
8968   PushOnScopeChains(AliasDecl, S);
8969   return AliasDecl;
8970 }
8971 
8972 Sema::ImplicitExceptionSpecification
ComputeDefaultedDefaultCtorExceptionSpec(SourceLocation Loc,CXXMethodDecl * MD)8973 Sema::ComputeDefaultedDefaultCtorExceptionSpec(SourceLocation Loc,
8974                                                CXXMethodDecl *MD) {
8975   CXXRecordDecl *ClassDecl = MD->getParent();
8976 
8977   // C++ [except.spec]p14:
8978   //   An implicitly declared special member function (Clause 12) shall have an
8979   //   exception-specification. [...]
8980   ImplicitExceptionSpecification ExceptSpec(*this);
8981   if (ClassDecl->isInvalidDecl())
8982     return ExceptSpec;
8983 
8984   // Direct base-class constructors.
8985   for (const auto &B : ClassDecl->bases()) {
8986     if (B.isVirtual()) // Handled below.
8987       continue;
8988 
8989     if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
8990       CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
8991       CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
8992       // If this is a deleted function, add it anyway. This might be conformant
8993       // with the standard. This might not. I'm not sure. It might not matter.
8994       if (Constructor)
8995         ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
8996     }
8997   }
8998 
8999   // Virtual base-class constructors.
9000   for (const auto &B : ClassDecl->vbases()) {
9001     if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
9002       CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
9003       CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
9004       // If this is a deleted function, add it anyway. This might be conformant
9005       // with the standard. This might not. I'm not sure. It might not matter.
9006       if (Constructor)
9007         ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
9008     }
9009   }
9010 
9011   // Field constructors.
9012   for (const auto *F : ClassDecl->fields()) {
9013     if (F->hasInClassInitializer()) {
9014       if (Expr *E = F->getInClassInitializer())
9015         ExceptSpec.CalledExpr(E);
9016     } else if (const RecordType *RecordTy
9017               = Context.getBaseElementType(F->getType())->getAs<RecordType>()) {
9018       CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
9019       CXXConstructorDecl *Constructor = LookupDefaultConstructor(FieldRecDecl);
9020       // If this is a deleted function, add it anyway. This might be conformant
9021       // with the standard. This might not. I'm not sure. It might not matter.
9022       // In particular, the problem is that this function never gets called. It
9023       // might just be ill-formed because this function attempts to refer to
9024       // a deleted function here.
9025       if (Constructor)
9026         ExceptSpec.CalledDecl(F->getLocation(), Constructor);
9027     }
9028   }
9029 
9030   return ExceptSpec;
9031 }
9032 
9033 Sema::ImplicitExceptionSpecification
ComputeInheritingCtorExceptionSpec(SourceLocation Loc,CXXConstructorDecl * CD)9034 Sema::ComputeInheritingCtorExceptionSpec(SourceLocation Loc,
9035                                          CXXConstructorDecl *CD) {
9036   CXXRecordDecl *ClassDecl = CD->getParent();
9037 
9038   // C++ [except.spec]p14:
9039   //   An inheriting constructor [...] shall have an exception-specification. [...]
9040   ImplicitExceptionSpecification ExceptSpec(*this);
9041   if (ClassDecl->isInvalidDecl())
9042     return ExceptSpec;
9043 
9044   auto Inherited = CD->getInheritedConstructor();
9045   InheritedConstructorInfo ICI(*this, Loc, Inherited.getShadowDecl());
9046 
9047   // Direct and virtual base-class constructors.
9048   for (bool VBase : {false, true}) {
9049     for (CXXBaseSpecifier &B :
9050          VBase ? ClassDecl->vbases() : ClassDecl->bases()) {
9051       // Don't visit direct vbases twice.
9052       if (B.isVirtual() != VBase)
9053         continue;
9054 
9055       CXXRecordDecl *BaseClass = B.getType()->getAsCXXRecordDecl();
9056       if (!BaseClass)
9057         continue;
9058 
9059       CXXConstructorDecl *Constructor =
9060           ICI.findConstructorForBase(BaseClass, Inherited.getConstructor())
9061               .first;
9062       if (!Constructor)
9063         Constructor = LookupDefaultConstructor(BaseClass);
9064       if (Constructor)
9065         ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
9066     }
9067   }
9068 
9069   // Field constructors.
9070   for (const auto *F : ClassDecl->fields()) {
9071     if (F->hasInClassInitializer()) {
9072       if (Expr *E = F->getInClassInitializer())
9073         ExceptSpec.CalledExpr(E);
9074     } else if (const RecordType *RecordTy
9075               = Context.getBaseElementType(F->getType())->getAs<RecordType>()) {
9076       CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
9077       CXXConstructorDecl *Constructor = LookupDefaultConstructor(FieldRecDecl);
9078       if (Constructor)
9079         ExceptSpec.CalledDecl(F->getLocation(), Constructor);
9080     }
9081   }
9082 
9083   return ExceptSpec;
9084 }
9085 
9086 namespace {
9087 /// RAII object to register a special member as being currently declared.
9088 struct DeclaringSpecialMember {
9089   Sema &S;
9090   Sema::SpecialMemberDecl D;
9091   Sema::ContextRAII SavedContext;
9092   bool WasAlreadyBeingDeclared;
9093 
DeclaringSpecialMember__anon92980ac11011::DeclaringSpecialMember9094   DeclaringSpecialMember(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM)
9095     : S(S), D(RD, CSM), SavedContext(S, RD) {
9096     WasAlreadyBeingDeclared = !S.SpecialMembersBeingDeclared.insert(D).second;
9097     if (WasAlreadyBeingDeclared)
9098       // This almost never happens, but if it does, ensure that our cache
9099       // doesn't contain a stale result.
9100       S.SpecialMemberCache.clear();
9101 
9102     // FIXME: Register a note to be produced if we encounter an error while
9103     // declaring the special member.
9104   }
~DeclaringSpecialMember__anon92980ac11011::DeclaringSpecialMember9105   ~DeclaringSpecialMember() {
9106     if (!WasAlreadyBeingDeclared)
9107       S.SpecialMembersBeingDeclared.erase(D);
9108   }
9109 
9110   /// \brief Are we already trying to declare this special member?
isAlreadyBeingDeclared__anon92980ac11011::DeclaringSpecialMember9111   bool isAlreadyBeingDeclared() const {
9112     return WasAlreadyBeingDeclared;
9113   }
9114 };
9115 }
9116 
CheckImplicitSpecialMemberDeclaration(Scope * S,FunctionDecl * FD)9117 void Sema::CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD) {
9118   // Look up any existing declarations, but don't trigger declaration of all
9119   // implicit special members with this name.
9120   DeclarationName Name = FD->getDeclName();
9121   LookupResult R(*this, Name, SourceLocation(), LookupOrdinaryName,
9122                  ForRedeclaration);
9123   for (auto *D : FD->getParent()->lookup(Name))
9124     if (auto *Acceptable = R.getAcceptableDecl(D))
9125       R.addDecl(Acceptable);
9126   R.resolveKind();
9127   R.suppressDiagnostics();
9128 
9129   CheckFunctionDeclaration(S, FD, R, /*IsExplicitSpecialization*/false);
9130 }
9131 
DeclareImplicitDefaultConstructor(CXXRecordDecl * ClassDecl)9132 CXXConstructorDecl *Sema::DeclareImplicitDefaultConstructor(
9133                                                      CXXRecordDecl *ClassDecl) {
9134   // C++ [class.ctor]p5:
9135   //   A default constructor for a class X is a constructor of class X
9136   //   that can be called without an argument. If there is no
9137   //   user-declared constructor for class X, a default constructor is
9138   //   implicitly declared. An implicitly-declared default constructor
9139   //   is an inline public member of its class.
9140   assert(ClassDecl->needsImplicitDefaultConstructor() &&
9141          "Should not build implicit default constructor!");
9142 
9143   DeclaringSpecialMember DSM(*this, ClassDecl, CXXDefaultConstructor);
9144   if (DSM.isAlreadyBeingDeclared())
9145     return nullptr;
9146 
9147   bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
9148                                                      CXXDefaultConstructor,
9149                                                      false);
9150 
9151   // Create the actual constructor declaration.
9152   CanQualType ClassType
9153     = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
9154   SourceLocation ClassLoc = ClassDecl->getLocation();
9155   DeclarationName Name
9156     = Context.DeclarationNames.getCXXConstructorName(ClassType);
9157   DeclarationNameInfo NameInfo(Name, ClassLoc);
9158   CXXConstructorDecl *DefaultCon = CXXConstructorDecl::Create(
9159       Context, ClassDecl, ClassLoc, NameInfo, /*Type*/QualType(),
9160       /*TInfo=*/nullptr, /*isExplicit=*/false, /*isInline=*/true,
9161       /*isImplicitlyDeclared=*/true, Constexpr);
9162   DefaultCon->setAccess(AS_public);
9163   DefaultCon->setDefaulted();
9164 
9165   if (getLangOpts().CUDA) {
9166     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDefaultConstructor,
9167                                             DefaultCon,
9168                                             /* ConstRHS */ false,
9169                                             /* Diagnose */ false);
9170   }
9171 
9172   // Build an exception specification pointing back at this constructor.
9173   FunctionProtoType::ExtProtoInfo EPI = getImplicitMethodEPI(*this, DefaultCon);
9174   DefaultCon->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
9175 
9176   // We don't need to use SpecialMemberIsTrivial here; triviality for default
9177   // constructors is easy to compute.
9178   DefaultCon->setTrivial(ClassDecl->hasTrivialDefaultConstructor());
9179 
9180   // Note that we have declared this constructor.
9181   ++ASTContext::NumImplicitDefaultConstructorsDeclared;
9182 
9183   Scope *S = getScopeForContext(ClassDecl);
9184   CheckImplicitSpecialMemberDeclaration(S, DefaultCon);
9185 
9186   if (ShouldDeleteSpecialMember(DefaultCon, CXXDefaultConstructor))
9187     SetDeclDeleted(DefaultCon, ClassLoc);
9188 
9189   if (S)
9190     PushOnScopeChains(DefaultCon, S, false);
9191   ClassDecl->addDecl(DefaultCon);
9192 
9193   return DefaultCon;
9194 }
9195 
DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,CXXConstructorDecl * Constructor)9196 void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
9197                                             CXXConstructorDecl *Constructor) {
9198   assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
9199           !Constructor->doesThisDeclarationHaveABody() &&
9200           !Constructor->isDeleted()) &&
9201     "DefineImplicitDefaultConstructor - call it for implicit default ctor");
9202 
9203   CXXRecordDecl *ClassDecl = Constructor->getParent();
9204   assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
9205 
9206   SynthesizedFunctionScope Scope(*this, Constructor);
9207   DiagnosticErrorTrap Trap(Diags);
9208   if (SetCtorInitializers(Constructor, /*AnyErrors=*/false) ||
9209       Trap.hasErrorOccurred()) {
9210     Diag(CurrentLocation, diag::note_member_synthesized_at)
9211       << CXXDefaultConstructor << Context.getTagDeclType(ClassDecl);
9212     Constructor->setInvalidDecl();
9213     return;
9214   }
9215 
9216   // The exception specification is needed because we are defining the
9217   // function.
9218   ResolveExceptionSpec(CurrentLocation,
9219                        Constructor->getType()->castAs<FunctionProtoType>());
9220 
9221   SourceLocation Loc = Constructor->getLocEnd().isValid()
9222                            ? Constructor->getLocEnd()
9223                            : Constructor->getLocation();
9224   Constructor->setBody(new (Context) CompoundStmt(Loc));
9225 
9226   Constructor->markUsed(Context);
9227   MarkVTableUsed(CurrentLocation, ClassDecl);
9228 
9229   if (ASTMutationListener *L = getASTMutationListener()) {
9230     L->CompletedImplicitDefinition(Constructor);
9231   }
9232 
9233   DiagnoseUninitializedFields(*this, Constructor);
9234 }
9235 
ActOnFinishDelayedMemberInitializers(Decl * D)9236 void Sema::ActOnFinishDelayedMemberInitializers(Decl *D) {
9237   // Perform any delayed checks on exception specifications.
9238   CheckDelayedMemberExceptionSpecs();
9239 }
9240 
9241 /// Find or create the fake constructor we synthesize to model constructing an
9242 /// object of a derived class via a constructor of a base class.
9243 CXXConstructorDecl *
findInheritingConstructor(SourceLocation Loc,CXXConstructorDecl * BaseCtor,ConstructorUsingShadowDecl * Shadow)9244 Sema::findInheritingConstructor(SourceLocation Loc,
9245                                 CXXConstructorDecl *BaseCtor,
9246                                 ConstructorUsingShadowDecl *Shadow) {
9247   CXXRecordDecl *Derived = Shadow->getParent();
9248   SourceLocation UsingLoc = Shadow->getLocation();
9249 
9250   // FIXME: Add a new kind of DeclarationName for an inherited constructor.
9251   // For now we use the name of the base class constructor as a member of the
9252   // derived class to indicate a (fake) inherited constructor name.
9253   DeclarationName Name = BaseCtor->getDeclName();
9254 
9255   // Check to see if we already have a fake constructor for this inherited
9256   // constructor call.
9257   for (NamedDecl *Ctor : Derived->lookup(Name))
9258     if (declaresSameEntity(cast<CXXConstructorDecl>(Ctor)
9259                                ->getInheritedConstructor()
9260                                .getConstructor(),
9261                            BaseCtor))
9262       return cast<CXXConstructorDecl>(Ctor);
9263 
9264   DeclarationNameInfo NameInfo(Name, UsingLoc);
9265   TypeSourceInfo *TInfo =
9266       Context.getTrivialTypeSourceInfo(BaseCtor->getType(), UsingLoc);
9267   FunctionProtoTypeLoc ProtoLoc =
9268       TInfo->getTypeLoc().IgnoreParens().castAs<FunctionProtoTypeLoc>();
9269 
9270   // Check the inherited constructor is valid and find the list of base classes
9271   // from which it was inherited.
9272   InheritedConstructorInfo ICI(*this, Loc, Shadow);
9273 
9274   bool Constexpr =
9275       BaseCtor->isConstexpr() &&
9276       defaultedSpecialMemberIsConstexpr(*this, Derived, CXXDefaultConstructor,
9277                                         false, BaseCtor, &ICI);
9278 
9279   CXXConstructorDecl *DerivedCtor = CXXConstructorDecl::Create(
9280       Context, Derived, UsingLoc, NameInfo, TInfo->getType(), TInfo,
9281       BaseCtor->isExplicit(), /*Inline=*/true,
9282       /*ImplicitlyDeclared=*/true, Constexpr,
9283       InheritedConstructor(Shadow, BaseCtor));
9284   if (Shadow->isInvalidDecl())
9285     DerivedCtor->setInvalidDecl();
9286 
9287   // Build an unevaluated exception specification for this fake constructor.
9288   const FunctionProtoType *FPT = TInfo->getType()->castAs<FunctionProtoType>();
9289   FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
9290   EPI.ExceptionSpec.Type = EST_Unevaluated;
9291   EPI.ExceptionSpec.SourceDecl = DerivedCtor;
9292   DerivedCtor->setType(Context.getFunctionType(FPT->getReturnType(),
9293                                                FPT->getParamTypes(), EPI));
9294 
9295   // Build the parameter declarations.
9296   SmallVector<ParmVarDecl *, 16> ParamDecls;
9297   for (unsigned I = 0, N = FPT->getNumParams(); I != N; ++I) {
9298     TypeSourceInfo *TInfo =
9299         Context.getTrivialTypeSourceInfo(FPT->getParamType(I), UsingLoc);
9300     ParmVarDecl *PD = ParmVarDecl::Create(
9301         Context, DerivedCtor, UsingLoc, UsingLoc, /*IdentifierInfo=*/nullptr,
9302         FPT->getParamType(I), TInfo, SC_None, /*DefaultArg=*/nullptr);
9303     PD->setScopeInfo(0, I);
9304     PD->setImplicit();
9305     // Ensure attributes are propagated onto parameters (this matters for
9306     // format, pass_object_size, ...).
9307     mergeDeclAttributes(PD, BaseCtor->getParamDecl(I));
9308     ParamDecls.push_back(PD);
9309     ProtoLoc.setParam(I, PD);
9310   }
9311 
9312   // Set up the new constructor.
9313   assert(!BaseCtor->isDeleted() && "should not use deleted constructor");
9314   DerivedCtor->setAccess(BaseCtor->getAccess());
9315   DerivedCtor->setParams(ParamDecls);
9316   Derived->addDecl(DerivedCtor);
9317 
9318   if (ShouldDeleteSpecialMember(DerivedCtor, CXXDefaultConstructor, &ICI))
9319     SetDeclDeleted(DerivedCtor, UsingLoc);
9320 
9321   return DerivedCtor;
9322 }
9323 
NoteDeletedInheritingConstructor(CXXConstructorDecl * Ctor)9324 void Sema::NoteDeletedInheritingConstructor(CXXConstructorDecl *Ctor) {
9325   InheritedConstructorInfo ICI(*this, Ctor->getLocation(),
9326                                Ctor->getInheritedConstructor().getShadowDecl());
9327   ShouldDeleteSpecialMember(Ctor, CXXDefaultConstructor, &ICI,
9328                             /*Diagnose*/true);
9329 }
9330 
DefineInheritingConstructor(SourceLocation CurrentLocation,CXXConstructorDecl * Constructor)9331 void Sema::DefineInheritingConstructor(SourceLocation CurrentLocation,
9332                                        CXXConstructorDecl *Constructor) {
9333   CXXRecordDecl *ClassDecl = Constructor->getParent();
9334   assert(Constructor->getInheritedConstructor() &&
9335          !Constructor->doesThisDeclarationHaveABody() &&
9336          !Constructor->isDeleted());
9337   if (Constructor->isInvalidDecl())
9338     return;
9339 
9340   ConstructorUsingShadowDecl *Shadow =
9341       Constructor->getInheritedConstructor().getShadowDecl();
9342   CXXConstructorDecl *InheritedCtor =
9343       Constructor->getInheritedConstructor().getConstructor();
9344 
9345   // [class.inhctor.init]p1:
9346   //   initialization proceeds as if a defaulted default constructor is used to
9347   //   initialize the D object and each base class subobject from which the
9348   //   constructor was inherited
9349 
9350   InheritedConstructorInfo ICI(*this, CurrentLocation, Shadow);
9351   CXXRecordDecl *RD = Shadow->getParent();
9352   SourceLocation InitLoc = Shadow->getLocation();
9353 
9354   // Initializations are performed "as if by a defaulted default constructor",
9355   // so enter the appropriate scope.
9356   SynthesizedFunctionScope Scope(*this, Constructor);
9357   DiagnosticErrorTrap Trap(Diags);
9358 
9359   // Build explicit initializers for all base classes from which the
9360   // constructor was inherited.
9361   SmallVector<CXXCtorInitializer*, 8> Inits;
9362   for (bool VBase : {false, true}) {
9363     for (CXXBaseSpecifier &B : VBase ? RD->vbases() : RD->bases()) {
9364       if (B.isVirtual() != VBase)
9365         continue;
9366 
9367       auto *BaseRD = B.getType()->getAsCXXRecordDecl();
9368       if (!BaseRD)
9369         continue;
9370 
9371       auto BaseCtor = ICI.findConstructorForBase(BaseRD, InheritedCtor);
9372       if (!BaseCtor.first)
9373         continue;
9374 
9375       MarkFunctionReferenced(CurrentLocation, BaseCtor.first);
9376       ExprResult Init = new (Context) CXXInheritedCtorInitExpr(
9377           InitLoc, B.getType(), BaseCtor.first, VBase, BaseCtor.second);
9378 
9379       auto *TInfo = Context.getTrivialTypeSourceInfo(B.getType(), InitLoc);
9380       Inits.push_back(new (Context) CXXCtorInitializer(
9381           Context, TInfo, VBase, InitLoc, Init.get(), InitLoc,
9382           SourceLocation()));
9383     }
9384   }
9385 
9386   // We now proceed as if for a defaulted default constructor, with the relevant
9387   // initializers replaced.
9388 
9389   bool HadError = SetCtorInitializers(Constructor, /*AnyErrors*/false, Inits);
9390   if (HadError || Trap.hasErrorOccurred()) {
9391     Diag(CurrentLocation, diag::note_inhctor_synthesized_at) << RD;
9392     Constructor->setInvalidDecl();
9393     return;
9394   }
9395 
9396   // The exception specification is needed because we are defining the
9397   // function.
9398   ResolveExceptionSpec(CurrentLocation,
9399                        Constructor->getType()->castAs<FunctionProtoType>());
9400 
9401   Constructor->setBody(new (Context) CompoundStmt(InitLoc));
9402 
9403   Constructor->markUsed(Context);
9404   MarkVTableUsed(CurrentLocation, ClassDecl);
9405 
9406   if (ASTMutationListener *L = getASTMutationListener()) {
9407     L->CompletedImplicitDefinition(Constructor);
9408   }
9409 
9410   DiagnoseUninitializedFields(*this, Constructor);
9411 }
9412 
9413 Sema::ImplicitExceptionSpecification
ComputeDefaultedDtorExceptionSpec(CXXMethodDecl * MD)9414 Sema::ComputeDefaultedDtorExceptionSpec(CXXMethodDecl *MD) {
9415   CXXRecordDecl *ClassDecl = MD->getParent();
9416 
9417   // C++ [except.spec]p14:
9418   //   An implicitly declared special member function (Clause 12) shall have
9419   //   an exception-specification.
9420   ImplicitExceptionSpecification ExceptSpec(*this);
9421   if (ClassDecl->isInvalidDecl())
9422     return ExceptSpec;
9423 
9424   // Direct base-class destructors.
9425   for (const auto &B : ClassDecl->bases()) {
9426     if (B.isVirtual()) // Handled below.
9427       continue;
9428 
9429     if (const RecordType *BaseType = B.getType()->getAs<RecordType>())
9430       ExceptSpec.CalledDecl(B.getLocStart(),
9431                    LookupDestructor(cast<CXXRecordDecl>(BaseType->getDecl())));
9432   }
9433 
9434   // Virtual base-class destructors.
9435   for (const auto &B : ClassDecl->vbases()) {
9436     if (const RecordType *BaseType = B.getType()->getAs<RecordType>())
9437       ExceptSpec.CalledDecl(B.getLocStart(),
9438                   LookupDestructor(cast<CXXRecordDecl>(BaseType->getDecl())));
9439   }
9440 
9441   // Field destructors.
9442   for (const auto *F : ClassDecl->fields()) {
9443     if (const RecordType *RecordTy
9444         = Context.getBaseElementType(F->getType())->getAs<RecordType>())
9445       ExceptSpec.CalledDecl(F->getLocation(),
9446                   LookupDestructor(cast<CXXRecordDecl>(RecordTy->getDecl())));
9447   }
9448 
9449   return ExceptSpec;
9450 }
9451 
DeclareImplicitDestructor(CXXRecordDecl * ClassDecl)9452 CXXDestructorDecl *Sema::DeclareImplicitDestructor(CXXRecordDecl *ClassDecl) {
9453   // C++ [class.dtor]p2:
9454   //   If a class has no user-declared destructor, a destructor is
9455   //   declared implicitly. An implicitly-declared destructor is an
9456   //   inline public member of its class.
9457   assert(ClassDecl->needsImplicitDestructor());
9458 
9459   DeclaringSpecialMember DSM(*this, ClassDecl, CXXDestructor);
9460   if (DSM.isAlreadyBeingDeclared())
9461     return nullptr;
9462 
9463   // Create the actual destructor declaration.
9464   CanQualType ClassType
9465     = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
9466   SourceLocation ClassLoc = ClassDecl->getLocation();
9467   DeclarationName Name
9468     = Context.DeclarationNames.getCXXDestructorName(ClassType);
9469   DeclarationNameInfo NameInfo(Name, ClassLoc);
9470   CXXDestructorDecl *Destructor
9471       = CXXDestructorDecl::Create(Context, ClassDecl, ClassLoc, NameInfo,
9472                                   QualType(), nullptr, /*isInline=*/true,
9473                                   /*isImplicitlyDeclared=*/true);
9474   Destructor->setAccess(AS_public);
9475   Destructor->setDefaulted();
9476 
9477   if (getLangOpts().CUDA) {
9478     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDestructor,
9479                                             Destructor,
9480                                             /* ConstRHS */ false,
9481                                             /* Diagnose */ false);
9482   }
9483 
9484   // Build an exception specification pointing back at this destructor.
9485   FunctionProtoType::ExtProtoInfo EPI = getImplicitMethodEPI(*this, Destructor);
9486   Destructor->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
9487 
9488   // We don't need to use SpecialMemberIsTrivial here; triviality for
9489   // destructors is easy to compute.
9490   Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
9491 
9492   // Note that we have declared this destructor.
9493   ++ASTContext::NumImplicitDestructorsDeclared;
9494 
9495   Scope *S = getScopeForContext(ClassDecl);
9496   CheckImplicitSpecialMemberDeclaration(S, Destructor);
9497 
9498   if (ShouldDeleteSpecialMember(Destructor, CXXDestructor))
9499     SetDeclDeleted(Destructor, ClassLoc);
9500 
9501   // Introduce this destructor into its scope.
9502   if (S)
9503     PushOnScopeChains(Destructor, S, false);
9504   ClassDecl->addDecl(Destructor);
9505 
9506   return Destructor;
9507 }
9508 
DefineImplicitDestructor(SourceLocation CurrentLocation,CXXDestructorDecl * Destructor)9509 void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
9510                                     CXXDestructorDecl *Destructor) {
9511   assert((Destructor->isDefaulted() &&
9512           !Destructor->doesThisDeclarationHaveABody() &&
9513           !Destructor->isDeleted()) &&
9514          "DefineImplicitDestructor - call it for implicit default dtor");
9515   CXXRecordDecl *ClassDecl = Destructor->getParent();
9516   assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
9517 
9518   if (Destructor->isInvalidDecl())
9519     return;
9520 
9521   SynthesizedFunctionScope Scope(*this, Destructor);
9522 
9523   DiagnosticErrorTrap Trap(Diags);
9524   MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
9525                                          Destructor->getParent());
9526 
9527   if (CheckDestructor(Destructor) || Trap.hasErrorOccurred()) {
9528     Diag(CurrentLocation, diag::note_member_synthesized_at)
9529       << CXXDestructor << Context.getTagDeclType(ClassDecl);
9530 
9531     Destructor->setInvalidDecl();
9532     return;
9533   }
9534 
9535   // The exception specification is needed because we are defining the
9536   // function.
9537   ResolveExceptionSpec(CurrentLocation,
9538                        Destructor->getType()->castAs<FunctionProtoType>());
9539 
9540   SourceLocation Loc = Destructor->getLocEnd().isValid()
9541                            ? Destructor->getLocEnd()
9542                            : Destructor->getLocation();
9543   Destructor->setBody(new (Context) CompoundStmt(Loc));
9544   Destructor->markUsed(Context);
9545   MarkVTableUsed(CurrentLocation, ClassDecl);
9546 
9547   if (ASTMutationListener *L = getASTMutationListener()) {
9548     L->CompletedImplicitDefinition(Destructor);
9549   }
9550 }
9551 
9552 /// \brief Perform any semantic analysis which needs to be delayed until all
9553 /// pending class member declarations have been parsed.
ActOnFinishCXXMemberDecls()9554 void Sema::ActOnFinishCXXMemberDecls() {
9555   // If the context is an invalid C++ class, just suppress these checks.
9556   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(CurContext)) {
9557     if (Record->isInvalidDecl()) {
9558       DelayedDefaultedMemberExceptionSpecs.clear();
9559       DelayedExceptionSpecChecks.clear();
9560       return;
9561     }
9562   }
9563 }
9564 
getDefaultArgExprsForConstructors(Sema & S,CXXRecordDecl * Class)9565 static void getDefaultArgExprsForConstructors(Sema &S, CXXRecordDecl *Class) {
9566   // Don't do anything for template patterns.
9567   if (Class->getDescribedClassTemplate())
9568     return;
9569 
9570   CallingConv ExpectedCallingConv = S.Context.getDefaultCallingConvention(
9571       /*IsVariadic=*/false, /*IsCXXMethod=*/true);
9572 
9573   CXXConstructorDecl *LastExportedDefaultCtor = nullptr;
9574   for (Decl *Member : Class->decls()) {
9575     auto *CD = dyn_cast<CXXConstructorDecl>(Member);
9576     if (!CD) {
9577       // Recurse on nested classes.
9578       if (auto *NestedRD = dyn_cast<CXXRecordDecl>(Member))
9579         getDefaultArgExprsForConstructors(S, NestedRD);
9580       continue;
9581     } else if (!CD->isDefaultConstructor() || !CD->hasAttr<DLLExportAttr>()) {
9582       continue;
9583     }
9584 
9585     CallingConv ActualCallingConv =
9586         CD->getType()->getAs<FunctionProtoType>()->getCallConv();
9587 
9588     // Skip default constructors with typical calling conventions and no default
9589     // arguments.
9590     unsigned NumParams = CD->getNumParams();
9591     if (ExpectedCallingConv == ActualCallingConv && NumParams == 0)
9592       continue;
9593 
9594     if (LastExportedDefaultCtor) {
9595       S.Diag(LastExportedDefaultCtor->getLocation(),
9596              diag::err_attribute_dll_ambiguous_default_ctor) << Class;
9597       S.Diag(CD->getLocation(), diag::note_entity_declared_at)
9598           << CD->getDeclName();
9599       return;
9600     }
9601     LastExportedDefaultCtor = CD;
9602 
9603     for (unsigned I = 0; I != NumParams; ++I) {
9604       // Skip any default arguments that we've already instantiated.
9605       if (S.Context.getDefaultArgExprForConstructor(CD, I))
9606         continue;
9607 
9608       Expr *DefaultArg = S.BuildCXXDefaultArgExpr(Class->getLocation(), CD,
9609                                                   CD->getParamDecl(I)).get();
9610       S.DiscardCleanupsInEvaluationContext();
9611       S.Context.addDefaultArgExprForConstructor(CD, I, DefaultArg);
9612     }
9613   }
9614 }
9615 
ActOnFinishCXXNonNestedClass(Decl * D)9616 void Sema::ActOnFinishCXXNonNestedClass(Decl *D) {
9617   auto *RD = dyn_cast<CXXRecordDecl>(D);
9618 
9619   // Default constructors that are annotated with __declspec(dllexport) which
9620   // have default arguments or don't use the standard calling convention are
9621   // wrapped with a thunk called the default constructor closure.
9622   if (RD && Context.getTargetInfo().getCXXABI().isMicrosoft())
9623     getDefaultArgExprsForConstructors(*this, RD);
9624 
9625   referenceDLLExportedClassMethods();
9626 }
9627 
referenceDLLExportedClassMethods()9628 void Sema::referenceDLLExportedClassMethods() {
9629   if (!DelayedDllExportClasses.empty()) {
9630     // Calling ReferenceDllExportedMethods might cause the current function to
9631     // be called again, so use a local copy of DelayedDllExportClasses.
9632     SmallVector<CXXRecordDecl *, 4> WorkList;
9633     std::swap(DelayedDllExportClasses, WorkList);
9634     for (CXXRecordDecl *Class : WorkList)
9635       ReferenceDllExportedMethods(*this, Class);
9636   }
9637 }
9638 
AdjustDestructorExceptionSpec(CXXRecordDecl * ClassDecl,CXXDestructorDecl * Destructor)9639 void Sema::AdjustDestructorExceptionSpec(CXXRecordDecl *ClassDecl,
9640                                          CXXDestructorDecl *Destructor) {
9641   assert(getLangOpts().CPlusPlus11 &&
9642          "adjusting dtor exception specs was introduced in c++11");
9643 
9644   // C++11 [class.dtor]p3:
9645   //   A declaration of a destructor that does not have an exception-
9646   //   specification is implicitly considered to have the same exception-
9647   //   specification as an implicit declaration.
9648   const FunctionProtoType *DtorType = Destructor->getType()->
9649                                         getAs<FunctionProtoType>();
9650   if (DtorType->hasExceptionSpec())
9651     return;
9652 
9653   // Replace the destructor's type, building off the existing one. Fortunately,
9654   // the only thing of interest in the destructor type is its extended info.
9655   // The return and arguments are fixed.
9656   FunctionProtoType::ExtProtoInfo EPI = DtorType->getExtProtoInfo();
9657   EPI.ExceptionSpec.Type = EST_Unevaluated;
9658   EPI.ExceptionSpec.SourceDecl = Destructor;
9659   Destructor->setType(Context.getFunctionType(Context.VoidTy, None, EPI));
9660 
9661   // FIXME: If the destructor has a body that could throw, and the newly created
9662   // spec doesn't allow exceptions, we should emit a warning, because this
9663   // change in behavior can break conforming C++03 programs at runtime.
9664   // However, we don't have a body or an exception specification yet, so it
9665   // needs to be done somewhere else.
9666 }
9667 
9668 namespace {
9669 /// \brief An abstract base class for all helper classes used in building the
9670 //  copy/move operators. These classes serve as factory functions and help us
9671 //  avoid using the same Expr* in the AST twice.
9672 class ExprBuilder {
9673   ExprBuilder(const ExprBuilder&) = delete;
9674   ExprBuilder &operator=(const ExprBuilder&) = delete;
9675 
9676 protected:
assertNotNull(Expr * E)9677   static Expr *assertNotNull(Expr *E) {
9678     assert(E && "Expression construction must not fail.");
9679     return E;
9680   }
9681 
9682 public:
ExprBuilder()9683   ExprBuilder() {}
~ExprBuilder()9684   virtual ~ExprBuilder() {}
9685 
9686   virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
9687 };
9688 
9689 class RefBuilder: public ExprBuilder {
9690   VarDecl *Var;
9691   QualType VarType;
9692 
9693 public:
build(Sema & S,SourceLocation Loc) const9694   Expr *build(Sema &S, SourceLocation Loc) const override {
9695     return assertNotNull(S.BuildDeclRefExpr(Var, VarType, VK_LValue, Loc).get());
9696   }
9697 
RefBuilder(VarDecl * Var,QualType VarType)9698   RefBuilder(VarDecl *Var, QualType VarType)
9699       : Var(Var), VarType(VarType) {}
9700 };
9701 
9702 class ThisBuilder: public ExprBuilder {
9703 public:
build(Sema & S,SourceLocation Loc) const9704   Expr *build(Sema &S, SourceLocation Loc) const override {
9705     return assertNotNull(S.ActOnCXXThis(Loc).getAs<Expr>());
9706   }
9707 };
9708 
9709 class CastBuilder: public ExprBuilder {
9710   const ExprBuilder &Builder;
9711   QualType Type;
9712   ExprValueKind Kind;
9713   const CXXCastPath &Path;
9714 
9715 public:
build(Sema & S,SourceLocation Loc) const9716   Expr *build(Sema &S, SourceLocation Loc) const override {
9717     return assertNotNull(S.ImpCastExprToType(Builder.build(S, Loc), Type,
9718                                              CK_UncheckedDerivedToBase, Kind,
9719                                              &Path).get());
9720   }
9721 
CastBuilder(const ExprBuilder & Builder,QualType Type,ExprValueKind Kind,const CXXCastPath & Path)9722   CastBuilder(const ExprBuilder &Builder, QualType Type, ExprValueKind Kind,
9723               const CXXCastPath &Path)
9724       : Builder(Builder), Type(Type), Kind(Kind), Path(Path) {}
9725 };
9726 
9727 class DerefBuilder: public ExprBuilder {
9728   const ExprBuilder &Builder;
9729 
9730 public:
build(Sema & S,SourceLocation Loc) const9731   Expr *build(Sema &S, SourceLocation Loc) const override {
9732     return assertNotNull(
9733         S.CreateBuiltinUnaryOp(Loc, UO_Deref, Builder.build(S, Loc)).get());
9734   }
9735 
DerefBuilder(const ExprBuilder & Builder)9736   DerefBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9737 };
9738 
9739 class MemberBuilder: public ExprBuilder {
9740   const ExprBuilder &Builder;
9741   QualType Type;
9742   CXXScopeSpec SS;
9743   bool IsArrow;
9744   LookupResult &MemberLookup;
9745 
9746 public:
build(Sema & S,SourceLocation Loc) const9747   Expr *build(Sema &S, SourceLocation Loc) const override {
9748     return assertNotNull(S.BuildMemberReferenceExpr(
9749         Builder.build(S, Loc), Type, Loc, IsArrow, SS, SourceLocation(),
9750         nullptr, MemberLookup, nullptr, nullptr).get());
9751   }
9752 
MemberBuilder(const ExprBuilder & Builder,QualType Type,bool IsArrow,LookupResult & MemberLookup)9753   MemberBuilder(const ExprBuilder &Builder, QualType Type, bool IsArrow,
9754                 LookupResult &MemberLookup)
9755       : Builder(Builder), Type(Type), IsArrow(IsArrow),
9756         MemberLookup(MemberLookup) {}
9757 };
9758 
9759 class MoveCastBuilder: public ExprBuilder {
9760   const ExprBuilder &Builder;
9761 
9762 public:
build(Sema & S,SourceLocation Loc) const9763   Expr *build(Sema &S, SourceLocation Loc) const override {
9764     return assertNotNull(CastForMoving(S, Builder.build(S, Loc)));
9765   }
9766 
MoveCastBuilder(const ExprBuilder & Builder)9767   MoveCastBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9768 };
9769 
9770 class LvalueConvBuilder: public ExprBuilder {
9771   const ExprBuilder &Builder;
9772 
9773 public:
build(Sema & S,SourceLocation Loc) const9774   Expr *build(Sema &S, SourceLocation Loc) const override {
9775     return assertNotNull(
9776         S.DefaultLvalueConversion(Builder.build(S, Loc)).get());
9777   }
9778 
LvalueConvBuilder(const ExprBuilder & Builder)9779   LvalueConvBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9780 };
9781 
9782 class SubscriptBuilder: public ExprBuilder {
9783   const ExprBuilder &Base;
9784   const ExprBuilder &Index;
9785 
9786 public:
build(Sema & S,SourceLocation Loc) const9787   Expr *build(Sema &S, SourceLocation Loc) const override {
9788     return assertNotNull(S.CreateBuiltinArraySubscriptExpr(
9789         Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).get());
9790   }
9791 
SubscriptBuilder(const ExprBuilder & Base,const ExprBuilder & Index)9792   SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index)
9793       : Base(Base), Index(Index) {}
9794 };
9795 
9796 } // end anonymous namespace
9797 
9798 /// When generating a defaulted copy or move assignment operator, if a field
9799 /// should be copied with __builtin_memcpy rather than via explicit assignments,
9800 /// do so. This optimization only applies for arrays of scalars, and for arrays
9801 /// of class type where the selected copy/move-assignment operator is trivial.
9802 static StmtResult
buildMemcpyForAssignmentOp(Sema & S,SourceLocation Loc,QualType T,const ExprBuilder & ToB,const ExprBuilder & FromB)9803 buildMemcpyForAssignmentOp(Sema &S, SourceLocation Loc, QualType T,
9804                            const ExprBuilder &ToB, const ExprBuilder &FromB) {
9805   // Compute the size of the memory buffer to be copied.
9806   QualType SizeType = S.Context.getSizeType();
9807   llvm::APInt Size(S.Context.getTypeSize(SizeType),
9808                    S.Context.getTypeSizeInChars(T).getQuantity());
9809 
9810   // Take the address of the field references for "from" and "to". We
9811   // directly construct UnaryOperators here because semantic analysis
9812   // does not permit us to take the address of an xvalue.
9813   Expr *From = FromB.build(S, Loc);
9814   From = new (S.Context) UnaryOperator(From, UO_AddrOf,
9815                          S.Context.getPointerType(From->getType()),
9816                          VK_RValue, OK_Ordinary, Loc);
9817   Expr *To = ToB.build(S, Loc);
9818   To = new (S.Context) UnaryOperator(To, UO_AddrOf,
9819                        S.Context.getPointerType(To->getType()),
9820                        VK_RValue, OK_Ordinary, Loc);
9821 
9822   const Type *E = T->getBaseElementTypeUnsafe();
9823   bool NeedsCollectableMemCpy =
9824     E->isRecordType() && E->getAs<RecordType>()->getDecl()->hasObjectMember();
9825 
9826   // Create a reference to the __builtin_objc_memmove_collectable function
9827   StringRef MemCpyName = NeedsCollectableMemCpy ?
9828     "__builtin_objc_memmove_collectable" :
9829     "__builtin_memcpy";
9830   LookupResult R(S, &S.Context.Idents.get(MemCpyName), Loc,
9831                  Sema::LookupOrdinaryName);
9832   S.LookupName(R, S.TUScope, true);
9833 
9834   FunctionDecl *MemCpy = R.getAsSingle<FunctionDecl>();
9835   if (!MemCpy)
9836     // Something went horribly wrong earlier, and we will have complained
9837     // about it.
9838     return StmtError();
9839 
9840   ExprResult MemCpyRef = S.BuildDeclRefExpr(MemCpy, S.Context.BuiltinFnTy,
9841                                             VK_RValue, Loc, nullptr);
9842   assert(MemCpyRef.isUsable() && "Builtin reference cannot fail");
9843 
9844   Expr *CallArgs[] = {
9845     To, From, IntegerLiteral::Create(S.Context, Size, SizeType, Loc)
9846   };
9847   ExprResult Call = S.ActOnCallExpr(/*Scope=*/nullptr, MemCpyRef.get(),
9848                                     Loc, CallArgs, Loc);
9849 
9850   assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!");
9851   return Call.getAs<Stmt>();
9852 }
9853 
9854 /// \brief Builds a statement that copies/moves the given entity from \p From to
9855 /// \c To.
9856 ///
9857 /// This routine is used to copy/move the members of a class with an
9858 /// implicitly-declared copy/move assignment operator. When the entities being
9859 /// copied are arrays, this routine builds for loops to copy them.
9860 ///
9861 /// \param S The Sema object used for type-checking.
9862 ///
9863 /// \param Loc The location where the implicit copy/move is being generated.
9864 ///
9865 /// \param T The type of the expressions being copied/moved. Both expressions
9866 /// must have this type.
9867 ///
9868 /// \param To The expression we are copying/moving to.
9869 ///
9870 /// \param From The expression we are copying/moving from.
9871 ///
9872 /// \param CopyingBaseSubobject Whether we're copying/moving a base subobject.
9873 /// Otherwise, it's a non-static member subobject.
9874 ///
9875 /// \param Copying Whether we're copying or moving.
9876 ///
9877 /// \param Depth Internal parameter recording the depth of the recursion.
9878 ///
9879 /// \returns A statement or a loop that copies the expressions, or StmtResult(0)
9880 /// if a memcpy should be used instead.
9881 static StmtResult
buildSingleCopyAssignRecursively(Sema & S,SourceLocation Loc,QualType T,const ExprBuilder & To,const ExprBuilder & From,bool CopyingBaseSubobject,bool Copying,unsigned Depth=0)9882 buildSingleCopyAssignRecursively(Sema &S, SourceLocation Loc, QualType T,
9883                                  const ExprBuilder &To, const ExprBuilder &From,
9884                                  bool CopyingBaseSubobject, bool Copying,
9885                                  unsigned Depth = 0) {
9886   // C++11 [class.copy]p28:
9887   //   Each subobject is assigned in the manner appropriate to its type:
9888   //
9889   //     - if the subobject is of class type, as if by a call to operator= with
9890   //       the subobject as the object expression and the corresponding
9891   //       subobject of x as a single function argument (as if by explicit
9892   //       qualification; that is, ignoring any possible virtual overriding
9893   //       functions in more derived classes);
9894   //
9895   // C++03 [class.copy]p13:
9896   //     - if the subobject is of class type, the copy assignment operator for
9897   //       the class is used (as if by explicit qualification; that is,
9898   //       ignoring any possible virtual overriding functions in more derived
9899   //       classes);
9900   if (const RecordType *RecordTy = T->getAs<RecordType>()) {
9901     CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
9902 
9903     // Look for operator=.
9904     DeclarationName Name
9905       = S.Context.DeclarationNames.getCXXOperatorName(OO_Equal);
9906     LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName);
9907     S.LookupQualifiedName(OpLookup, ClassDecl, false);
9908 
9909     // Prior to C++11, filter out any result that isn't a copy/move-assignment
9910     // operator.
9911     if (!S.getLangOpts().CPlusPlus11) {
9912       LookupResult::Filter F = OpLookup.makeFilter();
9913       while (F.hasNext()) {
9914         NamedDecl *D = F.next();
9915         if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
9916           if (Method->isCopyAssignmentOperator() ||
9917               (!Copying && Method->isMoveAssignmentOperator()))
9918             continue;
9919 
9920         F.erase();
9921       }
9922       F.done();
9923     }
9924 
9925     // Suppress the protected check (C++ [class.protected]) for each of the
9926     // assignment operators we found. This strange dance is required when
9927     // we're assigning via a base classes's copy-assignment operator. To
9928     // ensure that we're getting the right base class subobject (without
9929     // ambiguities), we need to cast "this" to that subobject type; to
9930     // ensure that we don't go through the virtual call mechanism, we need
9931     // to qualify the operator= name with the base class (see below). However,
9932     // this means that if the base class has a protected copy assignment
9933     // operator, the protected member access check will fail. So, we
9934     // rewrite "protected" access to "public" access in this case, since we
9935     // know by construction that we're calling from a derived class.
9936     if (CopyingBaseSubobject) {
9937       for (LookupResult::iterator L = OpLookup.begin(), LEnd = OpLookup.end();
9938            L != LEnd; ++L) {
9939         if (L.getAccess() == AS_protected)
9940           L.setAccess(AS_public);
9941       }
9942     }
9943 
9944     // Create the nested-name-specifier that will be used to qualify the
9945     // reference to operator=; this is required to suppress the virtual
9946     // call mechanism.
9947     CXXScopeSpec SS;
9948     const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
9949     SS.MakeTrivial(S.Context,
9950                    NestedNameSpecifier::Create(S.Context, nullptr, false,
9951                                                CanonicalT),
9952                    Loc);
9953 
9954     // Create the reference to operator=.
9955     ExprResult OpEqualRef
9956       = S.BuildMemberReferenceExpr(To.build(S, Loc), T, Loc, /*isArrow=*/false,
9957                                    SS, /*TemplateKWLoc=*/SourceLocation(),
9958                                    /*FirstQualifierInScope=*/nullptr,
9959                                    OpLookup,
9960                                    /*TemplateArgs=*/nullptr, /*S*/nullptr,
9961                                    /*SuppressQualifierCheck=*/true);
9962     if (OpEqualRef.isInvalid())
9963       return StmtError();
9964 
9965     // Build the call to the assignment operator.
9966 
9967     Expr *FromInst = From.build(S, Loc);
9968     ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/nullptr,
9969                                                   OpEqualRef.getAs<Expr>(),
9970                                                   Loc, FromInst, Loc);
9971     if (Call.isInvalid())
9972       return StmtError();
9973 
9974     // If we built a call to a trivial 'operator=' while copying an array,
9975     // bail out. We'll replace the whole shebang with a memcpy.
9976     CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(Call.get());
9977     if (CE && CE->getMethodDecl()->isTrivial() && Depth)
9978       return StmtResult((Stmt*)nullptr);
9979 
9980     // Convert to an expression-statement, and clean up any produced
9981     // temporaries.
9982     return S.ActOnExprStmt(Call);
9983   }
9984 
9985   //     - if the subobject is of scalar type, the built-in assignment
9986   //       operator is used.
9987   const ConstantArrayType *ArrayTy = S.Context.getAsConstantArrayType(T);
9988   if (!ArrayTy) {
9989     ExprResult Assignment = S.CreateBuiltinBinOp(
9990         Loc, BO_Assign, To.build(S, Loc), From.build(S, Loc));
9991     if (Assignment.isInvalid())
9992       return StmtError();
9993     return S.ActOnExprStmt(Assignment);
9994   }
9995 
9996   //     - if the subobject is an array, each element is assigned, in the
9997   //       manner appropriate to the element type;
9998 
9999   // Construct a loop over the array bounds, e.g.,
10000   //
10001   //   for (__SIZE_TYPE__ i0 = 0; i0 != array-size; ++i0)
10002   //
10003   // that will copy each of the array elements.
10004   QualType SizeType = S.Context.getSizeType();
10005 
10006   // Create the iteration variable.
10007   IdentifierInfo *IterationVarName = nullptr;
10008   {
10009     SmallString<8> Str;
10010     llvm::raw_svector_ostream OS(Str);
10011     OS << "__i" << Depth;
10012     IterationVarName = &S.Context.Idents.get(OS.str());
10013   }
10014   VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
10015                                           IterationVarName, SizeType,
10016                             S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
10017                                           SC_None);
10018 
10019   // Initialize the iteration variable to zero.
10020   llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
10021   IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
10022 
10023   // Creates a reference to the iteration variable.
10024   RefBuilder IterationVarRef(IterationVar, SizeType);
10025   LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
10026 
10027   // Create the DeclStmt that holds the iteration variable.
10028   Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);
10029 
10030   // Subscript the "from" and "to" expressions with the iteration variable.
10031   SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
10032   MoveCastBuilder FromIndexMove(FromIndexCopy);
10033   const ExprBuilder *FromIndex;
10034   if (Copying)
10035     FromIndex = &FromIndexCopy;
10036   else
10037     FromIndex = &FromIndexMove;
10038 
10039   SubscriptBuilder ToIndex(To, IterationVarRefRVal);
10040 
10041   // Build the copy/move for an individual element of the array.
10042   StmtResult Copy =
10043     buildSingleCopyAssignRecursively(S, Loc, ArrayTy->getElementType(),
10044                                      ToIndex, *FromIndex, CopyingBaseSubobject,
10045                                      Copying, Depth + 1);
10046   // Bail out if copying fails or if we determined that we should use memcpy.
10047   if (Copy.isInvalid() || !Copy.get())
10048     return Copy;
10049 
10050   // Create the comparison against the array bound.
10051   llvm::APInt Upper
10052     = ArrayTy->getSize().zextOrTrunc(S.Context.getTypeSize(SizeType));
10053   Expr *Comparison
10054     = new (S.Context) BinaryOperator(IterationVarRefRVal.build(S, Loc),
10055                      IntegerLiteral::Create(S.Context, Upper, SizeType, Loc),
10056                                      BO_NE, S.Context.BoolTy,
10057                                      VK_RValue, OK_Ordinary, Loc, false);
10058 
10059   // Create the pre-increment of the iteration variable.
10060   Expr *Increment
10061     = new (S.Context) UnaryOperator(IterationVarRef.build(S, Loc), UO_PreInc,
10062                                     SizeType, VK_LValue, OK_Ordinary, Loc);
10063 
10064   // Construct the loop that copies all elements of this array.
10065   return S.ActOnForStmt(
10066       Loc, Loc, InitStmt,
10067       S.ActOnCondition(nullptr, Loc, Comparison, Sema::ConditionKind::Boolean),
10068       S.MakeFullDiscardedValueExpr(Increment), Loc, Copy.get());
10069 }
10070 
10071 static StmtResult
buildSingleCopyAssign(Sema & S,SourceLocation Loc,QualType T,const ExprBuilder & To,const ExprBuilder & From,bool CopyingBaseSubobject,bool Copying)10072 buildSingleCopyAssign(Sema &S, SourceLocation Loc, QualType T,
10073                       const ExprBuilder &To, const ExprBuilder &From,
10074                       bool CopyingBaseSubobject, bool Copying) {
10075   // Maybe we should use a memcpy?
10076   if (T->isArrayType() && !T.isConstQualified() && !T.isVolatileQualified() &&
10077       T.isTriviallyCopyableType(S.Context))
10078     return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
10079 
10080   StmtResult Result(buildSingleCopyAssignRecursively(S, Loc, T, To, From,
10081                                                      CopyingBaseSubobject,
10082                                                      Copying, 0));
10083 
10084   // If we ended up picking a trivial assignment operator for an array of a
10085   // non-trivially-copyable class type, just emit a memcpy.
10086   if (!Result.isInvalid() && !Result.get())
10087     return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
10088 
10089   return Result;
10090 }
10091 
10092 Sema::ImplicitExceptionSpecification
ComputeDefaultedCopyAssignmentExceptionSpec(CXXMethodDecl * MD)10093 Sema::ComputeDefaultedCopyAssignmentExceptionSpec(CXXMethodDecl *MD) {
10094   CXXRecordDecl *ClassDecl = MD->getParent();
10095 
10096   ImplicitExceptionSpecification ExceptSpec(*this);
10097   if (ClassDecl->isInvalidDecl())
10098     return ExceptSpec;
10099 
10100   const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
10101   assert(T->getNumParams() == 1 && "not a copy assignment op");
10102   unsigned ArgQuals =
10103       T->getParamType(0).getNonReferenceType().getCVRQualifiers();
10104 
10105   // C++ [except.spec]p14:
10106   //   An implicitly declared special member function (Clause 12) shall have an
10107   //   exception-specification. [...]
10108 
10109   // It is unspecified whether or not an implicit copy assignment operator
10110   // attempts to deduplicate calls to assignment operators of virtual bases are
10111   // made. As such, this exception specification is effectively unspecified.
10112   // Based on a similar decision made for constness in C++0x, we're erring on
10113   // the side of assuming such calls to be made regardless of whether they
10114   // actually happen.
10115   for (const auto &Base : ClassDecl->bases()) {
10116     if (Base.isVirtual())
10117       continue;
10118 
10119     CXXRecordDecl *BaseClassDecl
10120       = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
10121     if (CXXMethodDecl *CopyAssign = LookupCopyingAssignment(BaseClassDecl,
10122                                                             ArgQuals, false, 0))
10123       ExceptSpec.CalledDecl(Base.getLocStart(), CopyAssign);
10124   }
10125 
10126   for (const auto &Base : ClassDecl->vbases()) {
10127     CXXRecordDecl *BaseClassDecl
10128       = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
10129     if (CXXMethodDecl *CopyAssign = LookupCopyingAssignment(BaseClassDecl,
10130                                                             ArgQuals, false, 0))
10131       ExceptSpec.CalledDecl(Base.getLocStart(), CopyAssign);
10132   }
10133 
10134   for (const auto *Field : ClassDecl->fields()) {
10135     QualType FieldType = Context.getBaseElementType(Field->getType());
10136     if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
10137       if (CXXMethodDecl *CopyAssign =
10138           LookupCopyingAssignment(FieldClassDecl,
10139                                   ArgQuals | FieldType.getCVRQualifiers(),
10140                                   false, 0))
10141         ExceptSpec.CalledDecl(Field->getLocation(), CopyAssign);
10142     }
10143   }
10144 
10145   return ExceptSpec;
10146 }
10147 
DeclareImplicitCopyAssignment(CXXRecordDecl * ClassDecl)10148 CXXMethodDecl *Sema::DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl) {
10149   // Note: The following rules are largely analoguous to the copy
10150   // constructor rules. Note that virtual bases are not taken into account
10151   // for determining the argument type of the operator. Note also that
10152   // operators taking an object instead of a reference are allowed.
10153   assert(ClassDecl->needsImplicitCopyAssignment());
10154 
10155   DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyAssignment);
10156   if (DSM.isAlreadyBeingDeclared())
10157     return nullptr;
10158 
10159   QualType ArgType = Context.getTypeDeclType(ClassDecl);
10160   QualType RetType = Context.getLValueReferenceType(ArgType);
10161   bool Const = ClassDecl->implicitCopyAssignmentHasConstParam();
10162   if (Const)
10163     ArgType = ArgType.withConst();
10164   ArgType = Context.getLValueReferenceType(ArgType);
10165 
10166   bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
10167                                                      CXXCopyAssignment,
10168                                                      Const);
10169 
10170   //   An implicitly-declared copy assignment operator is an inline public
10171   //   member of its class.
10172   DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
10173   SourceLocation ClassLoc = ClassDecl->getLocation();
10174   DeclarationNameInfo NameInfo(Name, ClassLoc);
10175   CXXMethodDecl *CopyAssignment =
10176       CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
10177                             /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
10178                             /*isInline=*/true, Constexpr, SourceLocation());
10179   CopyAssignment->setAccess(AS_public);
10180   CopyAssignment->setDefaulted();
10181   CopyAssignment->setImplicit();
10182 
10183   if (getLangOpts().CUDA) {
10184     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyAssignment,
10185                                             CopyAssignment,
10186                                             /* ConstRHS */ Const,
10187                                             /* Diagnose */ false);
10188   }
10189 
10190   // Build an exception specification pointing back at this member.
10191   FunctionProtoType::ExtProtoInfo EPI =
10192       getImplicitMethodEPI(*this, CopyAssignment);
10193   CopyAssignment->setType(Context.getFunctionType(RetType, ArgType, EPI));
10194 
10195   // Add the parameter to the operator.
10196   ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
10197                                                ClassLoc, ClassLoc,
10198                                                /*Id=*/nullptr, ArgType,
10199                                                /*TInfo=*/nullptr, SC_None,
10200                                                nullptr);
10201   CopyAssignment->setParams(FromParam);
10202 
10203   CopyAssignment->setTrivial(
10204     ClassDecl->needsOverloadResolutionForCopyAssignment()
10205       ? SpecialMemberIsTrivial(CopyAssignment, CXXCopyAssignment)
10206       : ClassDecl->hasTrivialCopyAssignment());
10207 
10208   // Note that we have added this copy-assignment operator.
10209   ++ASTContext::NumImplicitCopyAssignmentOperatorsDeclared;
10210 
10211   Scope *S = getScopeForContext(ClassDecl);
10212   CheckImplicitSpecialMemberDeclaration(S, CopyAssignment);
10213 
10214   if (ShouldDeleteSpecialMember(CopyAssignment, CXXCopyAssignment))
10215     SetDeclDeleted(CopyAssignment, ClassLoc);
10216 
10217   if (S)
10218     PushOnScopeChains(CopyAssignment, S, false);
10219   ClassDecl->addDecl(CopyAssignment);
10220 
10221   return CopyAssignment;
10222 }
10223 
10224 /// Diagnose an implicit copy operation for a class which is odr-used, but
10225 /// which is deprecated because the class has a user-declared copy constructor,
10226 /// copy assignment operator, or destructor.
diagnoseDeprecatedCopyOperation(Sema & S,CXXMethodDecl * CopyOp,SourceLocation UseLoc)10227 static void diagnoseDeprecatedCopyOperation(Sema &S, CXXMethodDecl *CopyOp,
10228                                             SourceLocation UseLoc) {
10229   assert(CopyOp->isImplicit());
10230 
10231   CXXRecordDecl *RD = CopyOp->getParent();
10232   CXXMethodDecl *UserDeclaredOperation = nullptr;
10233 
10234   // In Microsoft mode, assignment operations don't affect constructors and
10235   // vice versa.
10236   if (RD->hasUserDeclaredDestructor()) {
10237     UserDeclaredOperation = RD->getDestructor();
10238   } else if (!isa<CXXConstructorDecl>(CopyOp) &&
10239              RD->hasUserDeclaredCopyConstructor() &&
10240              !S.getLangOpts().MSVCCompat) {
10241     // Find any user-declared copy constructor.
10242     for (auto *I : RD->ctors()) {
10243       if (I->isCopyConstructor()) {
10244         UserDeclaredOperation = I;
10245         break;
10246       }
10247     }
10248     assert(UserDeclaredOperation);
10249   } else if (isa<CXXConstructorDecl>(CopyOp) &&
10250              RD->hasUserDeclaredCopyAssignment() &&
10251              !S.getLangOpts().MSVCCompat) {
10252     // Find any user-declared move assignment operator.
10253     for (auto *I : RD->methods()) {
10254       if (I->isCopyAssignmentOperator()) {
10255         UserDeclaredOperation = I;
10256         break;
10257       }
10258     }
10259     assert(UserDeclaredOperation);
10260   }
10261 
10262   if (UserDeclaredOperation) {
10263     S.Diag(UserDeclaredOperation->getLocation(),
10264          diag::warn_deprecated_copy_operation)
10265       << RD << /*copy assignment*/!isa<CXXConstructorDecl>(CopyOp)
10266       << /*destructor*/isa<CXXDestructorDecl>(UserDeclaredOperation);
10267     S.Diag(UseLoc, diag::note_member_synthesized_at)
10268       << (isa<CXXConstructorDecl>(CopyOp) ? Sema::CXXCopyConstructor
10269                                           : Sema::CXXCopyAssignment)
10270       << RD;
10271   }
10272 }
10273 
DefineImplicitCopyAssignment(SourceLocation CurrentLocation,CXXMethodDecl * CopyAssignOperator)10274 void Sema::DefineImplicitCopyAssignment(SourceLocation CurrentLocation,
10275                                         CXXMethodDecl *CopyAssignOperator) {
10276   assert((CopyAssignOperator->isDefaulted() &&
10277           CopyAssignOperator->isOverloadedOperator() &&
10278           CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
10279           !CopyAssignOperator->doesThisDeclarationHaveABody() &&
10280           !CopyAssignOperator->isDeleted()) &&
10281          "DefineImplicitCopyAssignment called for wrong function");
10282 
10283   CXXRecordDecl *ClassDecl = CopyAssignOperator->getParent();
10284 
10285   if (ClassDecl->isInvalidDecl() || CopyAssignOperator->isInvalidDecl()) {
10286     CopyAssignOperator->setInvalidDecl();
10287     return;
10288   }
10289 
10290   // C++11 [class.copy]p18:
10291   //   The [definition of an implicitly declared copy assignment operator] is
10292   //   deprecated if the class has a user-declared copy constructor or a
10293   //   user-declared destructor.
10294   if (getLangOpts().CPlusPlus11 && CopyAssignOperator->isImplicit())
10295     diagnoseDeprecatedCopyOperation(*this, CopyAssignOperator, CurrentLocation);
10296 
10297   CopyAssignOperator->markUsed(Context);
10298 
10299   SynthesizedFunctionScope Scope(*this, CopyAssignOperator);
10300   DiagnosticErrorTrap Trap(Diags);
10301 
10302   // C++0x [class.copy]p30:
10303   //   The implicitly-defined or explicitly-defaulted copy assignment operator
10304   //   for a non-union class X performs memberwise copy assignment of its
10305   //   subobjects. The direct base classes of X are assigned first, in the
10306   //   order of their declaration in the base-specifier-list, and then the
10307   //   immediate non-static data members of X are assigned, in the order in
10308   //   which they were declared in the class definition.
10309 
10310   // The statements that form the synthesized function body.
10311   SmallVector<Stmt*, 8> Statements;
10312 
10313   // The parameter for the "other" object, which we are copying from.
10314   ParmVarDecl *Other = CopyAssignOperator->getParamDecl(0);
10315   Qualifiers OtherQuals = Other->getType().getQualifiers();
10316   QualType OtherRefType = Other->getType();
10317   if (const LValueReferenceType *OtherRef
10318                                 = OtherRefType->getAs<LValueReferenceType>()) {
10319     OtherRefType = OtherRef->getPointeeType();
10320     OtherQuals = OtherRefType.getQualifiers();
10321   }
10322 
10323   // Our location for everything implicitly-generated.
10324   SourceLocation Loc = CopyAssignOperator->getLocEnd().isValid()
10325                            ? CopyAssignOperator->getLocEnd()
10326                            : CopyAssignOperator->getLocation();
10327 
10328   // Builds a DeclRefExpr for the "other" object.
10329   RefBuilder OtherRef(Other, OtherRefType);
10330 
10331   // Builds the "this" pointer.
10332   ThisBuilder This;
10333 
10334   // Assign base classes.
10335   bool Invalid = false;
10336   for (auto &Base : ClassDecl->bases()) {
10337     // Form the assignment:
10338     //   static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other));
10339     QualType BaseType = Base.getType().getUnqualifiedType();
10340     if (!BaseType->isRecordType()) {
10341       Invalid = true;
10342       continue;
10343     }
10344 
10345     CXXCastPath BasePath;
10346     BasePath.push_back(&Base);
10347 
10348     // Construct the "from" expression, which is an implicit cast to the
10349     // appropriately-qualified base type.
10350     CastBuilder From(OtherRef, Context.getQualifiedType(BaseType, OtherQuals),
10351                      VK_LValue, BasePath);
10352 
10353     // Dereference "this".
10354     DerefBuilder DerefThis(This);
10355     CastBuilder To(DerefThis,
10356                    Context.getCVRQualifiedType(
10357                        BaseType, CopyAssignOperator->getTypeQualifiers()),
10358                    VK_LValue, BasePath);
10359 
10360     // Build the copy.
10361     StmtResult Copy = buildSingleCopyAssign(*this, Loc, BaseType,
10362                                             To, From,
10363                                             /*CopyingBaseSubobject=*/true,
10364                                             /*Copying=*/true);
10365     if (Copy.isInvalid()) {
10366       Diag(CurrentLocation, diag::note_member_synthesized_at)
10367         << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
10368       CopyAssignOperator->setInvalidDecl();
10369       return;
10370     }
10371 
10372     // Success! Record the copy.
10373     Statements.push_back(Copy.getAs<Expr>());
10374   }
10375 
10376   // Assign non-static members.
10377   for (auto *Field : ClassDecl->fields()) {
10378     // FIXME: We should form some kind of AST representation for the implied
10379     // memcpy in a union copy operation.
10380     if (Field->isUnnamedBitfield() || Field->getParent()->isUnion())
10381       continue;
10382 
10383     if (Field->isInvalidDecl()) {
10384       Invalid = true;
10385       continue;
10386     }
10387 
10388     // Check for members of reference type; we can't copy those.
10389     if (Field->getType()->isReferenceType()) {
10390       Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
10391         << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
10392       Diag(Field->getLocation(), diag::note_declared_at);
10393       Diag(CurrentLocation, diag::note_member_synthesized_at)
10394         << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
10395       Invalid = true;
10396       continue;
10397     }
10398 
10399     // Check for members of const-qualified, non-class type.
10400     QualType BaseType = Context.getBaseElementType(Field->getType());
10401     if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
10402       Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
10403         << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
10404       Diag(Field->getLocation(), diag::note_declared_at);
10405       Diag(CurrentLocation, diag::note_member_synthesized_at)
10406         << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
10407       Invalid = true;
10408       continue;
10409     }
10410 
10411     // Suppress assigning zero-width bitfields.
10412     if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
10413       continue;
10414 
10415     QualType FieldType = Field->getType().getNonReferenceType();
10416     if (FieldType->isIncompleteArrayType()) {
10417       assert(ClassDecl->hasFlexibleArrayMember() &&
10418              "Incomplete array type is not valid");
10419       continue;
10420     }
10421 
10422     // Build references to the field in the object we're copying from and to.
10423     CXXScopeSpec SS; // Intentionally empty
10424     LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
10425                               LookupMemberName);
10426     MemberLookup.addDecl(Field);
10427     MemberLookup.resolveKind();
10428 
10429     MemberBuilder From(OtherRef, OtherRefType, /*IsArrow=*/false, MemberLookup);
10430 
10431     MemberBuilder To(This, getCurrentThisType(), /*IsArrow=*/true, MemberLookup);
10432 
10433     // Build the copy of this field.
10434     StmtResult Copy = buildSingleCopyAssign(*this, Loc, FieldType,
10435                                             To, From,
10436                                             /*CopyingBaseSubobject=*/false,
10437                                             /*Copying=*/true);
10438     if (Copy.isInvalid()) {
10439       Diag(CurrentLocation, diag::note_member_synthesized_at)
10440         << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
10441       CopyAssignOperator->setInvalidDecl();
10442       return;
10443     }
10444 
10445     // Success! Record the copy.
10446     Statements.push_back(Copy.getAs<Stmt>());
10447   }
10448 
10449   if (!Invalid) {
10450     // Add a "return *this;"
10451     ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
10452 
10453     StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
10454     if (Return.isInvalid())
10455       Invalid = true;
10456     else {
10457       Statements.push_back(Return.getAs<Stmt>());
10458 
10459       if (Trap.hasErrorOccurred()) {
10460         Diag(CurrentLocation, diag::note_member_synthesized_at)
10461           << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
10462         Invalid = true;
10463       }
10464     }
10465   }
10466 
10467   // The exception specification is needed because we are defining the
10468   // function.
10469   ResolveExceptionSpec(CurrentLocation,
10470                        CopyAssignOperator->getType()->castAs<FunctionProtoType>());
10471 
10472   if (Invalid) {
10473     CopyAssignOperator->setInvalidDecl();
10474     return;
10475   }
10476 
10477   StmtResult Body;
10478   {
10479     CompoundScopeRAII CompoundScope(*this);
10480     Body = ActOnCompoundStmt(Loc, Loc, Statements,
10481                              /*isStmtExpr=*/false);
10482     assert(!Body.isInvalid() && "Compound statement creation cannot fail");
10483   }
10484   CopyAssignOperator->setBody(Body.getAs<Stmt>());
10485 
10486   if (ASTMutationListener *L = getASTMutationListener()) {
10487     L->CompletedImplicitDefinition(CopyAssignOperator);
10488   }
10489 }
10490 
10491 Sema::ImplicitExceptionSpecification
ComputeDefaultedMoveAssignmentExceptionSpec(CXXMethodDecl * MD)10492 Sema::ComputeDefaultedMoveAssignmentExceptionSpec(CXXMethodDecl *MD) {
10493   CXXRecordDecl *ClassDecl = MD->getParent();
10494 
10495   ImplicitExceptionSpecification ExceptSpec(*this);
10496   if (ClassDecl->isInvalidDecl())
10497     return ExceptSpec;
10498 
10499   // C++0x [except.spec]p14:
10500   //   An implicitly declared special member function (Clause 12) shall have an
10501   //   exception-specification. [...]
10502 
10503   // It is unspecified whether or not an implicit move assignment operator
10504   // attempts to deduplicate calls to assignment operators of virtual bases are
10505   // made. As such, this exception specification is effectively unspecified.
10506   // Based on a similar decision made for constness in C++0x, we're erring on
10507   // the side of assuming such calls to be made regardless of whether they
10508   // actually happen.
10509   // Note that a move constructor is not implicitly declared when there are
10510   // virtual bases, but it can still be user-declared and explicitly defaulted.
10511   for (const auto &Base : ClassDecl->bases()) {
10512     if (Base.isVirtual())
10513       continue;
10514 
10515     CXXRecordDecl *BaseClassDecl
10516       = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
10517     if (CXXMethodDecl *MoveAssign = LookupMovingAssignment(BaseClassDecl,
10518                                                            0, false, 0))
10519       ExceptSpec.CalledDecl(Base.getLocStart(), MoveAssign);
10520   }
10521 
10522   for (const auto &Base : ClassDecl->vbases()) {
10523     CXXRecordDecl *BaseClassDecl
10524       = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
10525     if (CXXMethodDecl *MoveAssign = LookupMovingAssignment(BaseClassDecl,
10526                                                            0, false, 0))
10527       ExceptSpec.CalledDecl(Base.getLocStart(), MoveAssign);
10528   }
10529 
10530   for (const auto *Field : ClassDecl->fields()) {
10531     QualType FieldType = Context.getBaseElementType(Field->getType());
10532     if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
10533       if (CXXMethodDecl *MoveAssign =
10534               LookupMovingAssignment(FieldClassDecl,
10535                                      FieldType.getCVRQualifiers(),
10536                                      false, 0))
10537         ExceptSpec.CalledDecl(Field->getLocation(), MoveAssign);
10538     }
10539   }
10540 
10541   return ExceptSpec;
10542 }
10543 
DeclareImplicitMoveAssignment(CXXRecordDecl * ClassDecl)10544 CXXMethodDecl *Sema::DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl) {
10545   assert(ClassDecl->needsImplicitMoveAssignment());
10546 
10547   DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveAssignment);
10548   if (DSM.isAlreadyBeingDeclared())
10549     return nullptr;
10550 
10551   // Note: The following rules are largely analoguous to the move
10552   // constructor rules.
10553 
10554   QualType ArgType = Context.getTypeDeclType(ClassDecl);
10555   QualType RetType = Context.getLValueReferenceType(ArgType);
10556   ArgType = Context.getRValueReferenceType(ArgType);
10557 
10558   bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
10559                                                      CXXMoveAssignment,
10560                                                      false);
10561 
10562   //   An implicitly-declared move assignment operator is an inline public
10563   //   member of its class.
10564   DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
10565   SourceLocation ClassLoc = ClassDecl->getLocation();
10566   DeclarationNameInfo NameInfo(Name, ClassLoc);
10567   CXXMethodDecl *MoveAssignment =
10568       CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
10569                             /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
10570                             /*isInline=*/true, Constexpr, SourceLocation());
10571   MoveAssignment->setAccess(AS_public);
10572   MoveAssignment->setDefaulted();
10573   MoveAssignment->setImplicit();
10574 
10575   if (getLangOpts().CUDA) {
10576     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveAssignment,
10577                                             MoveAssignment,
10578                                             /* ConstRHS */ false,
10579                                             /* Diagnose */ false);
10580   }
10581 
10582   // Build an exception specification pointing back at this member.
10583   FunctionProtoType::ExtProtoInfo EPI =
10584       getImplicitMethodEPI(*this, MoveAssignment);
10585   MoveAssignment->setType(Context.getFunctionType(RetType, ArgType, EPI));
10586 
10587   // Add the parameter to the operator.
10588   ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveAssignment,
10589                                                ClassLoc, ClassLoc,
10590                                                /*Id=*/nullptr, ArgType,
10591                                                /*TInfo=*/nullptr, SC_None,
10592                                                nullptr);
10593   MoveAssignment->setParams(FromParam);
10594 
10595   MoveAssignment->setTrivial(
10596     ClassDecl->needsOverloadResolutionForMoveAssignment()
10597       ? SpecialMemberIsTrivial(MoveAssignment, CXXMoveAssignment)
10598       : ClassDecl->hasTrivialMoveAssignment());
10599 
10600   // Note that we have added this copy-assignment operator.
10601   ++ASTContext::NumImplicitMoveAssignmentOperatorsDeclared;
10602 
10603   Scope *S = getScopeForContext(ClassDecl);
10604   CheckImplicitSpecialMemberDeclaration(S, MoveAssignment);
10605 
10606   if (ShouldDeleteSpecialMember(MoveAssignment, CXXMoveAssignment)) {
10607     ClassDecl->setImplicitMoveAssignmentIsDeleted();
10608     SetDeclDeleted(MoveAssignment, ClassLoc);
10609   }
10610 
10611   if (S)
10612     PushOnScopeChains(MoveAssignment, S, false);
10613   ClassDecl->addDecl(MoveAssignment);
10614 
10615   return MoveAssignment;
10616 }
10617 
10618 /// Check if we're implicitly defining a move assignment operator for a class
10619 /// with virtual bases. Such a move assignment might move-assign the virtual
10620 /// base multiple times.
checkMoveAssignmentForRepeatedMove(Sema & S,CXXRecordDecl * Class,SourceLocation CurrentLocation)10621 static void checkMoveAssignmentForRepeatedMove(Sema &S, CXXRecordDecl *Class,
10622                                                SourceLocation CurrentLocation) {
10623   assert(!Class->isDependentContext() && "should not define dependent move");
10624 
10625   // Only a virtual base could get implicitly move-assigned multiple times.
10626   // Only a non-trivial move assignment can observe this. We only want to
10627   // diagnose if we implicitly define an assignment operator that assigns
10628   // two base classes, both of which move-assign the same virtual base.
10629   if (Class->getNumVBases() == 0 || Class->hasTrivialMoveAssignment() ||
10630       Class->getNumBases() < 2)
10631     return;
10632 
10633   llvm::SmallVector<CXXBaseSpecifier *, 16> Worklist;
10634   typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
10635   VBaseMap VBases;
10636 
10637   for (auto &BI : Class->bases()) {
10638     Worklist.push_back(&BI);
10639     while (!Worklist.empty()) {
10640       CXXBaseSpecifier *BaseSpec = Worklist.pop_back_val();
10641       CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
10642 
10643       // If the base has no non-trivial move assignment operators,
10644       // we don't care about moves from it.
10645       if (!Base->hasNonTrivialMoveAssignment())
10646         continue;
10647 
10648       // If there's nothing virtual here, skip it.
10649       if (!BaseSpec->isVirtual() && !Base->getNumVBases())
10650         continue;
10651 
10652       // If we're not actually going to call a move assignment for this base,
10653       // or the selected move assignment is trivial, skip it.
10654       Sema::SpecialMemberOverloadResult *SMOR =
10655         S.LookupSpecialMember(Base, Sema::CXXMoveAssignment,
10656                               /*ConstArg*/false, /*VolatileArg*/false,
10657                               /*RValueThis*/true, /*ConstThis*/false,
10658                               /*VolatileThis*/false);
10659       if (!SMOR->getMethod() || SMOR->getMethod()->isTrivial() ||
10660           !SMOR->getMethod()->isMoveAssignmentOperator())
10661         continue;
10662 
10663       if (BaseSpec->isVirtual()) {
10664         // We're going to move-assign this virtual base, and its move
10665         // assignment operator is not trivial. If this can happen for
10666         // multiple distinct direct bases of Class, diagnose it. (If it
10667         // only happens in one base, we'll diagnose it when synthesizing
10668         // that base class's move assignment operator.)
10669         CXXBaseSpecifier *&Existing =
10670             VBases.insert(std::make_pair(Base->getCanonicalDecl(), &BI))
10671                 .first->second;
10672         if (Existing && Existing != &BI) {
10673           S.Diag(CurrentLocation, diag::warn_vbase_moved_multiple_times)
10674             << Class << Base;
10675           S.Diag(Existing->getLocStart(), diag::note_vbase_moved_here)
10676             << (Base->getCanonicalDecl() ==
10677                 Existing->getType()->getAsCXXRecordDecl()->getCanonicalDecl())
10678             << Base << Existing->getType() << Existing->getSourceRange();
10679           S.Diag(BI.getLocStart(), diag::note_vbase_moved_here)
10680             << (Base->getCanonicalDecl() ==
10681                 BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
10682             << Base << BI.getType() << BaseSpec->getSourceRange();
10683 
10684           // Only diagnose each vbase once.
10685           Existing = nullptr;
10686         }
10687       } else {
10688         // Only walk over bases that have defaulted move assignment operators.
10689         // We assume that any user-provided move assignment operator handles
10690         // the multiple-moves-of-vbase case itself somehow.
10691         if (!SMOR->getMethod()->isDefaulted())
10692           continue;
10693 
10694         // We're going to move the base classes of Base. Add them to the list.
10695         for (auto &BI : Base->bases())
10696           Worklist.push_back(&BI);
10697       }
10698     }
10699   }
10700 }
10701 
DefineImplicitMoveAssignment(SourceLocation CurrentLocation,CXXMethodDecl * MoveAssignOperator)10702 void Sema::DefineImplicitMoveAssignment(SourceLocation CurrentLocation,
10703                                         CXXMethodDecl *MoveAssignOperator) {
10704   assert((MoveAssignOperator->isDefaulted() &&
10705           MoveAssignOperator->isOverloadedOperator() &&
10706           MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
10707           !MoveAssignOperator->doesThisDeclarationHaveABody() &&
10708           !MoveAssignOperator->isDeleted()) &&
10709          "DefineImplicitMoveAssignment called for wrong function");
10710 
10711   CXXRecordDecl *ClassDecl = MoveAssignOperator->getParent();
10712 
10713   if (ClassDecl->isInvalidDecl() || MoveAssignOperator->isInvalidDecl()) {
10714     MoveAssignOperator->setInvalidDecl();
10715     return;
10716   }
10717 
10718   MoveAssignOperator->markUsed(Context);
10719 
10720   SynthesizedFunctionScope Scope(*this, MoveAssignOperator);
10721   DiagnosticErrorTrap Trap(Diags);
10722 
10723   // C++0x [class.copy]p28:
10724   //   The implicitly-defined or move assignment operator for a non-union class
10725   //   X performs memberwise move assignment of its subobjects. The direct base
10726   //   classes of X are assigned first, in the order of their declaration in the
10727   //   base-specifier-list, and then the immediate non-static data members of X
10728   //   are assigned, in the order in which they were declared in the class
10729   //   definition.
10730 
10731   // Issue a warning if our implicit move assignment operator will move
10732   // from a virtual base more than once.
10733   checkMoveAssignmentForRepeatedMove(*this, ClassDecl, CurrentLocation);
10734 
10735   // The statements that form the synthesized function body.
10736   SmallVector<Stmt*, 8> Statements;
10737 
10738   // The parameter for the "other" object, which we are move from.
10739   ParmVarDecl *Other = MoveAssignOperator->getParamDecl(0);
10740   QualType OtherRefType = Other->getType()->
10741       getAs<RValueReferenceType>()->getPointeeType();
10742   assert(!OtherRefType.getQualifiers() &&
10743          "Bad argument type of defaulted move assignment");
10744 
10745   // Our location for everything implicitly-generated.
10746   SourceLocation Loc = MoveAssignOperator->getLocEnd().isValid()
10747                            ? MoveAssignOperator->getLocEnd()
10748                            : MoveAssignOperator->getLocation();
10749 
10750   // Builds a reference to the "other" object.
10751   RefBuilder OtherRef(Other, OtherRefType);
10752   // Cast to rvalue.
10753   MoveCastBuilder MoveOther(OtherRef);
10754 
10755   // Builds the "this" pointer.
10756   ThisBuilder This;
10757 
10758   // Assign base classes.
10759   bool Invalid = false;
10760   for (auto &Base : ClassDecl->bases()) {
10761     // C++11 [class.copy]p28:
10762     //   It is unspecified whether subobjects representing virtual base classes
10763     //   are assigned more than once by the implicitly-defined copy assignment
10764     //   operator.
10765     // FIXME: Do not assign to a vbase that will be assigned by some other base
10766     // class. For a move-assignment, this can result in the vbase being moved
10767     // multiple times.
10768 
10769     // Form the assignment:
10770     //   static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other));
10771     QualType BaseType = Base.getType().getUnqualifiedType();
10772     if (!BaseType->isRecordType()) {
10773       Invalid = true;
10774       continue;
10775     }
10776 
10777     CXXCastPath BasePath;
10778     BasePath.push_back(&Base);
10779 
10780     // Construct the "from" expression, which is an implicit cast to the
10781     // appropriately-qualified base type.
10782     CastBuilder From(OtherRef, BaseType, VK_XValue, BasePath);
10783 
10784     // Dereference "this".
10785     DerefBuilder DerefThis(This);
10786 
10787     // Implicitly cast "this" to the appropriately-qualified base type.
10788     CastBuilder To(DerefThis,
10789                    Context.getCVRQualifiedType(
10790                        BaseType, MoveAssignOperator->getTypeQualifiers()),
10791                    VK_LValue, BasePath);
10792 
10793     // Build the move.
10794     StmtResult Move = buildSingleCopyAssign(*this, Loc, BaseType,
10795                                             To, From,
10796                                             /*CopyingBaseSubobject=*/true,
10797                                             /*Copying=*/false);
10798     if (Move.isInvalid()) {
10799       Diag(CurrentLocation, diag::note_member_synthesized_at)
10800         << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10801       MoveAssignOperator->setInvalidDecl();
10802       return;
10803     }
10804 
10805     // Success! Record the move.
10806     Statements.push_back(Move.getAs<Expr>());
10807   }
10808 
10809   // Assign non-static members.
10810   for (auto *Field : ClassDecl->fields()) {
10811     // FIXME: We should form some kind of AST representation for the implied
10812     // memcpy in a union copy operation.
10813     if (Field->isUnnamedBitfield() || Field->getParent()->isUnion())
10814       continue;
10815 
10816     if (Field->isInvalidDecl()) {
10817       Invalid = true;
10818       continue;
10819     }
10820 
10821     // Check for members of reference type; we can't move those.
10822     if (Field->getType()->isReferenceType()) {
10823       Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
10824         << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
10825       Diag(Field->getLocation(), diag::note_declared_at);
10826       Diag(CurrentLocation, diag::note_member_synthesized_at)
10827         << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10828       Invalid = true;
10829       continue;
10830     }
10831 
10832     // Check for members of const-qualified, non-class type.
10833     QualType BaseType = Context.getBaseElementType(Field->getType());
10834     if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
10835       Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
10836         << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
10837       Diag(Field->getLocation(), diag::note_declared_at);
10838       Diag(CurrentLocation, diag::note_member_synthesized_at)
10839         << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10840       Invalid = true;
10841       continue;
10842     }
10843 
10844     // Suppress assigning zero-width bitfields.
10845     if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
10846       continue;
10847 
10848     QualType FieldType = Field->getType().getNonReferenceType();
10849     if (FieldType->isIncompleteArrayType()) {
10850       assert(ClassDecl->hasFlexibleArrayMember() &&
10851              "Incomplete array type is not valid");
10852       continue;
10853     }
10854 
10855     // Build references to the field in the object we're copying from and to.
10856     LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
10857                               LookupMemberName);
10858     MemberLookup.addDecl(Field);
10859     MemberLookup.resolveKind();
10860     MemberBuilder From(MoveOther, OtherRefType,
10861                        /*IsArrow=*/false, MemberLookup);
10862     MemberBuilder To(This, getCurrentThisType(),
10863                      /*IsArrow=*/true, MemberLookup);
10864 
10865     assert(!From.build(*this, Loc)->isLValue() && // could be xvalue or prvalue
10866         "Member reference with rvalue base must be rvalue except for reference "
10867         "members, which aren't allowed for move assignment.");
10868 
10869     // Build the move of this field.
10870     StmtResult Move = buildSingleCopyAssign(*this, Loc, FieldType,
10871                                             To, From,
10872                                             /*CopyingBaseSubobject=*/false,
10873                                             /*Copying=*/false);
10874     if (Move.isInvalid()) {
10875       Diag(CurrentLocation, diag::note_member_synthesized_at)
10876         << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10877       MoveAssignOperator->setInvalidDecl();
10878       return;
10879     }
10880 
10881     // Success! Record the copy.
10882     Statements.push_back(Move.getAs<Stmt>());
10883   }
10884 
10885   if (!Invalid) {
10886     // Add a "return *this;"
10887     ExprResult ThisObj =
10888         CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
10889 
10890     StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
10891     if (Return.isInvalid())
10892       Invalid = true;
10893     else {
10894       Statements.push_back(Return.getAs<Stmt>());
10895 
10896       if (Trap.hasErrorOccurred()) {
10897         Diag(CurrentLocation, diag::note_member_synthesized_at)
10898           << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
10899         Invalid = true;
10900       }
10901     }
10902   }
10903 
10904   // The exception specification is needed because we are defining the
10905   // function.
10906   ResolveExceptionSpec(CurrentLocation,
10907                        MoveAssignOperator->getType()->castAs<FunctionProtoType>());
10908 
10909   if (Invalid) {
10910     MoveAssignOperator->setInvalidDecl();
10911     return;
10912   }
10913 
10914   StmtResult Body;
10915   {
10916     CompoundScopeRAII CompoundScope(*this);
10917     Body = ActOnCompoundStmt(Loc, Loc, Statements,
10918                              /*isStmtExpr=*/false);
10919     assert(!Body.isInvalid() && "Compound statement creation cannot fail");
10920   }
10921   MoveAssignOperator->setBody(Body.getAs<Stmt>());
10922 
10923   if (ASTMutationListener *L = getASTMutationListener()) {
10924     L->CompletedImplicitDefinition(MoveAssignOperator);
10925   }
10926 }
10927 
10928 Sema::ImplicitExceptionSpecification
ComputeDefaultedCopyCtorExceptionSpec(CXXMethodDecl * MD)10929 Sema::ComputeDefaultedCopyCtorExceptionSpec(CXXMethodDecl *MD) {
10930   CXXRecordDecl *ClassDecl = MD->getParent();
10931 
10932   ImplicitExceptionSpecification ExceptSpec(*this);
10933   if (ClassDecl->isInvalidDecl())
10934     return ExceptSpec;
10935 
10936   const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
10937   assert(T->getNumParams() >= 1 && "not a copy ctor");
10938   unsigned Quals = T->getParamType(0).getNonReferenceType().getCVRQualifiers();
10939 
10940   // C++ [except.spec]p14:
10941   //   An implicitly declared special member function (Clause 12) shall have an
10942   //   exception-specification. [...]
10943   for (const auto &Base : ClassDecl->bases()) {
10944     // Virtual bases are handled below.
10945     if (Base.isVirtual())
10946       continue;
10947 
10948     CXXRecordDecl *BaseClassDecl
10949       = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
10950     if (CXXConstructorDecl *CopyConstructor =
10951           LookupCopyingConstructor(BaseClassDecl, Quals))
10952       ExceptSpec.CalledDecl(Base.getLocStart(), CopyConstructor);
10953   }
10954   for (const auto &Base : ClassDecl->vbases()) {
10955     CXXRecordDecl *BaseClassDecl
10956       = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
10957     if (CXXConstructorDecl *CopyConstructor =
10958           LookupCopyingConstructor(BaseClassDecl, Quals))
10959       ExceptSpec.CalledDecl(Base.getLocStart(), CopyConstructor);
10960   }
10961   for (const auto *Field : ClassDecl->fields()) {
10962     QualType FieldType = Context.getBaseElementType(Field->getType());
10963     if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
10964       if (CXXConstructorDecl *CopyConstructor =
10965               LookupCopyingConstructor(FieldClassDecl,
10966                                        Quals | FieldType.getCVRQualifiers()))
10967       ExceptSpec.CalledDecl(Field->getLocation(), CopyConstructor);
10968     }
10969   }
10970 
10971   return ExceptSpec;
10972 }
10973 
DeclareImplicitCopyConstructor(CXXRecordDecl * ClassDecl)10974 CXXConstructorDecl *Sema::DeclareImplicitCopyConstructor(
10975                                                     CXXRecordDecl *ClassDecl) {
10976   // C++ [class.copy]p4:
10977   //   If the class definition does not explicitly declare a copy
10978   //   constructor, one is declared implicitly.
10979   assert(ClassDecl->needsImplicitCopyConstructor());
10980 
10981   DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyConstructor);
10982   if (DSM.isAlreadyBeingDeclared())
10983     return nullptr;
10984 
10985   QualType ClassType = Context.getTypeDeclType(ClassDecl);
10986   QualType ArgType = ClassType;
10987   bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
10988   if (Const)
10989     ArgType = ArgType.withConst();
10990   ArgType = Context.getLValueReferenceType(ArgType);
10991 
10992   bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
10993                                                      CXXCopyConstructor,
10994                                                      Const);
10995 
10996   DeclarationName Name
10997     = Context.DeclarationNames.getCXXConstructorName(
10998                                            Context.getCanonicalType(ClassType));
10999   SourceLocation ClassLoc = ClassDecl->getLocation();
11000   DeclarationNameInfo NameInfo(Name, ClassLoc);
11001 
11002   //   An implicitly-declared copy constructor is an inline public
11003   //   member of its class.
11004   CXXConstructorDecl *CopyConstructor = CXXConstructorDecl::Create(
11005       Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
11006       /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
11007       Constexpr);
11008   CopyConstructor->setAccess(AS_public);
11009   CopyConstructor->setDefaulted();
11010 
11011   if (getLangOpts().CUDA) {
11012     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyConstructor,
11013                                             CopyConstructor,
11014                                             /* ConstRHS */ Const,
11015                                             /* Diagnose */ false);
11016   }
11017 
11018   // Build an exception specification pointing back at this member.
11019   FunctionProtoType::ExtProtoInfo EPI =
11020       getImplicitMethodEPI(*this, CopyConstructor);
11021   CopyConstructor->setType(
11022       Context.getFunctionType(Context.VoidTy, ArgType, EPI));
11023 
11024   // Add the parameter to the constructor.
11025   ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
11026                                                ClassLoc, ClassLoc,
11027                                                /*IdentifierInfo=*/nullptr,
11028                                                ArgType, /*TInfo=*/nullptr,
11029                                                SC_None, nullptr);
11030   CopyConstructor->setParams(FromParam);
11031 
11032   CopyConstructor->setTrivial(
11033     ClassDecl->needsOverloadResolutionForCopyConstructor()
11034       ? SpecialMemberIsTrivial(CopyConstructor, CXXCopyConstructor)
11035       : ClassDecl->hasTrivialCopyConstructor());
11036 
11037   // Note that we have declared this constructor.
11038   ++ASTContext::NumImplicitCopyConstructorsDeclared;
11039 
11040   Scope *S = getScopeForContext(ClassDecl);
11041   CheckImplicitSpecialMemberDeclaration(S, CopyConstructor);
11042 
11043   if (ShouldDeleteSpecialMember(CopyConstructor, CXXCopyConstructor))
11044     SetDeclDeleted(CopyConstructor, ClassLoc);
11045 
11046   if (S)
11047     PushOnScopeChains(CopyConstructor, S, false);
11048   ClassDecl->addDecl(CopyConstructor);
11049 
11050   return CopyConstructor;
11051 }
11052 
DefineImplicitCopyConstructor(SourceLocation CurrentLocation,CXXConstructorDecl * CopyConstructor)11053 void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
11054                                    CXXConstructorDecl *CopyConstructor) {
11055   assert((CopyConstructor->isDefaulted() &&
11056           CopyConstructor->isCopyConstructor() &&
11057           !CopyConstructor->doesThisDeclarationHaveABody() &&
11058           !CopyConstructor->isDeleted()) &&
11059          "DefineImplicitCopyConstructor - call it for implicit copy ctor");
11060 
11061   CXXRecordDecl *ClassDecl = CopyConstructor->getParent();
11062   assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
11063 
11064   // C++11 [class.copy]p7:
11065   //   The [definition of an implicitly declared copy constructor] is
11066   //   deprecated if the class has a user-declared copy assignment operator
11067   //   or a user-declared destructor.
11068   if (getLangOpts().CPlusPlus11 && CopyConstructor->isImplicit())
11069     diagnoseDeprecatedCopyOperation(*this, CopyConstructor, CurrentLocation);
11070 
11071   SynthesizedFunctionScope Scope(*this, CopyConstructor);
11072   DiagnosticErrorTrap Trap(Diags);
11073 
11074   if (SetCtorInitializers(CopyConstructor, /*AnyErrors=*/false) ||
11075       Trap.hasErrorOccurred()) {
11076     Diag(CurrentLocation, diag::note_member_synthesized_at)
11077       << CXXCopyConstructor << Context.getTagDeclType(ClassDecl);
11078     CopyConstructor->setInvalidDecl();
11079   }  else {
11080     SourceLocation Loc = CopyConstructor->getLocEnd().isValid()
11081                              ? CopyConstructor->getLocEnd()
11082                              : CopyConstructor->getLocation();
11083     Sema::CompoundScopeRAII CompoundScope(*this);
11084     CopyConstructor->setBody(
11085         ActOnCompoundStmt(Loc, Loc, None, /*isStmtExpr=*/false).getAs<Stmt>());
11086   }
11087 
11088   // The exception specification is needed because we are defining the
11089   // function.
11090   ResolveExceptionSpec(CurrentLocation,
11091                        CopyConstructor->getType()->castAs<FunctionProtoType>());
11092 
11093   CopyConstructor->markUsed(Context);
11094   MarkVTableUsed(CurrentLocation, ClassDecl);
11095 
11096   if (ASTMutationListener *L = getASTMutationListener()) {
11097     L->CompletedImplicitDefinition(CopyConstructor);
11098   }
11099 }
11100 
11101 Sema::ImplicitExceptionSpecification
ComputeDefaultedMoveCtorExceptionSpec(CXXMethodDecl * MD)11102 Sema::ComputeDefaultedMoveCtorExceptionSpec(CXXMethodDecl *MD) {
11103   CXXRecordDecl *ClassDecl = MD->getParent();
11104 
11105   // C++ [except.spec]p14:
11106   //   An implicitly declared special member function (Clause 12) shall have an
11107   //   exception-specification. [...]
11108   ImplicitExceptionSpecification ExceptSpec(*this);
11109   if (ClassDecl->isInvalidDecl())
11110     return ExceptSpec;
11111 
11112   // Direct base-class constructors.
11113   for (const auto &B : ClassDecl->bases()) {
11114     if (B.isVirtual()) // Handled below.
11115       continue;
11116 
11117     if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
11118       CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
11119       CXXConstructorDecl *Constructor =
11120           LookupMovingConstructor(BaseClassDecl, 0);
11121       // If this is a deleted function, add it anyway. This might be conformant
11122       // with the standard. This might not. I'm not sure. It might not matter.
11123       if (Constructor)
11124         ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
11125     }
11126   }
11127 
11128   // Virtual base-class constructors.
11129   for (const auto &B : ClassDecl->vbases()) {
11130     if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
11131       CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
11132       CXXConstructorDecl *Constructor =
11133           LookupMovingConstructor(BaseClassDecl, 0);
11134       // If this is a deleted function, add it anyway. This might be conformant
11135       // with the standard. This might not. I'm not sure. It might not matter.
11136       if (Constructor)
11137         ExceptSpec.CalledDecl(B.getLocStart(), Constructor);
11138     }
11139   }
11140 
11141   // Field constructors.
11142   for (const auto *F : ClassDecl->fields()) {
11143     QualType FieldType = Context.getBaseElementType(F->getType());
11144     if (CXXRecordDecl *FieldRecDecl = FieldType->getAsCXXRecordDecl()) {
11145       CXXConstructorDecl *Constructor =
11146           LookupMovingConstructor(FieldRecDecl, FieldType.getCVRQualifiers());
11147       // If this is a deleted function, add it anyway. This might be conformant
11148       // with the standard. This might not. I'm not sure. It might not matter.
11149       // In particular, the problem is that this function never gets called. It
11150       // might just be ill-formed because this function attempts to refer to
11151       // a deleted function here.
11152       if (Constructor)
11153         ExceptSpec.CalledDecl(F->getLocation(), Constructor);
11154     }
11155   }
11156 
11157   return ExceptSpec;
11158 }
11159 
DeclareImplicitMoveConstructor(CXXRecordDecl * ClassDecl)11160 CXXConstructorDecl *Sema::DeclareImplicitMoveConstructor(
11161                                                     CXXRecordDecl *ClassDecl) {
11162   assert(ClassDecl->needsImplicitMoveConstructor());
11163 
11164   DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveConstructor);
11165   if (DSM.isAlreadyBeingDeclared())
11166     return nullptr;
11167 
11168   QualType ClassType = Context.getTypeDeclType(ClassDecl);
11169   QualType ArgType = Context.getRValueReferenceType(ClassType);
11170 
11171   bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
11172                                                      CXXMoveConstructor,
11173                                                      false);
11174 
11175   DeclarationName Name
11176     = Context.DeclarationNames.getCXXConstructorName(
11177                                            Context.getCanonicalType(ClassType));
11178   SourceLocation ClassLoc = ClassDecl->getLocation();
11179   DeclarationNameInfo NameInfo(Name, ClassLoc);
11180 
11181   // C++11 [class.copy]p11:
11182   //   An implicitly-declared copy/move constructor is an inline public
11183   //   member of its class.
11184   CXXConstructorDecl *MoveConstructor = CXXConstructorDecl::Create(
11185       Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
11186       /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
11187       Constexpr);
11188   MoveConstructor->setAccess(AS_public);
11189   MoveConstructor->setDefaulted();
11190 
11191   if (getLangOpts().CUDA) {
11192     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveConstructor,
11193                                             MoveConstructor,
11194                                             /* ConstRHS */ false,
11195                                             /* Diagnose */ false);
11196   }
11197 
11198   // Build an exception specification pointing back at this member.
11199   FunctionProtoType::ExtProtoInfo EPI =
11200       getImplicitMethodEPI(*this, MoveConstructor);
11201   MoveConstructor->setType(
11202       Context.getFunctionType(Context.VoidTy, ArgType, EPI));
11203 
11204   // Add the parameter to the constructor.
11205   ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveConstructor,
11206                                                ClassLoc, ClassLoc,
11207                                                /*IdentifierInfo=*/nullptr,
11208                                                ArgType, /*TInfo=*/nullptr,
11209                                                SC_None, nullptr);
11210   MoveConstructor->setParams(FromParam);
11211 
11212   MoveConstructor->setTrivial(
11213     ClassDecl->needsOverloadResolutionForMoveConstructor()
11214       ? SpecialMemberIsTrivial(MoveConstructor, CXXMoveConstructor)
11215       : ClassDecl->hasTrivialMoveConstructor());
11216 
11217   // Note that we have declared this constructor.
11218   ++ASTContext::NumImplicitMoveConstructorsDeclared;
11219 
11220   Scope *S = getScopeForContext(ClassDecl);
11221   CheckImplicitSpecialMemberDeclaration(S, MoveConstructor);
11222 
11223   if (ShouldDeleteSpecialMember(MoveConstructor, CXXMoveConstructor)) {
11224     ClassDecl->setImplicitMoveConstructorIsDeleted();
11225     SetDeclDeleted(MoveConstructor, ClassLoc);
11226   }
11227 
11228   if (S)
11229     PushOnScopeChains(MoveConstructor, S, false);
11230   ClassDecl->addDecl(MoveConstructor);
11231 
11232   return MoveConstructor;
11233 }
11234 
DefineImplicitMoveConstructor(SourceLocation CurrentLocation,CXXConstructorDecl * MoveConstructor)11235 void Sema::DefineImplicitMoveConstructor(SourceLocation CurrentLocation,
11236                                    CXXConstructorDecl *MoveConstructor) {
11237   assert((MoveConstructor->isDefaulted() &&
11238           MoveConstructor->isMoveConstructor() &&
11239           !MoveConstructor->doesThisDeclarationHaveABody() &&
11240           !MoveConstructor->isDeleted()) &&
11241          "DefineImplicitMoveConstructor - call it for implicit move ctor");
11242 
11243   CXXRecordDecl *ClassDecl = MoveConstructor->getParent();
11244   assert(ClassDecl && "DefineImplicitMoveConstructor - invalid constructor");
11245 
11246   SynthesizedFunctionScope Scope(*this, MoveConstructor);
11247   DiagnosticErrorTrap Trap(Diags);
11248 
11249   if (SetCtorInitializers(MoveConstructor, /*AnyErrors=*/false) ||
11250       Trap.hasErrorOccurred()) {
11251     Diag(CurrentLocation, diag::note_member_synthesized_at)
11252       << CXXMoveConstructor << Context.getTagDeclType(ClassDecl);
11253     MoveConstructor->setInvalidDecl();
11254   }  else {
11255     SourceLocation Loc = MoveConstructor->getLocEnd().isValid()
11256                              ? MoveConstructor->getLocEnd()
11257                              : MoveConstructor->getLocation();
11258     Sema::CompoundScopeRAII CompoundScope(*this);
11259     MoveConstructor->setBody(ActOnCompoundStmt(
11260         Loc, Loc, None, /*isStmtExpr=*/ false).getAs<Stmt>());
11261   }
11262 
11263   // The exception specification is needed because we are defining the
11264   // function.
11265   ResolveExceptionSpec(CurrentLocation,
11266                        MoveConstructor->getType()->castAs<FunctionProtoType>());
11267 
11268   MoveConstructor->markUsed(Context);
11269   MarkVTableUsed(CurrentLocation, ClassDecl);
11270 
11271   if (ASTMutationListener *L = getASTMutationListener()) {
11272     L->CompletedImplicitDefinition(MoveConstructor);
11273   }
11274 }
11275 
isImplicitlyDeleted(FunctionDecl * FD)11276 bool Sema::isImplicitlyDeleted(FunctionDecl *FD) {
11277   return FD->isDeleted() && FD->isDefaulted() && isa<CXXMethodDecl>(FD);
11278 }
11279 
DefineImplicitLambdaToFunctionPointerConversion(SourceLocation CurrentLocation,CXXConversionDecl * Conv)11280 void Sema::DefineImplicitLambdaToFunctionPointerConversion(
11281                             SourceLocation CurrentLocation,
11282                             CXXConversionDecl *Conv) {
11283   CXXRecordDecl *Lambda = Conv->getParent();
11284   CXXMethodDecl *CallOp = Lambda->getLambdaCallOperator();
11285   // If we are defining a specialization of a conversion to function-ptr
11286   // cache the deduced template arguments for this specialization
11287   // so that we can use them to retrieve the corresponding call-operator
11288   // and static-invoker.
11289   const TemplateArgumentList *DeducedTemplateArgs = nullptr;
11290 
11291   // Retrieve the corresponding call-operator specialization.
11292   if (Lambda->isGenericLambda()) {
11293     assert(Conv->isFunctionTemplateSpecialization());
11294     FunctionTemplateDecl *CallOpTemplate =
11295         CallOp->getDescribedFunctionTemplate();
11296     DeducedTemplateArgs = Conv->getTemplateSpecializationArgs();
11297     void *InsertPos = nullptr;
11298     FunctionDecl *CallOpSpec = CallOpTemplate->findSpecialization(
11299                                                 DeducedTemplateArgs->asArray(),
11300                                                 InsertPos);
11301     assert(CallOpSpec &&
11302           "Conversion operator must have a corresponding call operator");
11303     CallOp = cast<CXXMethodDecl>(CallOpSpec);
11304   }
11305   // Mark the call operator referenced (and add to pending instantiations
11306   // if necessary).
11307   // For both the conversion and static-invoker template specializations
11308   // we construct their body's in this function, so no need to add them
11309   // to the PendingInstantiations.
11310   MarkFunctionReferenced(CurrentLocation, CallOp);
11311 
11312   SynthesizedFunctionScope Scope(*this, Conv);
11313   DiagnosticErrorTrap Trap(Diags);
11314 
11315   // Retrieve the static invoker...
11316   CXXMethodDecl *Invoker = Lambda->getLambdaStaticInvoker();
11317   // ... and get the corresponding specialization for a generic lambda.
11318   if (Lambda->isGenericLambda()) {
11319     assert(DeducedTemplateArgs &&
11320       "Must have deduced template arguments from Conversion Operator");
11321     FunctionTemplateDecl *InvokeTemplate =
11322                           Invoker->getDescribedFunctionTemplate();
11323     void *InsertPos = nullptr;
11324     FunctionDecl *InvokeSpec = InvokeTemplate->findSpecialization(
11325                                                 DeducedTemplateArgs->asArray(),
11326                                                 InsertPos);
11327     assert(InvokeSpec &&
11328       "Must have a corresponding static invoker specialization");
11329     Invoker = cast<CXXMethodDecl>(InvokeSpec);
11330   }
11331   // Construct the body of the conversion function { return __invoke; }.
11332   Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(),
11333                                         VK_LValue, Conv->getLocation()).get();
11334    assert(FunctionRef && "Can't refer to __invoke function?");
11335    Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
11336    Conv->setBody(new (Context) CompoundStmt(Context, Return,
11337                                             Conv->getLocation(),
11338                                             Conv->getLocation()));
11339 
11340   Conv->markUsed(Context);
11341   Conv->setReferenced();
11342 
11343   // Fill in the __invoke function with a dummy implementation. IR generation
11344   // will fill in the actual details.
11345   Invoker->markUsed(Context);
11346   Invoker->setReferenced();
11347   Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));
11348 
11349   if (ASTMutationListener *L = getASTMutationListener()) {
11350     L->CompletedImplicitDefinition(Conv);
11351     L->CompletedImplicitDefinition(Invoker);
11352    }
11353 }
11354 
11355 
11356 
DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLocation,CXXConversionDecl * Conv)11357 void Sema::DefineImplicitLambdaToBlockPointerConversion(
11358        SourceLocation CurrentLocation,
11359        CXXConversionDecl *Conv)
11360 {
11361   assert(!Conv->getParent()->isGenericLambda());
11362 
11363   Conv->markUsed(Context);
11364 
11365   SynthesizedFunctionScope Scope(*this, Conv);
11366   DiagnosticErrorTrap Trap(Diags);
11367 
11368   // Copy-initialize the lambda object as needed to capture it.
11369   Expr *This = ActOnCXXThis(CurrentLocation).get();
11370   Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).get();
11371 
11372   ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation,
11373                                                         Conv->getLocation(),
11374                                                         Conv, DerefThis);
11375 
11376   // If we're not under ARC, make sure we still get the _Block_copy/autorelease
11377   // behavior.  Note that only the general conversion function does this
11378   // (since it's unusable otherwise); in the case where we inline the
11379   // block literal, it has block literal lifetime semantics.
11380   if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
11381     BuildBlock = ImplicitCastExpr::Create(Context, BuildBlock.get()->getType(),
11382                                           CK_CopyAndAutoreleaseBlockObject,
11383                                           BuildBlock.get(), nullptr, VK_RValue);
11384 
11385   if (BuildBlock.isInvalid()) {
11386     Diag(CurrentLocation, diag::note_lambda_to_block_conv);
11387     Conv->setInvalidDecl();
11388     return;
11389   }
11390 
11391   // Create the return statement that returns the block from the conversion
11392   // function.
11393   StmtResult Return = BuildReturnStmt(Conv->getLocation(), BuildBlock.get());
11394   if (Return.isInvalid()) {
11395     Diag(CurrentLocation, diag::note_lambda_to_block_conv);
11396     Conv->setInvalidDecl();
11397     return;
11398   }
11399 
11400   // Set the body of the conversion function.
11401   Stmt *ReturnS = Return.get();
11402   Conv->setBody(new (Context) CompoundStmt(Context, ReturnS,
11403                                            Conv->getLocation(),
11404                                            Conv->getLocation()));
11405 
11406   // We're done; notify the mutation listener, if any.
11407   if (ASTMutationListener *L = getASTMutationListener()) {
11408     L->CompletedImplicitDefinition(Conv);
11409   }
11410 }
11411 
11412 /// \brief Determine whether the given list arguments contains exactly one
11413 /// "real" (non-default) argument.
hasOneRealArgument(MultiExprArg Args)11414 static bool hasOneRealArgument(MultiExprArg Args) {
11415   switch (Args.size()) {
11416   case 0:
11417     return false;
11418 
11419   default:
11420     if (!Args[1]->isDefaultArgument())
11421       return false;
11422 
11423     // fall through
11424   case 1:
11425     return !Args[0]->isDefaultArgument();
11426   }
11427 
11428   return false;
11429 }
11430 
11431 ExprResult
BuildCXXConstructExpr(SourceLocation ConstructLoc,QualType DeclInitType,NamedDecl * FoundDecl,CXXConstructorDecl * Constructor,MultiExprArg ExprArgs,bool HadMultipleCandidates,bool IsListInitialization,bool IsStdInitListInitialization,bool RequiresZeroInit,unsigned ConstructKind,SourceRange ParenRange)11432 Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
11433                             NamedDecl *FoundDecl,
11434                             CXXConstructorDecl *Constructor,
11435                             MultiExprArg ExprArgs,
11436                             bool HadMultipleCandidates,
11437                             bool IsListInitialization,
11438                             bool IsStdInitListInitialization,
11439                             bool RequiresZeroInit,
11440                             unsigned ConstructKind,
11441                             SourceRange ParenRange) {
11442   bool Elidable = false;
11443 
11444   // C++0x [class.copy]p34:
11445   //   When certain criteria are met, an implementation is allowed to
11446   //   omit the copy/move construction of a class object, even if the
11447   //   copy/move constructor and/or destructor for the object have
11448   //   side effects. [...]
11449   //     - when a temporary class object that has not been bound to a
11450   //       reference (12.2) would be copied/moved to a class object
11451   //       with the same cv-unqualified type, the copy/move operation
11452   //       can be omitted by constructing the temporary object
11453   //       directly into the target of the omitted copy/move
11454   if (ConstructKind == CXXConstructExpr::CK_Complete && Constructor &&
11455       Constructor->isCopyOrMoveConstructor() && hasOneRealArgument(ExprArgs)) {
11456     Expr *SubExpr = ExprArgs[0];
11457     Elidable = SubExpr->isTemporaryObject(
11458         Context, cast<CXXRecordDecl>(FoundDecl->getDeclContext()));
11459   }
11460 
11461   return BuildCXXConstructExpr(ConstructLoc, DeclInitType,
11462                                FoundDecl, Constructor,
11463                                Elidable, ExprArgs, HadMultipleCandidates,
11464                                IsListInitialization,
11465                                IsStdInitListInitialization, RequiresZeroInit,
11466                                ConstructKind, ParenRange);
11467 }
11468 
11469 ExprResult
BuildCXXConstructExpr(SourceLocation ConstructLoc,QualType DeclInitType,NamedDecl * FoundDecl,CXXConstructorDecl * Constructor,bool Elidable,MultiExprArg ExprArgs,bool HadMultipleCandidates,bool IsListInitialization,bool IsStdInitListInitialization,bool RequiresZeroInit,unsigned ConstructKind,SourceRange ParenRange)11470 Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
11471                             NamedDecl *FoundDecl,
11472                             CXXConstructorDecl *Constructor,
11473                             bool Elidable,
11474                             MultiExprArg ExprArgs,
11475                             bool HadMultipleCandidates,
11476                             bool IsListInitialization,
11477                             bool IsStdInitListInitialization,
11478                             bool RequiresZeroInit,
11479                             unsigned ConstructKind,
11480                             SourceRange ParenRange) {
11481   if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl)) {
11482     Constructor = findInheritingConstructor(ConstructLoc, Constructor, Shadow);
11483     if (DiagnoseUseOfDecl(Constructor, ConstructLoc))
11484       return ExprError();
11485   }
11486 
11487   return BuildCXXConstructExpr(
11488       ConstructLoc, DeclInitType, Constructor, Elidable, ExprArgs,
11489       HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
11490       RequiresZeroInit, ConstructKind, ParenRange);
11491 }
11492 
11493 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
11494 /// including handling of its default argument expressions.
11495 ExprResult
BuildCXXConstructExpr(SourceLocation ConstructLoc,QualType DeclInitType,CXXConstructorDecl * Constructor,bool Elidable,MultiExprArg ExprArgs,bool HadMultipleCandidates,bool IsListInitialization,bool IsStdInitListInitialization,bool RequiresZeroInit,unsigned ConstructKind,SourceRange ParenRange)11496 Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
11497                             CXXConstructorDecl *Constructor,
11498                             bool Elidable,
11499                             MultiExprArg ExprArgs,
11500                             bool HadMultipleCandidates,
11501                             bool IsListInitialization,
11502                             bool IsStdInitListInitialization,
11503                             bool RequiresZeroInit,
11504                             unsigned ConstructKind,
11505                             SourceRange ParenRange) {
11506   assert(declaresSameEntity(
11507              Constructor->getParent(),
11508              DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) &&
11509          "given constructor for wrong type");
11510   MarkFunctionReferenced(ConstructLoc, Constructor);
11511 
11512   return CXXConstructExpr::Create(
11513       Context, DeclInitType, ConstructLoc, Constructor, Elidable,
11514       ExprArgs, HadMultipleCandidates, IsListInitialization,
11515       IsStdInitListInitialization, RequiresZeroInit,
11516       static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
11517       ParenRange);
11518 }
11519 
BuildCXXDefaultInitExpr(SourceLocation Loc,FieldDecl * Field)11520 ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
11521   assert(Field->hasInClassInitializer());
11522 
11523   // If we already have the in-class initializer nothing needs to be done.
11524   if (Field->getInClassInitializer())
11525     return CXXDefaultInitExpr::Create(Context, Loc, Field);
11526 
11527   // Maybe we haven't instantiated the in-class initializer. Go check the
11528   // pattern FieldDecl to see if it has one.
11529   CXXRecordDecl *ParentRD = cast<CXXRecordDecl>(Field->getParent());
11530 
11531   if (isTemplateInstantiation(ParentRD->getTemplateSpecializationKind())) {
11532     CXXRecordDecl *ClassPattern = ParentRD->getTemplateInstantiationPattern();
11533     DeclContext::lookup_result Lookup =
11534         ClassPattern->lookup(Field->getDeclName());
11535 
11536     // Lookup can return at most two results: the pattern for the field, or the
11537     // injected class name of the parent record. No other member can have the
11538     // same name as the field.
11539     assert(!Lookup.empty() && Lookup.size() <= 2 &&
11540            "more than two lookup results for field name");
11541     FieldDecl *Pattern = dyn_cast<FieldDecl>(Lookup[0]);
11542     if (!Pattern) {
11543       assert(isa<CXXRecordDecl>(Lookup[0]) &&
11544              "cannot have other non-field member with same name");
11545       Pattern = cast<FieldDecl>(Lookup[1]);
11546     }
11547 
11548     if (InstantiateInClassInitializer(Loc, Field, Pattern,
11549                                       getTemplateInstantiationArgs(Field)))
11550       return ExprError();
11551     return CXXDefaultInitExpr::Create(Context, Loc, Field);
11552   }
11553 
11554   // DR1351:
11555   //   If the brace-or-equal-initializer of a non-static data member
11556   //   invokes a defaulted default constructor of its class or of an
11557   //   enclosing class in a potentially evaluated subexpression, the
11558   //   program is ill-formed.
11559   //
11560   // This resolution is unworkable: the exception specification of the
11561   // default constructor can be needed in an unevaluated context, in
11562   // particular, in the operand of a noexcept-expression, and we can be
11563   // unable to compute an exception specification for an enclosed class.
11564   //
11565   // Any attempt to resolve the exception specification of a defaulted default
11566   // constructor before the initializer is lexically complete will ultimately
11567   // come here at which point we can diagnose it.
11568   RecordDecl *OutermostClass = ParentRD->getOuterLexicalRecordContext();
11569   if (OutermostClass == ParentRD) {
11570     Diag(Field->getLocEnd(), diag::err_in_class_initializer_not_yet_parsed)
11571         << ParentRD << Field;
11572   } else {
11573     Diag(Field->getLocEnd(),
11574          diag::err_in_class_initializer_not_yet_parsed_outer_class)
11575         << ParentRD << OutermostClass << Field;
11576   }
11577 
11578   return ExprError();
11579 }
11580 
FinalizeVarWithDestructor(VarDecl * VD,const RecordType * Record)11581 void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {
11582   if (VD->isInvalidDecl()) return;
11583 
11584   CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());
11585   if (ClassDecl->isInvalidDecl()) return;
11586   if (ClassDecl->hasIrrelevantDestructor()) return;
11587   if (ClassDecl->isDependentContext()) return;
11588 
11589   CXXDestructorDecl *Destructor = LookupDestructor(ClassDecl);
11590   MarkFunctionReferenced(VD->getLocation(), Destructor);
11591   CheckDestructorAccess(VD->getLocation(), Destructor,
11592                         PDiag(diag::err_access_dtor_var)
11593                         << VD->getDeclName()
11594                         << VD->getType());
11595   DiagnoseUseOfDecl(Destructor, VD->getLocation());
11596 
11597   if (Destructor->isTrivial()) return;
11598   if (!VD->hasGlobalStorage()) return;
11599 
11600   // Emit warning for non-trivial dtor in global scope (a real global,
11601   // class-static, function-static).
11602   Diag(VD->getLocation(), diag::warn_exit_time_destructor);
11603 
11604   // TODO: this should be re-enabled for static locals by !CXAAtExit
11605   if (!VD->isStaticLocal())
11606     Diag(VD->getLocation(), diag::warn_global_destructor);
11607 }
11608 
11609 /// \brief Given a constructor and the set of arguments provided for the
11610 /// constructor, convert the arguments and add any required default arguments
11611 /// to form a proper call to this constructor.
11612 ///
11613 /// \returns true if an error occurred, false otherwise.
11614 bool
CompleteConstructorCall(CXXConstructorDecl * Constructor,MultiExprArg ArgsPtr,SourceLocation Loc,SmallVectorImpl<Expr * > & ConvertedArgs,bool AllowExplicit,bool IsListInitialization)11615 Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
11616                               MultiExprArg ArgsPtr,
11617                               SourceLocation Loc,
11618                               SmallVectorImpl<Expr*> &ConvertedArgs,
11619                               bool AllowExplicit,
11620                               bool IsListInitialization) {
11621   // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
11622   unsigned NumArgs = ArgsPtr.size();
11623   Expr **Args = ArgsPtr.data();
11624 
11625   const FunctionProtoType *Proto
11626     = Constructor->getType()->getAs<FunctionProtoType>();
11627   assert(Proto && "Constructor without a prototype?");
11628   unsigned NumParams = Proto->getNumParams();
11629 
11630   // If too few arguments are available, we'll fill in the rest with defaults.
11631   if (NumArgs < NumParams)
11632     ConvertedArgs.reserve(NumParams);
11633   else
11634     ConvertedArgs.reserve(NumArgs);
11635 
11636   VariadicCallType CallType =
11637     Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
11638   SmallVector<Expr *, 8> AllArgs;
11639   bool Invalid = GatherArgumentsForCall(Loc, Constructor,
11640                                         Proto, 0,
11641                                         llvm::makeArrayRef(Args, NumArgs),
11642                                         AllArgs,
11643                                         CallType, AllowExplicit,
11644                                         IsListInitialization);
11645   ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
11646 
11647   DiagnoseSentinelCalls(Constructor, Loc, AllArgs);
11648 
11649   CheckConstructorCall(Constructor,
11650                        llvm::makeArrayRef(AllArgs.data(), AllArgs.size()),
11651                        Proto, Loc);
11652 
11653   return Invalid;
11654 }
11655 
11656 static inline bool
CheckOperatorNewDeleteDeclarationScope(Sema & SemaRef,const FunctionDecl * FnDecl)11657 CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef,
11658                                        const FunctionDecl *FnDecl) {
11659   const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
11660   if (isa<NamespaceDecl>(DC)) {
11661     return SemaRef.Diag(FnDecl->getLocation(),
11662                         diag::err_operator_new_delete_declared_in_namespace)
11663       << FnDecl->getDeclName();
11664   }
11665 
11666   if (isa<TranslationUnitDecl>(DC) &&
11667       FnDecl->getStorageClass() == SC_Static) {
11668     return SemaRef.Diag(FnDecl->getLocation(),
11669                         diag::err_operator_new_delete_declared_static)
11670       << FnDecl->getDeclName();
11671   }
11672 
11673   return false;
11674 }
11675 
11676 static inline bool
CheckOperatorNewDeleteTypes(Sema & SemaRef,const FunctionDecl * FnDecl,CanQualType ExpectedResultType,CanQualType ExpectedFirstParamType,unsigned DependentParamTypeDiag,unsigned InvalidParamTypeDiag)11677 CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
11678                             CanQualType ExpectedResultType,
11679                             CanQualType ExpectedFirstParamType,
11680                             unsigned DependentParamTypeDiag,
11681                             unsigned InvalidParamTypeDiag) {
11682   QualType ResultType =
11683       FnDecl->getType()->getAs<FunctionType>()->getReturnType();
11684 
11685   // Check that the result type is not dependent.
11686   if (ResultType->isDependentType())
11687     return SemaRef.Diag(FnDecl->getLocation(),
11688                         diag::err_operator_new_delete_dependent_result_type)
11689     << FnDecl->getDeclName() << ExpectedResultType;
11690 
11691   // Check that the result type is what we expect.
11692   if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType)
11693     return SemaRef.Diag(FnDecl->getLocation(),
11694                         diag::err_operator_new_delete_invalid_result_type)
11695     << FnDecl->getDeclName() << ExpectedResultType;
11696 
11697   // A function template must have at least 2 parameters.
11698   if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
11699     return SemaRef.Diag(FnDecl->getLocation(),
11700                       diag::err_operator_new_delete_template_too_few_parameters)
11701         << FnDecl->getDeclName();
11702 
11703   // The function decl must have at least 1 parameter.
11704   if (FnDecl->getNumParams() == 0)
11705     return SemaRef.Diag(FnDecl->getLocation(),
11706                         diag::err_operator_new_delete_too_few_parameters)
11707       << FnDecl->getDeclName();
11708 
11709   // Check the first parameter type is not dependent.
11710   QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
11711   if (FirstParamType->isDependentType())
11712     return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag)
11713       << FnDecl->getDeclName() << ExpectedFirstParamType;
11714 
11715   // Check that the first parameter type is what we expect.
11716   if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
11717       ExpectedFirstParamType)
11718     return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
11719     << FnDecl->getDeclName() << ExpectedFirstParamType;
11720 
11721   return false;
11722 }
11723 
11724 static bool
CheckOperatorNewDeclaration(Sema & SemaRef,const FunctionDecl * FnDecl)11725 CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
11726   // C++ [basic.stc.dynamic.allocation]p1:
11727   //   A program is ill-formed if an allocation function is declared in a
11728   //   namespace scope other than global scope or declared static in global
11729   //   scope.
11730   if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
11731     return true;
11732 
11733   CanQualType SizeTy =
11734     SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType());
11735 
11736   // C++ [basic.stc.dynamic.allocation]p1:
11737   //  The return type shall be void*. The first parameter shall have type
11738   //  std::size_t.
11739   if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy,
11740                                   SizeTy,
11741                                   diag::err_operator_new_dependent_param_type,
11742                                   diag::err_operator_new_param_type))
11743     return true;
11744 
11745   // C++ [basic.stc.dynamic.allocation]p1:
11746   //  The first parameter shall not have an associated default argument.
11747   if (FnDecl->getParamDecl(0)->hasDefaultArg())
11748     return SemaRef.Diag(FnDecl->getLocation(),
11749                         diag::err_operator_new_default_arg)
11750       << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();
11751 
11752   return false;
11753 }
11754 
11755 static bool
CheckOperatorDeleteDeclaration(Sema & SemaRef,FunctionDecl * FnDecl)11756 CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {
11757   // C++ [basic.stc.dynamic.deallocation]p1:
11758   //   A program is ill-formed if deallocation functions are declared in a
11759   //   namespace scope other than global scope or declared static in global
11760   //   scope.
11761   if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
11762     return true;
11763 
11764   // C++ [basic.stc.dynamic.deallocation]p2:
11765   //   Each deallocation function shall return void and its first parameter
11766   //   shall be void*.
11767   if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidTy,
11768                                   SemaRef.Context.VoidPtrTy,
11769                                  diag::err_operator_delete_dependent_param_type,
11770                                  diag::err_operator_delete_param_type))
11771     return true;
11772 
11773   return false;
11774 }
11775 
11776 /// CheckOverloadedOperatorDeclaration - Check whether the declaration
11777 /// of this overloaded operator is well-formed. If so, returns false;
11778 /// otherwise, emits appropriate diagnostics and returns true.
CheckOverloadedOperatorDeclaration(FunctionDecl * FnDecl)11779 bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
11780   assert(FnDecl && FnDecl->isOverloadedOperator() &&
11781          "Expected an overloaded operator declaration");
11782 
11783   OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
11784 
11785   // C++ [over.oper]p5:
11786   //   The allocation and deallocation functions, operator new,
11787   //   operator new[], operator delete and operator delete[], are
11788   //   described completely in 3.7.3. The attributes and restrictions
11789   //   found in the rest of this subclause do not apply to them unless
11790   //   explicitly stated in 3.7.3.
11791   if (Op == OO_Delete || Op == OO_Array_Delete)
11792     return CheckOperatorDeleteDeclaration(*this, FnDecl);
11793 
11794   if (Op == OO_New || Op == OO_Array_New)
11795     return CheckOperatorNewDeclaration(*this, FnDecl);
11796 
11797   // C++ [over.oper]p6:
11798   //   An operator function shall either be a non-static member
11799   //   function or be a non-member function and have at least one
11800   //   parameter whose type is a class, a reference to a class, an
11801   //   enumeration, or a reference to an enumeration.
11802   if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
11803     if (MethodDecl->isStatic())
11804       return Diag(FnDecl->getLocation(),
11805                   diag::err_operator_overload_static) << FnDecl->getDeclName();
11806   } else {
11807     bool ClassOrEnumParam = false;
11808     for (auto Param : FnDecl->parameters()) {
11809       QualType ParamType = Param->getType().getNonReferenceType();
11810       if (ParamType->isDependentType() || ParamType->isRecordType() ||
11811           ParamType->isEnumeralType()) {
11812         ClassOrEnumParam = true;
11813         break;
11814       }
11815     }
11816 
11817     if (!ClassOrEnumParam)
11818       return Diag(FnDecl->getLocation(),
11819                   diag::err_operator_overload_needs_class_or_enum)
11820         << FnDecl->getDeclName();
11821   }
11822 
11823   // C++ [over.oper]p8:
11824   //   An operator function cannot have default arguments (8.3.6),
11825   //   except where explicitly stated below.
11826   //
11827   // Only the function-call operator allows default arguments
11828   // (C++ [over.call]p1).
11829   if (Op != OO_Call) {
11830     for (auto Param : FnDecl->parameters()) {
11831       if (Param->hasDefaultArg())
11832         return Diag(Param->getLocation(),
11833                     diag::err_operator_overload_default_arg)
11834           << FnDecl->getDeclName() << Param->getDefaultArgRange();
11835     }
11836   }
11837 
11838   static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
11839     { false, false, false }
11840 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
11841     , { Unary, Binary, MemberOnly }
11842 #include "clang/Basic/OperatorKinds.def"
11843   };
11844 
11845   bool CanBeUnaryOperator = OperatorUses[Op][0];
11846   bool CanBeBinaryOperator = OperatorUses[Op][1];
11847   bool MustBeMemberOperator = OperatorUses[Op][2];
11848 
11849   // C++ [over.oper]p8:
11850   //   [...] Operator functions cannot have more or fewer parameters
11851   //   than the number required for the corresponding operator, as
11852   //   described in the rest of this subclause.
11853   unsigned NumParams = FnDecl->getNumParams()
11854                      + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
11855   if (Op != OO_Call &&
11856       ((NumParams == 1 && !CanBeUnaryOperator) ||
11857        (NumParams == 2 && !CanBeBinaryOperator) ||
11858        (NumParams < 1) || (NumParams > 2))) {
11859     // We have the wrong number of parameters.
11860     unsigned ErrorKind;
11861     if (CanBeUnaryOperator && CanBeBinaryOperator) {
11862       ErrorKind = 2;  // 2 -> unary or binary.
11863     } else if (CanBeUnaryOperator) {
11864       ErrorKind = 0;  // 0 -> unary
11865     } else {
11866       assert(CanBeBinaryOperator &&
11867              "All non-call overloaded operators are unary or binary!");
11868       ErrorKind = 1;  // 1 -> binary
11869     }
11870 
11871     return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
11872       << FnDecl->getDeclName() << NumParams << ErrorKind;
11873   }
11874 
11875   // Overloaded operators other than operator() cannot be variadic.
11876   if (Op != OO_Call &&
11877       FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) {
11878     return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
11879       << FnDecl->getDeclName();
11880   }
11881 
11882   // Some operators must be non-static member functions.
11883   if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
11884     return Diag(FnDecl->getLocation(),
11885                 diag::err_operator_overload_must_be_member)
11886       << FnDecl->getDeclName();
11887   }
11888 
11889   // C++ [over.inc]p1:
11890   //   The user-defined function called operator++ implements the
11891   //   prefix and postfix ++ operator. If this function is a member
11892   //   function with no parameters, or a non-member function with one
11893   //   parameter of class or enumeration type, it defines the prefix
11894   //   increment operator ++ for objects of that type. If the function
11895   //   is a member function with one parameter (which shall be of type
11896   //   int) or a non-member function with two parameters (the second
11897   //   of which shall be of type int), it defines the postfix
11898   //   increment operator ++ for objects of that type.
11899   if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
11900     ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
11901     QualType ParamType = LastParam->getType();
11902 
11903     if (!ParamType->isSpecificBuiltinType(BuiltinType::Int) &&
11904         !ParamType->isDependentType())
11905       return Diag(LastParam->getLocation(),
11906                   diag::err_operator_overload_post_incdec_must_be_int)
11907         << LastParam->getType() << (Op == OO_MinusMinus);
11908   }
11909 
11910   return false;
11911 }
11912 
11913 static bool
checkLiteralOperatorTemplateParameterList(Sema & SemaRef,FunctionTemplateDecl * TpDecl)11914 checkLiteralOperatorTemplateParameterList(Sema &SemaRef,
11915                                           FunctionTemplateDecl *TpDecl) {
11916   TemplateParameterList *TemplateParams = TpDecl->getTemplateParameters();
11917 
11918   // Must have one or two template parameters.
11919   if (TemplateParams->size() == 1) {
11920     NonTypeTemplateParmDecl *PmDecl =
11921         dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(0));
11922 
11923     // The template parameter must be a char parameter pack.
11924     if (PmDecl && PmDecl->isTemplateParameterPack() &&
11925         SemaRef.Context.hasSameType(PmDecl->getType(), SemaRef.Context.CharTy))
11926       return false;
11927 
11928   } else if (TemplateParams->size() == 2) {
11929     TemplateTypeParmDecl *PmType =
11930         dyn_cast<TemplateTypeParmDecl>(TemplateParams->getParam(0));
11931     NonTypeTemplateParmDecl *PmArgs =
11932         dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(1));
11933 
11934     // The second template parameter must be a parameter pack with the
11935     // first template parameter as its type.
11936     if (PmType && PmArgs && !PmType->isTemplateParameterPack() &&
11937         PmArgs->isTemplateParameterPack()) {
11938       const TemplateTypeParmType *TArgs =
11939           PmArgs->getType()->getAs<TemplateTypeParmType>();
11940       if (TArgs && TArgs->getDepth() == PmType->getDepth() &&
11941           TArgs->getIndex() == PmType->getIndex()) {
11942         if (SemaRef.ActiveTemplateInstantiations.empty())
11943           SemaRef.Diag(TpDecl->getLocation(),
11944                        diag::ext_string_literal_operator_template);
11945         return false;
11946       }
11947     }
11948   }
11949 
11950   SemaRef.Diag(TpDecl->getTemplateParameters()->getSourceRange().getBegin(),
11951                diag::err_literal_operator_template)
11952       << TpDecl->getTemplateParameters()->getSourceRange();
11953   return true;
11954 }
11955 
11956 /// CheckLiteralOperatorDeclaration - Check whether the declaration
11957 /// of this literal operator function is well-formed. If so, returns
11958 /// false; otherwise, emits appropriate diagnostics and returns true.
CheckLiteralOperatorDeclaration(FunctionDecl * FnDecl)11959 bool Sema::CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl) {
11960   if (isa<CXXMethodDecl>(FnDecl)) {
11961     Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
11962       << FnDecl->getDeclName();
11963     return true;
11964   }
11965 
11966   if (FnDecl->isExternC()) {
11967     Diag(FnDecl->getLocation(), diag::err_literal_operator_extern_c);
11968     return true;
11969   }
11970 
11971   // This might be the definition of a literal operator template.
11972   FunctionTemplateDecl *TpDecl = FnDecl->getDescribedFunctionTemplate();
11973 
11974   // This might be a specialization of a literal operator template.
11975   if (!TpDecl)
11976     TpDecl = FnDecl->getPrimaryTemplate();
11977 
11978   // template <char...> type operator "" name() and
11979   // template <class T, T...> type operator "" name() are the only valid
11980   // template signatures, and the only valid signatures with no parameters.
11981   if (TpDecl) {
11982     if (FnDecl->param_size() != 0) {
11983       Diag(FnDecl->getLocation(),
11984            diag::err_literal_operator_template_with_params);
11985       return true;
11986     }
11987 
11988     if (checkLiteralOperatorTemplateParameterList(*this, TpDecl))
11989       return true;
11990 
11991   } else if (FnDecl->param_size() == 1) {
11992     const ParmVarDecl *Param = FnDecl->getParamDecl(0);
11993 
11994     QualType ParamType = Param->getType().getUnqualifiedType();
11995 
11996     // Only unsigned long long int, long double, any character type, and const
11997     // char * are allowed as the only parameters.
11998     if (ParamType->isSpecificBuiltinType(BuiltinType::ULongLong) ||
11999         ParamType->isSpecificBuiltinType(BuiltinType::LongDouble) ||
12000         Context.hasSameType(ParamType, Context.CharTy) ||
12001         Context.hasSameType(ParamType, Context.WideCharTy) ||
12002         Context.hasSameType(ParamType, Context.Char16Ty) ||
12003         Context.hasSameType(ParamType, Context.Char32Ty)) {
12004     } else if (const PointerType *Ptr = ParamType->getAs<PointerType>()) {
12005       QualType InnerType = Ptr->getPointeeType();
12006 
12007       // Pointer parameter must be a const char *.
12008       if (!(Context.hasSameType(InnerType.getUnqualifiedType(),
12009                                 Context.CharTy) &&
12010             InnerType.isConstQualified() && !InnerType.isVolatileQualified())) {
12011         Diag(Param->getSourceRange().getBegin(),
12012              diag::err_literal_operator_param)
12013             << ParamType << "'const char *'" << Param->getSourceRange();
12014         return true;
12015       }
12016 
12017     } else if (ParamType->isRealFloatingType()) {
12018       Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
12019           << ParamType << Context.LongDoubleTy << Param->getSourceRange();
12020       return true;
12021 
12022     } else if (ParamType->isIntegerType()) {
12023       Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
12024           << ParamType << Context.UnsignedLongLongTy << Param->getSourceRange();
12025       return true;
12026 
12027     } else {
12028       Diag(Param->getSourceRange().getBegin(),
12029            diag::err_literal_operator_invalid_param)
12030           << ParamType << Param->getSourceRange();
12031       return true;
12032     }
12033 
12034   } else if (FnDecl->param_size() == 2) {
12035     FunctionDecl::param_iterator Param = FnDecl->param_begin();
12036 
12037     // First, verify that the first parameter is correct.
12038 
12039     QualType FirstParamType = (*Param)->getType().getUnqualifiedType();
12040 
12041     // Two parameter function must have a pointer to const as a
12042     // first parameter; let's strip those qualifiers.
12043     const PointerType *PT = FirstParamType->getAs<PointerType>();
12044 
12045     if (!PT) {
12046       Diag((*Param)->getSourceRange().getBegin(),
12047            diag::err_literal_operator_param)
12048           << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
12049       return true;
12050     }
12051 
12052     QualType PointeeType = PT->getPointeeType();
12053     // First parameter must be const
12054     if (!PointeeType.isConstQualified() || PointeeType.isVolatileQualified()) {
12055       Diag((*Param)->getSourceRange().getBegin(),
12056            diag::err_literal_operator_param)
12057           << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
12058       return true;
12059     }
12060 
12061     QualType InnerType = PointeeType.getUnqualifiedType();
12062     // Only const char *, const wchar_t*, const char16_t*, and const char32_t*
12063     // are allowed as the first parameter to a two-parameter function
12064     if (!(Context.hasSameType(InnerType, Context.CharTy) ||
12065           Context.hasSameType(InnerType, Context.WideCharTy) ||
12066           Context.hasSameType(InnerType, Context.Char16Ty) ||
12067           Context.hasSameType(InnerType, Context.Char32Ty))) {
12068       Diag((*Param)->getSourceRange().getBegin(),
12069            diag::err_literal_operator_param)
12070           << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
12071       return true;
12072     }
12073 
12074     // Move on to the second and final parameter.
12075     ++Param;
12076 
12077     // The second parameter must be a std::size_t.
12078     QualType SecondParamType = (*Param)->getType().getUnqualifiedType();
12079     if (!Context.hasSameType(SecondParamType, Context.getSizeType())) {
12080       Diag((*Param)->getSourceRange().getBegin(),
12081            diag::err_literal_operator_param)
12082           << SecondParamType << Context.getSizeType()
12083           << (*Param)->getSourceRange();
12084       return true;
12085     }
12086   } else {
12087     Diag(FnDecl->getLocation(), diag::err_literal_operator_bad_param_count);
12088     return true;
12089   }
12090 
12091   // Parameters are good.
12092 
12093   // A parameter-declaration-clause containing a default argument is not
12094   // equivalent to any of the permitted forms.
12095   for (auto Param : FnDecl->parameters()) {
12096     if (Param->hasDefaultArg()) {
12097       Diag(Param->getDefaultArgRange().getBegin(),
12098            diag::err_literal_operator_default_argument)
12099         << Param->getDefaultArgRange();
12100       break;
12101     }
12102   }
12103 
12104   StringRef LiteralName
12105     = FnDecl->getDeclName().getCXXLiteralIdentifier()->getName();
12106   if (LiteralName[0] != '_') {
12107     // C++11 [usrlit.suffix]p1:
12108     //   Literal suffix identifiers that do not start with an underscore
12109     //   are reserved for future standardization.
12110     Diag(FnDecl->getLocation(), diag::warn_user_literal_reserved)
12111       << NumericLiteralParser::isValidUDSuffix(getLangOpts(), LiteralName);
12112   }
12113 
12114   return false;
12115 }
12116 
12117 /// ActOnStartLinkageSpecification - Parsed the beginning of a C++
12118 /// linkage specification, including the language and (if present)
12119 /// the '{'. ExternLoc is the location of the 'extern', Lang is the
12120 /// language string literal. LBraceLoc, if valid, provides the location of
12121 /// the '{' brace. Otherwise, this linkage specification does not
12122 /// have any braces.
ActOnStartLinkageSpecification(Scope * S,SourceLocation ExternLoc,Expr * LangStr,SourceLocation LBraceLoc)12123 Decl *Sema::ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc,
12124                                            Expr *LangStr,
12125                                            SourceLocation LBraceLoc) {
12126   StringLiteral *Lit = cast<StringLiteral>(LangStr);
12127   if (!Lit->isAscii()) {
12128     Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_not_ascii)
12129       << LangStr->getSourceRange();
12130     return nullptr;
12131   }
12132 
12133   StringRef Lang = Lit->getString();
12134   LinkageSpecDecl::LanguageIDs Language;
12135   if (Lang == "C")
12136     Language = LinkageSpecDecl::lang_c;
12137   else if (Lang == "C++")
12138     Language = LinkageSpecDecl::lang_cxx;
12139   else {
12140     Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_unknown)
12141       << LangStr->getSourceRange();
12142     return nullptr;
12143   }
12144 
12145   // FIXME: Add all the various semantics of linkage specifications
12146 
12147   LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext, ExternLoc,
12148                                                LangStr->getExprLoc(), Language,
12149                                                LBraceLoc.isValid());
12150   CurContext->addDecl(D);
12151   PushDeclContext(S, D);
12152   return D;
12153 }
12154 
12155 /// ActOnFinishLinkageSpecification - Complete the definition of
12156 /// the C++ linkage specification LinkageSpec. If RBraceLoc is
12157 /// valid, it's the position of the closing '}' brace in a linkage
12158 /// specification that uses braces.
ActOnFinishLinkageSpecification(Scope * S,Decl * LinkageSpec,SourceLocation RBraceLoc)12159 Decl *Sema::ActOnFinishLinkageSpecification(Scope *S,
12160                                             Decl *LinkageSpec,
12161                                             SourceLocation RBraceLoc) {
12162   if (RBraceLoc.isValid()) {
12163     LinkageSpecDecl* LSDecl = cast<LinkageSpecDecl>(LinkageSpec);
12164     LSDecl->setRBraceLoc(RBraceLoc);
12165   }
12166   PopDeclContext();
12167   return LinkageSpec;
12168 }
12169 
ActOnEmptyDeclaration(Scope * S,AttributeList * AttrList,SourceLocation SemiLoc)12170 Decl *Sema::ActOnEmptyDeclaration(Scope *S,
12171                                   AttributeList *AttrList,
12172                                   SourceLocation SemiLoc) {
12173   Decl *ED = EmptyDecl::Create(Context, CurContext, SemiLoc);
12174   // Attribute declarations appertain to empty declaration so we handle
12175   // them here.
12176   if (AttrList)
12177     ProcessDeclAttributeList(S, ED, AttrList);
12178 
12179   CurContext->addDecl(ED);
12180   return ED;
12181 }
12182 
12183 /// \brief Perform semantic analysis for the variable declaration that
12184 /// occurs within a C++ catch clause, returning the newly-created
12185 /// variable.
BuildExceptionDeclaration(Scope * S,TypeSourceInfo * TInfo,SourceLocation StartLoc,SourceLocation Loc,IdentifierInfo * Name)12186 VarDecl *Sema::BuildExceptionDeclaration(Scope *S,
12187                                          TypeSourceInfo *TInfo,
12188                                          SourceLocation StartLoc,
12189                                          SourceLocation Loc,
12190                                          IdentifierInfo *Name) {
12191   bool Invalid = false;
12192   QualType ExDeclType = TInfo->getType();
12193 
12194   // Arrays and functions decay.
12195   if (ExDeclType->isArrayType())
12196     ExDeclType = Context.getArrayDecayedType(ExDeclType);
12197   else if (ExDeclType->isFunctionType())
12198     ExDeclType = Context.getPointerType(ExDeclType);
12199 
12200   // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
12201   // The exception-declaration shall not denote a pointer or reference to an
12202   // incomplete type, other than [cv] void*.
12203   // N2844 forbids rvalue references.
12204   if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
12205     Diag(Loc, diag::err_catch_rvalue_ref);
12206     Invalid = true;
12207   }
12208 
12209   if (ExDeclType->isVariablyModifiedType()) {
12210     Diag(Loc, diag::err_catch_variably_modified) << ExDeclType;
12211     Invalid = true;
12212   }
12213 
12214   QualType BaseType = ExDeclType;
12215   int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
12216   unsigned DK = diag::err_catch_incomplete;
12217   if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
12218     BaseType = Ptr->getPointeeType();
12219     Mode = 1;
12220     DK = diag::err_catch_incomplete_ptr;
12221   } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
12222     // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
12223     BaseType = Ref->getPointeeType();
12224     Mode = 2;
12225     DK = diag::err_catch_incomplete_ref;
12226   }
12227   if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
12228       !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
12229     Invalid = true;
12230 
12231   if (!Invalid && !ExDeclType->isDependentType() &&
12232       RequireNonAbstractType(Loc, ExDeclType,
12233                              diag::err_abstract_type_in_decl,
12234                              AbstractVariableType))
12235     Invalid = true;
12236 
12237   // Only the non-fragile NeXT runtime currently supports C++ catches
12238   // of ObjC types, and no runtime supports catching ObjC types by value.
12239   if (!Invalid && getLangOpts().ObjC1) {
12240     QualType T = ExDeclType;
12241     if (const ReferenceType *RT = T->getAs<ReferenceType>())
12242       T = RT->getPointeeType();
12243 
12244     if (T->isObjCObjectType()) {
12245       Diag(Loc, diag::err_objc_object_catch);
12246       Invalid = true;
12247     } else if (T->isObjCObjectPointerType()) {
12248       // FIXME: should this be a test for macosx-fragile specifically?
12249       if (getLangOpts().ObjCRuntime.isFragile())
12250         Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
12251     }
12252   }
12253 
12254   VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
12255                                     ExDeclType, TInfo, SC_None);
12256   ExDecl->setExceptionVariable(true);
12257 
12258   // In ARC, infer 'retaining' for variables of retainable type.
12259   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(ExDecl))
12260     Invalid = true;
12261 
12262   if (!Invalid && !ExDeclType->isDependentType()) {
12263     if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) {
12264       // Insulate this from anything else we might currently be parsing.
12265       EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated);
12266 
12267       // C++ [except.handle]p16:
12268       //   The object declared in an exception-declaration or, if the
12269       //   exception-declaration does not specify a name, a temporary (12.2) is
12270       //   copy-initialized (8.5) from the exception object. [...]
12271       //   The object is destroyed when the handler exits, after the destruction
12272       //   of any automatic objects initialized within the handler.
12273       //
12274       // We just pretend to initialize the object with itself, then make sure
12275       // it can be destroyed later.
12276       QualType initType = Context.getExceptionObjectType(ExDeclType);
12277 
12278       InitializedEntity entity =
12279         InitializedEntity::InitializeVariable(ExDecl);
12280       InitializationKind initKind =
12281         InitializationKind::CreateCopy(Loc, SourceLocation());
12282 
12283       Expr *opaqueValue =
12284         new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary);
12285       InitializationSequence sequence(*this, entity, initKind, opaqueValue);
12286       ExprResult result = sequence.Perform(*this, entity, initKind, opaqueValue);
12287       if (result.isInvalid())
12288         Invalid = true;
12289       else {
12290         // If the constructor used was non-trivial, set this as the
12291         // "initializer".
12292         CXXConstructExpr *construct = result.getAs<CXXConstructExpr>();
12293         if (!construct->getConstructor()->isTrivial()) {
12294           Expr *init = MaybeCreateExprWithCleanups(construct);
12295           ExDecl->setInit(init);
12296         }
12297 
12298         // And make sure it's destructable.
12299         FinalizeVarWithDestructor(ExDecl, recordType);
12300       }
12301     }
12302   }
12303 
12304   if (Invalid)
12305     ExDecl->setInvalidDecl();
12306 
12307   return ExDecl;
12308 }
12309 
12310 /// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
12311 /// handler.
ActOnExceptionDeclarator(Scope * S,Declarator & D)12312 Decl *Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
12313   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
12314   bool Invalid = D.isInvalidType();
12315 
12316   // Check for unexpanded parameter packs.
12317   if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
12318                                       UPPC_ExceptionType)) {
12319     TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
12320                                              D.getIdentifierLoc());
12321     Invalid = true;
12322   }
12323 
12324   IdentifierInfo *II = D.getIdentifier();
12325   if (NamedDecl *PrevDecl = LookupSingleName(S, II, D.getIdentifierLoc(),
12326                                              LookupOrdinaryName,
12327                                              ForRedeclaration)) {
12328     // The scope should be freshly made just for us. There is just no way
12329     // it contains any previous declaration, except for function parameters in
12330     // a function-try-block's catch statement.
12331     assert(!S->isDeclScope(PrevDecl));
12332     if (isDeclInScope(PrevDecl, CurContext, S)) {
12333       Diag(D.getIdentifierLoc(), diag::err_redefinition)
12334         << D.getIdentifier();
12335       Diag(PrevDecl->getLocation(), diag::note_previous_definition);
12336       Invalid = true;
12337     } else if (PrevDecl->isTemplateParameter())
12338       // Maybe we will complain about the shadowed template parameter.
12339       DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
12340   }
12341 
12342   if (D.getCXXScopeSpec().isSet() && !Invalid) {
12343     Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
12344       << D.getCXXScopeSpec().getRange();
12345     Invalid = true;
12346   }
12347 
12348   VarDecl *ExDecl = BuildExceptionDeclaration(S, TInfo,
12349                                               D.getLocStart(),
12350                                               D.getIdentifierLoc(),
12351                                               D.getIdentifier());
12352   if (Invalid)
12353     ExDecl->setInvalidDecl();
12354 
12355   // Add the exception declaration into this scope.
12356   if (II)
12357     PushOnScopeChains(ExDecl, S);
12358   else
12359     CurContext->addDecl(ExDecl);
12360 
12361   ProcessDeclAttributes(S, ExDecl, D);
12362   return ExDecl;
12363 }
12364 
ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,Expr * AssertExpr,Expr * AssertMessageExpr,SourceLocation RParenLoc)12365 Decl *Sema::ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,
12366                                          Expr *AssertExpr,
12367                                          Expr *AssertMessageExpr,
12368                                          SourceLocation RParenLoc) {
12369   StringLiteral *AssertMessage =
12370       AssertMessageExpr ? cast<StringLiteral>(AssertMessageExpr) : nullptr;
12371 
12372   if (DiagnoseUnexpandedParameterPack(AssertExpr, UPPC_StaticAssertExpression))
12373     return nullptr;
12374 
12375   return BuildStaticAssertDeclaration(StaticAssertLoc, AssertExpr,
12376                                       AssertMessage, RParenLoc, false);
12377 }
12378 
BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,Expr * AssertExpr,StringLiteral * AssertMessage,SourceLocation RParenLoc,bool Failed)12379 Decl *Sema::BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,
12380                                          Expr *AssertExpr,
12381                                          StringLiteral *AssertMessage,
12382                                          SourceLocation RParenLoc,
12383                                          bool Failed) {
12384   assert(AssertExpr != nullptr && "Expected non-null condition");
12385   if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent() &&
12386       !Failed) {
12387     // In a static_assert-declaration, the constant-expression shall be a
12388     // constant expression that can be contextually converted to bool.
12389     ExprResult Converted = PerformContextuallyConvertToBool(AssertExpr);
12390     if (Converted.isInvalid())
12391       Failed = true;
12392 
12393     llvm::APSInt Cond;
12394     if (!Failed && VerifyIntegerConstantExpression(Converted.get(), &Cond,
12395           diag::err_static_assert_expression_is_not_constant,
12396           /*AllowFold=*/false).isInvalid())
12397       Failed = true;
12398 
12399     if (!Failed && !Cond) {
12400       SmallString<256> MsgBuffer;
12401       llvm::raw_svector_ostream Msg(MsgBuffer);
12402       if (AssertMessage)
12403         AssertMessage->printPretty(Msg, nullptr, getPrintingPolicy());
12404       Diag(StaticAssertLoc, diag::err_static_assert_failed)
12405         << !AssertMessage << Msg.str() << AssertExpr->getSourceRange();
12406       Failed = true;
12407     }
12408   }
12409 
12410   Decl *Decl = StaticAssertDecl::Create(Context, CurContext, StaticAssertLoc,
12411                                         AssertExpr, AssertMessage, RParenLoc,
12412                                         Failed);
12413 
12414   CurContext->addDecl(Decl);
12415   return Decl;
12416 }
12417 
12418 /// \brief Perform semantic analysis of the given friend type declaration.
12419 ///
12420 /// \returns A friend declaration that.
CheckFriendTypeDecl(SourceLocation LocStart,SourceLocation FriendLoc,TypeSourceInfo * TSInfo)12421 FriendDecl *Sema::CheckFriendTypeDecl(SourceLocation LocStart,
12422                                       SourceLocation FriendLoc,
12423                                       TypeSourceInfo *TSInfo) {
12424   assert(TSInfo && "NULL TypeSourceInfo for friend type declaration");
12425 
12426   QualType T = TSInfo->getType();
12427   SourceRange TypeRange = TSInfo->getTypeLoc().getLocalSourceRange();
12428 
12429   // C++03 [class.friend]p2:
12430   //   An elaborated-type-specifier shall be used in a friend declaration
12431   //   for a class.*
12432   //
12433   //   * The class-key of the elaborated-type-specifier is required.
12434   if (!ActiveTemplateInstantiations.empty()) {
12435     // Do not complain about the form of friend template types during
12436     // template instantiation; we will already have complained when the
12437     // template was declared.
12438   } else {
12439     if (!T->isElaboratedTypeSpecifier()) {
12440       // If we evaluated the type to a record type, suggest putting
12441       // a tag in front.
12442       if (const RecordType *RT = T->getAs<RecordType>()) {
12443         RecordDecl *RD = RT->getDecl();
12444 
12445         SmallString<16> InsertionText(" ");
12446         InsertionText += RD->getKindName();
12447 
12448         Diag(TypeRange.getBegin(),
12449              getLangOpts().CPlusPlus11 ?
12450                diag::warn_cxx98_compat_unelaborated_friend_type :
12451                diag::ext_unelaborated_friend_type)
12452           << (unsigned) RD->getTagKind()
12453           << T
12454           << FixItHint::CreateInsertion(getLocForEndOfToken(FriendLoc),
12455                                         InsertionText);
12456       } else {
12457         Diag(FriendLoc,
12458              getLangOpts().CPlusPlus11 ?
12459                diag::warn_cxx98_compat_nonclass_type_friend :
12460                diag::ext_nonclass_type_friend)
12461           << T
12462           << TypeRange;
12463       }
12464     } else if (T->getAs<EnumType>()) {
12465       Diag(FriendLoc,
12466            getLangOpts().CPlusPlus11 ?
12467              diag::warn_cxx98_compat_enum_friend :
12468              diag::ext_enum_friend)
12469         << T
12470         << TypeRange;
12471     }
12472 
12473     // C++11 [class.friend]p3:
12474     //   A friend declaration that does not declare a function shall have one
12475     //   of the following forms:
12476     //     friend elaborated-type-specifier ;
12477     //     friend simple-type-specifier ;
12478     //     friend typename-specifier ;
12479     if (getLangOpts().CPlusPlus11 && LocStart != FriendLoc)
12480       Diag(FriendLoc, diag::err_friend_not_first_in_declaration) << T;
12481   }
12482 
12483   //   If the type specifier in a friend declaration designates a (possibly
12484   //   cv-qualified) class type, that class is declared as a friend; otherwise,
12485   //   the friend declaration is ignored.
12486   return FriendDecl::Create(Context, CurContext,
12487                             TSInfo->getTypeLoc().getLocStart(), TSInfo,
12488                             FriendLoc);
12489 }
12490 
12491 /// Handle a friend tag declaration where the scope specifier was
12492 /// templated.
ActOnTemplatedFriendTag(Scope * S,SourceLocation FriendLoc,unsigned TagSpec,SourceLocation TagLoc,CXXScopeSpec & SS,IdentifierInfo * Name,SourceLocation NameLoc,AttributeList * Attr,MultiTemplateParamsArg TempParamLists)12493 Decl *Sema::ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
12494                                     unsigned TagSpec, SourceLocation TagLoc,
12495                                     CXXScopeSpec &SS,
12496                                     IdentifierInfo *Name,
12497                                     SourceLocation NameLoc,
12498                                     AttributeList *Attr,
12499                                     MultiTemplateParamsArg TempParamLists) {
12500   TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
12501 
12502   bool isExplicitSpecialization = false;
12503   bool Invalid = false;
12504 
12505   if (TemplateParameterList *TemplateParams =
12506           MatchTemplateParametersToScopeSpecifier(
12507               TagLoc, NameLoc, SS, nullptr, TempParamLists, /*friend*/ true,
12508               isExplicitSpecialization, Invalid)) {
12509     if (TemplateParams->size() > 0) {
12510       // This is a declaration of a class template.
12511       if (Invalid)
12512         return nullptr;
12513 
12514       return CheckClassTemplate(S, TagSpec, TUK_Friend, TagLoc, SS, Name,
12515                                 NameLoc, Attr, TemplateParams, AS_public,
12516                                 /*ModulePrivateLoc=*/SourceLocation(),
12517                                 FriendLoc, TempParamLists.size() - 1,
12518                                 TempParamLists.data()).get();
12519     } else {
12520       // The "template<>" header is extraneous.
12521       Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
12522         << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
12523       isExplicitSpecialization = true;
12524     }
12525   }
12526 
12527   if (Invalid) return nullptr;
12528 
12529   bool isAllExplicitSpecializations = true;
12530   for (unsigned I = TempParamLists.size(); I-- > 0; ) {
12531     if (TempParamLists[I]->size()) {
12532       isAllExplicitSpecializations = false;
12533       break;
12534     }
12535   }
12536 
12537   // FIXME: don't ignore attributes.
12538 
12539   // If it's explicit specializations all the way down, just forget
12540   // about the template header and build an appropriate non-templated
12541   // friend.  TODO: for source fidelity, remember the headers.
12542   if (isAllExplicitSpecializations) {
12543     if (SS.isEmpty()) {
12544       bool Owned = false;
12545       bool IsDependent = false;
12546       return ActOnTag(S, TagSpec, TUK_Friend, TagLoc, SS, Name, NameLoc,
12547                       Attr, AS_public,
12548                       /*ModulePrivateLoc=*/SourceLocation(),
12549                       MultiTemplateParamsArg(), Owned, IsDependent,
12550                       /*ScopedEnumKWLoc=*/SourceLocation(),
12551                       /*ScopedEnumUsesClassTag=*/false,
12552                       /*UnderlyingType=*/TypeResult(),
12553                       /*IsTypeSpecifier=*/false);
12554     }
12555 
12556     NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
12557     ElaboratedTypeKeyword Keyword
12558       = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
12559     QualType T = CheckTypenameType(Keyword, TagLoc, QualifierLoc,
12560                                    *Name, NameLoc);
12561     if (T.isNull())
12562       return nullptr;
12563 
12564     TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
12565     if (isa<DependentNameType>(T)) {
12566       DependentNameTypeLoc TL =
12567           TSI->getTypeLoc().castAs<DependentNameTypeLoc>();
12568       TL.setElaboratedKeywordLoc(TagLoc);
12569       TL.setQualifierLoc(QualifierLoc);
12570       TL.setNameLoc(NameLoc);
12571     } else {
12572       ElaboratedTypeLoc TL = TSI->getTypeLoc().castAs<ElaboratedTypeLoc>();
12573       TL.setElaboratedKeywordLoc(TagLoc);
12574       TL.setQualifierLoc(QualifierLoc);
12575       TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(NameLoc);
12576     }
12577 
12578     FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
12579                                             TSI, FriendLoc, TempParamLists);
12580     Friend->setAccess(AS_public);
12581     CurContext->addDecl(Friend);
12582     return Friend;
12583   }
12584 
12585   assert(SS.isNotEmpty() && "valid templated tag with no SS and no direct?");
12586 
12587 
12588 
12589   // Handle the case of a templated-scope friend class.  e.g.
12590   //   template <class T> class A<T>::B;
12591   // FIXME: we don't support these right now.
12592   Diag(NameLoc, diag::warn_template_qualified_friend_unsupported)
12593     << SS.getScopeRep() << SS.getRange() << cast<CXXRecordDecl>(CurContext);
12594   ElaboratedTypeKeyword ETK = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
12595   QualType T = Context.getDependentNameType(ETK, SS.getScopeRep(), Name);
12596   TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
12597   DependentNameTypeLoc TL = TSI->getTypeLoc().castAs<DependentNameTypeLoc>();
12598   TL.setElaboratedKeywordLoc(TagLoc);
12599   TL.setQualifierLoc(SS.getWithLocInContext(Context));
12600   TL.setNameLoc(NameLoc);
12601 
12602   FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
12603                                           TSI, FriendLoc, TempParamLists);
12604   Friend->setAccess(AS_public);
12605   Friend->setUnsupportedFriend(true);
12606   CurContext->addDecl(Friend);
12607   return Friend;
12608 }
12609 
12610 
12611 /// Handle a friend type declaration.  This works in tandem with
12612 /// ActOnTag.
12613 ///
12614 /// Notes on friend class templates:
12615 ///
12616 /// We generally treat friend class declarations as if they were
12617 /// declaring a class.  So, for example, the elaborated type specifier
12618 /// in a friend declaration is required to obey the restrictions of a
12619 /// class-head (i.e. no typedefs in the scope chain), template
12620 /// parameters are required to match up with simple template-ids, &c.
12621 /// However, unlike when declaring a template specialization, it's
12622 /// okay to refer to a template specialization without an empty
12623 /// template parameter declaration, e.g.
12624 ///   friend class A<T>::B<unsigned>;
12625 /// We permit this as a special case; if there are any template
12626 /// parameters present at all, require proper matching, i.e.
12627 ///   template <> template \<class T> friend class A<int>::B;
ActOnFriendTypeDecl(Scope * S,const DeclSpec & DS,MultiTemplateParamsArg TempParams)12628 Decl *Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
12629                                 MultiTemplateParamsArg TempParams) {
12630   SourceLocation Loc = DS.getLocStart();
12631 
12632   assert(DS.isFriendSpecified());
12633   assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
12634 
12635   // Try to convert the decl specifier to a type.  This works for
12636   // friend templates because ActOnTag never produces a ClassTemplateDecl
12637   // for a TUK_Friend.
12638   Declarator TheDeclarator(DS, Declarator::MemberContext);
12639   TypeSourceInfo *TSI = GetTypeForDeclarator(TheDeclarator, S);
12640   QualType T = TSI->getType();
12641   if (TheDeclarator.isInvalidType())
12642     return nullptr;
12643 
12644   if (DiagnoseUnexpandedParameterPack(Loc, TSI, UPPC_FriendDeclaration))
12645     return nullptr;
12646 
12647   // This is definitely an error in C++98.  It's probably meant to
12648   // be forbidden in C++0x, too, but the specification is just
12649   // poorly written.
12650   //
12651   // The problem is with declarations like the following:
12652   //   template <T> friend A<T>::foo;
12653   // where deciding whether a class C is a friend or not now hinges
12654   // on whether there exists an instantiation of A that causes
12655   // 'foo' to equal C.  There are restrictions on class-heads
12656   // (which we declare (by fiat) elaborated friend declarations to
12657   // be) that makes this tractable.
12658   //
12659   // FIXME: handle "template <> friend class A<T>;", which
12660   // is possibly well-formed?  Who even knows?
12661   if (TempParams.size() && !T->isElaboratedTypeSpecifier()) {
12662     Diag(Loc, diag::err_tagless_friend_type_template)
12663       << DS.getSourceRange();
12664     return nullptr;
12665   }
12666 
12667   // C++98 [class.friend]p1: A friend of a class is a function
12668   //   or class that is not a member of the class . . .
12669   // This is fixed in DR77, which just barely didn't make the C++03
12670   // deadline.  It's also a very silly restriction that seriously
12671   // affects inner classes and which nobody else seems to implement;
12672   // thus we never diagnose it, not even in -pedantic.
12673   //
12674   // But note that we could warn about it: it's always useless to
12675   // friend one of your own members (it's not, however, worthless to
12676   // friend a member of an arbitrary specialization of your template).
12677 
12678   Decl *D;
12679   if (!TempParams.empty())
12680     D = FriendTemplateDecl::Create(Context, CurContext, Loc,
12681                                    TempParams,
12682                                    TSI,
12683                                    DS.getFriendSpecLoc());
12684   else
12685     D = CheckFriendTypeDecl(Loc, DS.getFriendSpecLoc(), TSI);
12686 
12687   if (!D)
12688     return nullptr;
12689 
12690   D->setAccess(AS_public);
12691   CurContext->addDecl(D);
12692 
12693   return D;
12694 }
12695 
ActOnFriendFunctionDecl(Scope * S,Declarator & D,MultiTemplateParamsArg TemplateParams)12696 NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D,
12697                                         MultiTemplateParamsArg TemplateParams) {
12698   const DeclSpec &DS = D.getDeclSpec();
12699 
12700   assert(DS.isFriendSpecified());
12701   assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
12702 
12703   SourceLocation Loc = D.getIdentifierLoc();
12704   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
12705 
12706   // C++ [class.friend]p1
12707   //   A friend of a class is a function or class....
12708   // Note that this sees through typedefs, which is intended.
12709   // It *doesn't* see through dependent types, which is correct
12710   // according to [temp.arg.type]p3:
12711   //   If a declaration acquires a function type through a
12712   //   type dependent on a template-parameter and this causes
12713   //   a declaration that does not use the syntactic form of a
12714   //   function declarator to have a function type, the program
12715   //   is ill-formed.
12716   if (!TInfo->getType()->isFunctionType()) {
12717     Diag(Loc, diag::err_unexpected_friend);
12718 
12719     // It might be worthwhile to try to recover by creating an
12720     // appropriate declaration.
12721     return nullptr;
12722   }
12723 
12724   // C++ [namespace.memdef]p3
12725   //  - If a friend declaration in a non-local class first declares a
12726   //    class or function, the friend class or function is a member
12727   //    of the innermost enclosing namespace.
12728   //  - The name of the friend is not found by simple name lookup
12729   //    until a matching declaration is provided in that namespace
12730   //    scope (either before or after the class declaration granting
12731   //    friendship).
12732   //  - If a friend function is called, its name may be found by the
12733   //    name lookup that considers functions from namespaces and
12734   //    classes associated with the types of the function arguments.
12735   //  - When looking for a prior declaration of a class or a function
12736   //    declared as a friend, scopes outside the innermost enclosing
12737   //    namespace scope are not considered.
12738 
12739   CXXScopeSpec &SS = D.getCXXScopeSpec();
12740   DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
12741   DeclarationName Name = NameInfo.getName();
12742   assert(Name);
12743 
12744   // Check for unexpanded parameter packs.
12745   if (DiagnoseUnexpandedParameterPack(Loc, TInfo, UPPC_FriendDeclaration) ||
12746       DiagnoseUnexpandedParameterPack(NameInfo, UPPC_FriendDeclaration) ||
12747       DiagnoseUnexpandedParameterPack(SS, UPPC_FriendDeclaration))
12748     return nullptr;
12749 
12750   // The context we found the declaration in, or in which we should
12751   // create the declaration.
12752   DeclContext *DC;
12753   Scope *DCScope = S;
12754   LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
12755                         ForRedeclaration);
12756 
12757   // There are five cases here.
12758   //   - There's no scope specifier and we're in a local class. Only look
12759   //     for functions declared in the immediately-enclosing block scope.
12760   // We recover from invalid scope qualifiers as if they just weren't there.
12761   FunctionDecl *FunctionContainingLocalClass = nullptr;
12762   if ((SS.isInvalid() || !SS.isSet()) &&
12763       (FunctionContainingLocalClass =
12764            cast<CXXRecordDecl>(CurContext)->isLocalClass())) {
12765     // C++11 [class.friend]p11:
12766     //   If a friend declaration appears in a local class and the name
12767     //   specified is an unqualified name, a prior declaration is
12768     //   looked up without considering scopes that are outside the
12769     //   innermost enclosing non-class scope. For a friend function
12770     //   declaration, if there is no prior declaration, the program is
12771     //   ill-formed.
12772 
12773     // Find the innermost enclosing non-class scope. This is the block
12774     // scope containing the local class definition (or for a nested class,
12775     // the outer local class).
12776     DCScope = S->getFnParent();
12777 
12778     // Look up the function name in the scope.
12779     Previous.clear(LookupLocalFriendName);
12780     LookupName(Previous, S, /*AllowBuiltinCreation*/false);
12781 
12782     if (!Previous.empty()) {
12783       // All possible previous declarations must have the same context:
12784       // either they were declared at block scope or they are members of
12785       // one of the enclosing local classes.
12786       DC = Previous.getRepresentativeDecl()->getDeclContext();
12787     } else {
12788       // This is ill-formed, but provide the context that we would have
12789       // declared the function in, if we were permitted to, for error recovery.
12790       DC = FunctionContainingLocalClass;
12791     }
12792     adjustContextForLocalExternDecl(DC);
12793 
12794     // C++ [class.friend]p6:
12795     //   A function can be defined in a friend declaration of a class if and
12796     //   only if the class is a non-local class (9.8), the function name is
12797     //   unqualified, and the function has namespace scope.
12798     if (D.isFunctionDefinition()) {
12799       Diag(NameInfo.getBeginLoc(), diag::err_friend_def_in_local_class);
12800     }
12801 
12802   //   - There's no scope specifier, in which case we just go to the
12803   //     appropriate scope and look for a function or function template
12804   //     there as appropriate.
12805   } else if (SS.isInvalid() || !SS.isSet()) {
12806     // C++11 [namespace.memdef]p3:
12807     //   If the name in a friend declaration is neither qualified nor
12808     //   a template-id and the declaration is a function or an
12809     //   elaborated-type-specifier, the lookup to determine whether
12810     //   the entity has been previously declared shall not consider
12811     //   any scopes outside the innermost enclosing namespace.
12812     bool isTemplateId = D.getName().getKind() == UnqualifiedId::IK_TemplateId;
12813 
12814     // Find the appropriate context according to the above.
12815     DC = CurContext;
12816 
12817     // Skip class contexts.  If someone can cite chapter and verse
12818     // for this behavior, that would be nice --- it's what GCC and
12819     // EDG do, and it seems like a reasonable intent, but the spec
12820     // really only says that checks for unqualified existing
12821     // declarations should stop at the nearest enclosing namespace,
12822     // not that they should only consider the nearest enclosing
12823     // namespace.
12824     while (DC->isRecord())
12825       DC = DC->getParent();
12826 
12827     DeclContext *LookupDC = DC;
12828     while (LookupDC->isTransparentContext())
12829       LookupDC = LookupDC->getParent();
12830 
12831     while (true) {
12832       LookupQualifiedName(Previous, LookupDC);
12833 
12834       if (!Previous.empty()) {
12835         DC = LookupDC;
12836         break;
12837       }
12838 
12839       if (isTemplateId) {
12840         if (isa<TranslationUnitDecl>(LookupDC)) break;
12841       } else {
12842         if (LookupDC->isFileContext()) break;
12843       }
12844       LookupDC = LookupDC->getParent();
12845     }
12846 
12847     DCScope = getScopeForDeclContext(S, DC);
12848 
12849   //   - There's a non-dependent scope specifier, in which case we
12850   //     compute it and do a previous lookup there for a function
12851   //     or function template.
12852   } else if (!SS.getScopeRep()->isDependent()) {
12853     DC = computeDeclContext(SS);
12854     if (!DC) return nullptr;
12855 
12856     if (RequireCompleteDeclContext(SS, DC)) return nullptr;
12857 
12858     LookupQualifiedName(Previous, DC);
12859 
12860     // Ignore things found implicitly in the wrong scope.
12861     // TODO: better diagnostics for this case.  Suggesting the right
12862     // qualified scope would be nice...
12863     LookupResult::Filter F = Previous.makeFilter();
12864     while (F.hasNext()) {
12865       NamedDecl *D = F.next();
12866       if (!DC->InEnclosingNamespaceSetOf(
12867               D->getDeclContext()->getRedeclContext()))
12868         F.erase();
12869     }
12870     F.done();
12871 
12872     if (Previous.empty()) {
12873       D.setInvalidType();
12874       Diag(Loc, diag::err_qualified_friend_not_found)
12875           << Name << TInfo->getType();
12876       return nullptr;
12877     }
12878 
12879     // C++ [class.friend]p1: A friend of a class is a function or
12880     //   class that is not a member of the class . . .
12881     if (DC->Equals(CurContext))
12882       Diag(DS.getFriendSpecLoc(),
12883            getLangOpts().CPlusPlus11 ?
12884              diag::warn_cxx98_compat_friend_is_member :
12885              diag::err_friend_is_member);
12886 
12887     if (D.isFunctionDefinition()) {
12888       // C++ [class.friend]p6:
12889       //   A function can be defined in a friend declaration of a class if and
12890       //   only if the class is a non-local class (9.8), the function name is
12891       //   unqualified, and the function has namespace scope.
12892       SemaDiagnosticBuilder DB
12893         = Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def);
12894 
12895       DB << SS.getScopeRep();
12896       if (DC->isFileContext())
12897         DB << FixItHint::CreateRemoval(SS.getRange());
12898       SS.clear();
12899     }
12900 
12901   //   - There's a scope specifier that does not match any template
12902   //     parameter lists, in which case we use some arbitrary context,
12903   //     create a method or method template, and wait for instantiation.
12904   //   - There's a scope specifier that does match some template
12905   //     parameter lists, which we don't handle right now.
12906   } else {
12907     if (D.isFunctionDefinition()) {
12908       // C++ [class.friend]p6:
12909       //   A function can be defined in a friend declaration of a class if and
12910       //   only if the class is a non-local class (9.8), the function name is
12911       //   unqualified, and the function has namespace scope.
12912       Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def)
12913         << SS.getScopeRep();
12914     }
12915 
12916     DC = CurContext;
12917     assert(isa<CXXRecordDecl>(DC) && "friend declaration not in class?");
12918   }
12919 
12920   if (!DC->isRecord()) {
12921     int DiagArg = -1;
12922     switch (D.getName().getKind()) {
12923     case UnqualifiedId::IK_ConstructorTemplateId:
12924     case UnqualifiedId::IK_ConstructorName:
12925       DiagArg = 0;
12926       break;
12927     case UnqualifiedId::IK_DestructorName:
12928       DiagArg = 1;
12929       break;
12930     case UnqualifiedId::IK_ConversionFunctionId:
12931       DiagArg = 2;
12932       break;
12933     case UnqualifiedId::IK_Identifier:
12934     case UnqualifiedId::IK_ImplicitSelfParam:
12935     case UnqualifiedId::IK_LiteralOperatorId:
12936     case UnqualifiedId::IK_OperatorFunctionId:
12937     case UnqualifiedId::IK_TemplateId:
12938       break;
12939     }
12940     // This implies that it has to be an operator or function.
12941     if (DiagArg >= 0) {
12942       Diag(Loc, diag::err_introducing_special_friend) << DiagArg;
12943       return nullptr;
12944     }
12945   }
12946 
12947   // FIXME: This is an egregious hack to cope with cases where the scope stack
12948   // does not contain the declaration context, i.e., in an out-of-line
12949   // definition of a class.
12950   Scope FakeDCScope(S, Scope::DeclScope, Diags);
12951   if (!DCScope) {
12952     FakeDCScope.setEntity(DC);
12953     DCScope = &FakeDCScope;
12954   }
12955 
12956   bool AddToScope = true;
12957   NamedDecl *ND = ActOnFunctionDeclarator(DCScope, D, DC, TInfo, Previous,
12958                                           TemplateParams, AddToScope);
12959   if (!ND) return nullptr;
12960 
12961   assert(ND->getLexicalDeclContext() == CurContext);
12962 
12963   // If we performed typo correction, we might have added a scope specifier
12964   // and changed the decl context.
12965   DC = ND->getDeclContext();
12966 
12967   // Add the function declaration to the appropriate lookup tables,
12968   // adjusting the redeclarations list as necessary.  We don't
12969   // want to do this yet if the friending class is dependent.
12970   //
12971   // Also update the scope-based lookup if the target context's
12972   // lookup context is in lexical scope.
12973   if (!CurContext->isDependentContext()) {
12974     DC = DC->getRedeclContext();
12975     DC->makeDeclVisibleInContext(ND);
12976     if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
12977       PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
12978   }
12979 
12980   FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
12981                                        D.getIdentifierLoc(), ND,
12982                                        DS.getFriendSpecLoc());
12983   FrD->setAccess(AS_public);
12984   CurContext->addDecl(FrD);
12985 
12986   if (ND->isInvalidDecl()) {
12987     FrD->setInvalidDecl();
12988   } else {
12989     if (DC->isRecord()) CheckFriendAccess(ND);
12990 
12991     FunctionDecl *FD;
12992     if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
12993       FD = FTD->getTemplatedDecl();
12994     else
12995       FD = cast<FunctionDecl>(ND);
12996 
12997     // C++11 [dcl.fct.default]p4: If a friend declaration specifies a
12998     // default argument expression, that declaration shall be a definition
12999     // and shall be the only declaration of the function or function
13000     // template in the translation unit.
13001     if (functionDeclHasDefaultArgument(FD)) {
13002       if (FunctionDecl *OldFD = FD->getPreviousDecl()) {
13003         Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
13004         Diag(OldFD->getLocation(), diag::note_previous_declaration);
13005       } else if (!D.isFunctionDefinition())
13006         Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_must_be_def);
13007     }
13008 
13009     // Mark templated-scope function declarations as unsupported.
13010     if (FD->getNumTemplateParameterLists() && SS.isValid()) {
13011       Diag(FD->getLocation(), diag::warn_template_qualified_friend_unsupported)
13012         << SS.getScopeRep() << SS.getRange()
13013         << cast<CXXRecordDecl>(CurContext);
13014       FrD->setUnsupportedFriend(true);
13015     }
13016   }
13017 
13018   return ND;
13019 }
13020 
SetDeclDeleted(Decl * Dcl,SourceLocation DelLoc)13021 void Sema::SetDeclDeleted(Decl *Dcl, SourceLocation DelLoc) {
13022   AdjustDeclIfTemplate(Dcl);
13023 
13024   FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Dcl);
13025   if (!Fn) {
13026     Diag(DelLoc, diag::err_deleted_non_function);
13027     return;
13028   }
13029 
13030   if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
13031     // Don't consider the implicit declaration we generate for explicit
13032     // specializations. FIXME: Do not generate these implicit declarations.
13033     if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization ||
13034          Prev->getPreviousDecl()) &&
13035         !Prev->isDefined()) {
13036       Diag(DelLoc, diag::err_deleted_decl_not_first);
13037       Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
13038            Prev->isImplicit() ? diag::note_previous_implicit_declaration
13039                               : diag::note_previous_declaration);
13040     }
13041     // If the declaration wasn't the first, we delete the function anyway for
13042     // recovery.
13043     Fn = Fn->getCanonicalDecl();
13044   }
13045 
13046   // dllimport/dllexport cannot be deleted.
13047   if (const InheritableAttr *DLLAttr = getDLLAttr(Fn)) {
13048     Diag(Fn->getLocation(), diag::err_attribute_dll_deleted) << DLLAttr;
13049     Fn->setInvalidDecl();
13050   }
13051 
13052   if (Fn->isDeleted())
13053     return;
13054 
13055   // See if we're deleting a function which is already known to override a
13056   // non-deleted virtual function.
13057   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn)) {
13058     bool IssuedDiagnostic = false;
13059     for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
13060                                         E = MD->end_overridden_methods();
13061          I != E; ++I) {
13062       if (!(*MD->begin_overridden_methods())->isDeleted()) {
13063         if (!IssuedDiagnostic) {
13064           Diag(DelLoc, diag::err_deleted_override) << MD->getDeclName();
13065           IssuedDiagnostic = true;
13066         }
13067         Diag((*I)->getLocation(), diag::note_overridden_virtual_function);
13068       }
13069     }
13070   }
13071 
13072   // C++11 [basic.start.main]p3:
13073   //   A program that defines main as deleted [...] is ill-formed.
13074   if (Fn->isMain())
13075     Diag(DelLoc, diag::err_deleted_main);
13076 
13077   Fn->setDeletedAsWritten();
13078 }
13079 
SetDeclDefaulted(Decl * Dcl,SourceLocation DefaultLoc)13080 void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) {
13081   CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Dcl);
13082 
13083   if (MD) {
13084     if (MD->getParent()->isDependentType()) {
13085       MD->setDefaulted();
13086       MD->setExplicitlyDefaulted();
13087       return;
13088     }
13089 
13090     CXXSpecialMember Member = getSpecialMember(MD);
13091     if (Member == CXXInvalid) {
13092       if (!MD->isInvalidDecl())
13093         Diag(DefaultLoc, diag::err_default_special_members);
13094       return;
13095     }
13096 
13097     MD->setDefaulted();
13098     MD->setExplicitlyDefaulted();
13099 
13100     // If this definition appears within the record, do the checking when
13101     // the record is complete.
13102     const FunctionDecl *Primary = MD;
13103     if (const FunctionDecl *Pattern = MD->getTemplateInstantiationPattern())
13104       // Ask the template instantiation pattern that actually had the
13105       // '= default' on it.
13106       Primary = Pattern;
13107 
13108     // If the method was defaulted on its first declaration, we will have
13109     // already performed the checking in CheckCompletedCXXClass. Such a
13110     // declaration doesn't trigger an implicit definition.
13111     if (Primary->getCanonicalDecl()->isDefaulted())
13112       return;
13113 
13114     CheckExplicitlyDefaultedSpecialMember(MD);
13115 
13116     if (!MD->isInvalidDecl())
13117       DefineImplicitSpecialMember(*this, MD, DefaultLoc);
13118   } else {
13119     Diag(DefaultLoc, diag::err_default_special_members);
13120   }
13121 }
13122 
SearchForReturnInStmt(Sema & Self,Stmt * S)13123 static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
13124   for (Stmt *SubStmt : S->children()) {
13125     if (!SubStmt)
13126       continue;
13127     if (isa<ReturnStmt>(SubStmt))
13128       Self.Diag(SubStmt->getLocStart(),
13129            diag::err_return_in_constructor_handler);
13130     if (!isa<Expr>(SubStmt))
13131       SearchForReturnInStmt(Self, SubStmt);
13132   }
13133 }
13134 
DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt * TryBlock)13135 void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
13136   for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
13137     CXXCatchStmt *Handler = TryBlock->getHandler(I);
13138     SearchForReturnInStmt(*this, Handler);
13139   }
13140 }
13141 
CheckOverridingFunctionAttributes(const CXXMethodDecl * New,const CXXMethodDecl * Old)13142 bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
13143                                              const CXXMethodDecl *Old) {
13144   const FunctionType *NewFT = New->getType()->getAs<FunctionType>();
13145   const FunctionType *OldFT = Old->getType()->getAs<FunctionType>();
13146 
13147   CallingConv NewCC = NewFT->getCallConv(), OldCC = OldFT->getCallConv();
13148 
13149   // If the calling conventions match, everything is fine
13150   if (NewCC == OldCC)
13151     return false;
13152 
13153   // If the calling conventions mismatch because the new function is static,
13154   // suppress the calling convention mismatch error; the error about static
13155   // function override (err_static_overrides_virtual from
13156   // Sema::CheckFunctionDeclaration) is more clear.
13157   if (New->getStorageClass() == SC_Static)
13158     return false;
13159 
13160   Diag(New->getLocation(),
13161        diag::err_conflicting_overriding_cc_attributes)
13162     << New->getDeclName() << New->getType() << Old->getType();
13163   Diag(Old->getLocation(), diag::note_overridden_virtual_function);
13164   return true;
13165 }
13166 
CheckOverridingFunctionReturnType(const CXXMethodDecl * New,const CXXMethodDecl * Old)13167 bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
13168                                              const CXXMethodDecl *Old) {
13169   QualType NewTy = New->getType()->getAs<FunctionType>()->getReturnType();
13170   QualType OldTy = Old->getType()->getAs<FunctionType>()->getReturnType();
13171 
13172   if (Context.hasSameType(NewTy, OldTy) ||
13173       NewTy->isDependentType() || OldTy->isDependentType())
13174     return false;
13175 
13176   // Check if the return types are covariant
13177   QualType NewClassTy, OldClassTy;
13178 
13179   /// Both types must be pointers or references to classes.
13180   if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
13181     if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
13182       NewClassTy = NewPT->getPointeeType();
13183       OldClassTy = OldPT->getPointeeType();
13184     }
13185   } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
13186     if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
13187       if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
13188         NewClassTy = NewRT->getPointeeType();
13189         OldClassTy = OldRT->getPointeeType();
13190       }
13191     }
13192   }
13193 
13194   // The return types aren't either both pointers or references to a class type.
13195   if (NewClassTy.isNull()) {
13196     Diag(New->getLocation(),
13197          diag::err_different_return_type_for_overriding_virtual_function)
13198         << New->getDeclName() << NewTy << OldTy
13199         << New->getReturnTypeSourceRange();
13200     Diag(Old->getLocation(), diag::note_overridden_virtual_function)
13201         << Old->getReturnTypeSourceRange();
13202 
13203     return true;
13204   }
13205 
13206   if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
13207     // C++14 [class.virtual]p8:
13208     //   If the class type in the covariant return type of D::f differs from
13209     //   that of B::f, the class type in the return type of D::f shall be
13210     //   complete at the point of declaration of D::f or shall be the class
13211     //   type D.
13212     if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
13213       if (!RT->isBeingDefined() &&
13214           RequireCompleteType(New->getLocation(), NewClassTy,
13215                               diag::err_covariant_return_incomplete,
13216                               New->getDeclName()))
13217         return true;
13218     }
13219 
13220     // Check if the new class derives from the old class.
13221     if (!IsDerivedFrom(New->getLocation(), NewClassTy, OldClassTy)) {
13222       Diag(New->getLocation(), diag::err_covariant_return_not_derived)
13223           << New->getDeclName() << NewTy << OldTy
13224           << New->getReturnTypeSourceRange();
13225       Diag(Old->getLocation(), diag::note_overridden_virtual_function)
13226           << Old->getReturnTypeSourceRange();
13227       return true;
13228     }
13229 
13230     // Check if we the conversion from derived to base is valid.
13231     if (CheckDerivedToBaseConversion(
13232             NewClassTy, OldClassTy,
13233             diag::err_covariant_return_inaccessible_base,
13234             diag::err_covariant_return_ambiguous_derived_to_base_conv,
13235             New->getLocation(), New->getReturnTypeSourceRange(),
13236             New->getDeclName(), nullptr)) {
13237       // FIXME: this note won't trigger for delayed access control
13238       // diagnostics, and it's impossible to get an undelayed error
13239       // here from access control during the original parse because
13240       // the ParsingDeclSpec/ParsingDeclarator are still in scope.
13241       Diag(Old->getLocation(), diag::note_overridden_virtual_function)
13242           << Old->getReturnTypeSourceRange();
13243       return true;
13244     }
13245   }
13246 
13247   // The qualifiers of the return types must be the same.
13248   if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
13249     Diag(New->getLocation(),
13250          diag::err_covariant_return_type_different_qualifications)
13251         << New->getDeclName() << NewTy << OldTy
13252         << New->getReturnTypeSourceRange();
13253     Diag(Old->getLocation(), diag::note_overridden_virtual_function)
13254         << Old->getReturnTypeSourceRange();
13255     return true;
13256   }
13257 
13258 
13259   // The new class type must have the same or less qualifiers as the old type.
13260   if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
13261     Diag(New->getLocation(),
13262          diag::err_covariant_return_type_class_type_more_qualified)
13263         << New->getDeclName() << NewTy << OldTy
13264         << New->getReturnTypeSourceRange();
13265     Diag(Old->getLocation(), diag::note_overridden_virtual_function)
13266         << Old->getReturnTypeSourceRange();
13267     return true;
13268   }
13269 
13270   return false;
13271 }
13272 
13273 /// \brief Mark the given method pure.
13274 ///
13275 /// \param Method the method to be marked pure.
13276 ///
13277 /// \param InitRange the source range that covers the "0" initializer.
CheckPureMethod(CXXMethodDecl * Method,SourceRange InitRange)13278 bool Sema::CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange) {
13279   SourceLocation EndLoc = InitRange.getEnd();
13280   if (EndLoc.isValid())
13281     Method->setRangeEnd(EndLoc);
13282 
13283   if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
13284     Method->setPure();
13285     return false;
13286   }
13287 
13288   if (!Method->isInvalidDecl())
13289     Diag(Method->getLocation(), diag::err_non_virtual_pure)
13290       << Method->getDeclName() << InitRange;
13291   return true;
13292 }
13293 
ActOnPureSpecifier(Decl * D,SourceLocation ZeroLoc)13294 void Sema::ActOnPureSpecifier(Decl *D, SourceLocation ZeroLoc) {
13295   if (D->getFriendObjectKind())
13296     Diag(D->getLocation(), diag::err_pure_friend);
13297   else if (auto *M = dyn_cast<CXXMethodDecl>(D))
13298     CheckPureMethod(M, ZeroLoc);
13299   else
13300     Diag(D->getLocation(), diag::err_illegal_initializer);
13301 }
13302 
13303 /// \brief Determine whether the given declaration is a static data member.
isStaticDataMember(const Decl * D)13304 static bool isStaticDataMember(const Decl *D) {
13305   if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(D))
13306     return Var->isStaticDataMember();
13307 
13308   return false;
13309 }
13310 
13311 /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse
13312 /// an initializer for the out-of-line declaration 'Dcl'.  The scope
13313 /// is a fresh scope pushed for just this purpose.
13314 ///
13315 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
13316 /// static data member of class X, names should be looked up in the scope of
13317 /// class X.
ActOnCXXEnterDeclInitializer(Scope * S,Decl * D)13318 void Sema::ActOnCXXEnterDeclInitializer(Scope *S, Decl *D) {
13319   // If there is no declaration, there was an error parsing it.
13320   if (!D || D->isInvalidDecl())
13321     return;
13322 
13323   // We will always have a nested name specifier here, but this declaration
13324   // might not be out of line if the specifier names the current namespace:
13325   //   extern int n;
13326   //   int ::n = 0;
13327   if (D->isOutOfLine())
13328     EnterDeclaratorContext(S, D->getDeclContext());
13329 
13330   // If we are parsing the initializer for a static data member, push a
13331   // new expression evaluation context that is associated with this static
13332   // data member.
13333   if (isStaticDataMember(D))
13334     PushExpressionEvaluationContext(PotentiallyEvaluated, D);
13335 }
13336 
13337 /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
13338 /// initializer for the out-of-line declaration 'D'.
ActOnCXXExitDeclInitializer(Scope * S,Decl * D)13339 void Sema::ActOnCXXExitDeclInitializer(Scope *S, Decl *D) {
13340   // If there is no declaration, there was an error parsing it.
13341   if (!D || D->isInvalidDecl())
13342     return;
13343 
13344   if (isStaticDataMember(D))
13345     PopExpressionEvaluationContext();
13346 
13347   if (D->isOutOfLine())
13348     ExitDeclaratorContext(S);
13349 }
13350 
13351 /// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
13352 /// C++ if/switch/while/for statement.
13353 /// e.g: "if (int x = f()) {...}"
ActOnCXXConditionDeclaration(Scope * S,Declarator & D)13354 DeclResult Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {
13355   // C++ 6.4p2:
13356   // The declarator shall not specify a function or an array.
13357   // The type-specifier-seq shall not contain typedef and shall not declare a
13358   // new class or enumeration.
13359   assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
13360          "Parser allowed 'typedef' as storage class of condition decl.");
13361 
13362   Decl *Dcl = ActOnDeclarator(S, D);
13363   if (!Dcl)
13364     return true;
13365 
13366   if (isa<FunctionDecl>(Dcl)) { // The declarator shall not specify a function.
13367     Diag(Dcl->getLocation(), diag::err_invalid_use_of_function_type)
13368       << D.getSourceRange();
13369     return true;
13370   }
13371 
13372   return Dcl;
13373 }
13374 
LoadExternalVTableUses()13375 void Sema::LoadExternalVTableUses() {
13376   if (!ExternalSource)
13377     return;
13378 
13379   SmallVector<ExternalVTableUse, 4> VTables;
13380   ExternalSource->ReadUsedVTables(VTables);
13381   SmallVector<VTableUse, 4> NewUses;
13382   for (unsigned I = 0, N = VTables.size(); I != N; ++I) {
13383     llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
13384       = VTablesUsed.find(VTables[I].Record);
13385     // Even if a definition wasn't required before, it may be required now.
13386     if (Pos != VTablesUsed.end()) {
13387       if (!Pos->second && VTables[I].DefinitionRequired)
13388         Pos->second = true;
13389       continue;
13390     }
13391 
13392     VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
13393     NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location));
13394   }
13395 
13396   VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end());
13397 }
13398 
MarkVTableUsed(SourceLocation Loc,CXXRecordDecl * Class,bool DefinitionRequired)13399 void Sema::MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
13400                           bool DefinitionRequired) {
13401   // Ignore any vtable uses in unevaluated operands or for classes that do
13402   // not have a vtable.
13403   if (!Class->isDynamicClass() || Class->isDependentContext() ||
13404       CurContext->isDependentContext() || isUnevaluatedContext())
13405     return;
13406 
13407   // Try to insert this class into the map.
13408   LoadExternalVTableUses();
13409   Class = cast<CXXRecordDecl>(Class->getCanonicalDecl());
13410   std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator, bool>
13411     Pos = VTablesUsed.insert(std::make_pair(Class, DefinitionRequired));
13412   if (!Pos.second) {
13413     // If we already had an entry, check to see if we are promoting this vtable
13414     // to require a definition. If so, we need to reappend to the VTableUses
13415     // list, since we may have already processed the first entry.
13416     if (DefinitionRequired && !Pos.first->second) {
13417       Pos.first->second = true;
13418     } else {
13419       // Otherwise, we can early exit.
13420       return;
13421     }
13422   } else {
13423     // The Microsoft ABI requires that we perform the destructor body
13424     // checks (i.e. operator delete() lookup) when the vtable is marked used, as
13425     // the deleting destructor is emitted with the vtable, not with the
13426     // destructor definition as in the Itanium ABI.
13427     if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
13428       CXXDestructorDecl *DD = Class->getDestructor();
13429       if (DD && DD->isVirtual() && !DD->isDeleted()) {
13430         if (Class->hasUserDeclaredDestructor() && !DD->isDefined()) {
13431           // If this is an out-of-line declaration, marking it referenced will
13432           // not do anything. Manually call CheckDestructor to look up operator
13433           // delete().
13434           ContextRAII SavedContext(*this, DD);
13435           CheckDestructor(DD);
13436         } else {
13437           MarkFunctionReferenced(Loc, Class->getDestructor());
13438         }
13439       }
13440     }
13441   }
13442 
13443   // Local classes need to have their virtual members marked
13444   // immediately. For all other classes, we mark their virtual members
13445   // at the end of the translation unit.
13446   if (Class->isLocalClass())
13447     MarkVirtualMembersReferenced(Loc, Class);
13448   else
13449     VTableUses.push_back(std::make_pair(Class, Loc));
13450 }
13451 
DefineUsedVTables()13452 bool Sema::DefineUsedVTables() {
13453   LoadExternalVTableUses();
13454   if (VTableUses.empty())
13455     return false;
13456 
13457   // Note: The VTableUses vector could grow as a result of marking
13458   // the members of a class as "used", so we check the size each
13459   // time through the loop and prefer indices (which are stable) to
13460   // iterators (which are not).
13461   bool DefinedAnything = false;
13462   for (unsigned I = 0; I != VTableUses.size(); ++I) {
13463     CXXRecordDecl *Class = VTableUses[I].first->getDefinition();
13464     if (!Class)
13465       continue;
13466 
13467     SourceLocation Loc = VTableUses[I].second;
13468 
13469     bool DefineVTable = true;
13470 
13471     // If this class has a key function, but that key function is
13472     // defined in another translation unit, we don't need to emit the
13473     // vtable even though we're using it.
13474     const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(Class);
13475     if (KeyFunction && !KeyFunction->hasBody()) {
13476       // The key function is in another translation unit.
13477       DefineVTable = false;
13478       TemplateSpecializationKind TSK =
13479           KeyFunction->getTemplateSpecializationKind();
13480       assert(TSK != TSK_ExplicitInstantiationDefinition &&
13481              TSK != TSK_ImplicitInstantiation &&
13482              "Instantiations don't have key functions");
13483       (void)TSK;
13484     } else if (!KeyFunction) {
13485       // If we have a class with no key function that is the subject
13486       // of an explicit instantiation declaration, suppress the
13487       // vtable; it will live with the explicit instantiation
13488       // definition.
13489       bool IsExplicitInstantiationDeclaration
13490         = Class->getTemplateSpecializationKind()
13491                                       == TSK_ExplicitInstantiationDeclaration;
13492       for (auto R : Class->redecls()) {
13493         TemplateSpecializationKind TSK
13494           = cast<CXXRecordDecl>(R)->getTemplateSpecializationKind();
13495         if (TSK == TSK_ExplicitInstantiationDeclaration)
13496           IsExplicitInstantiationDeclaration = true;
13497         else if (TSK == TSK_ExplicitInstantiationDefinition) {
13498           IsExplicitInstantiationDeclaration = false;
13499           break;
13500         }
13501       }
13502 
13503       if (IsExplicitInstantiationDeclaration)
13504         DefineVTable = false;
13505     }
13506 
13507     // The exception specifications for all virtual members may be needed even
13508     // if we are not providing an authoritative form of the vtable in this TU.
13509     // We may choose to emit it available_externally anyway.
13510     if (!DefineVTable) {
13511       MarkVirtualMemberExceptionSpecsNeeded(Loc, Class);
13512       continue;
13513     }
13514 
13515     // Mark all of the virtual members of this class as referenced, so
13516     // that we can build a vtable. Then, tell the AST consumer that a
13517     // vtable for this class is required.
13518     DefinedAnything = true;
13519     MarkVirtualMembersReferenced(Loc, Class);
13520     CXXRecordDecl *Canonical = cast<CXXRecordDecl>(Class->getCanonicalDecl());
13521     if (VTablesUsed[Canonical])
13522       Consumer.HandleVTable(Class);
13523 
13524     // Optionally warn if we're emitting a weak vtable.
13525     if (Class->isExternallyVisible() &&
13526         Class->getTemplateSpecializationKind() != TSK_ImplicitInstantiation) {
13527       const FunctionDecl *KeyFunctionDef = nullptr;
13528       if (!KeyFunction ||
13529           (KeyFunction->hasBody(KeyFunctionDef) &&
13530            KeyFunctionDef->isInlined()))
13531         Diag(Class->getLocation(), Class->getTemplateSpecializationKind() ==
13532              TSK_ExplicitInstantiationDefinition
13533              ? diag::warn_weak_template_vtable : diag::warn_weak_vtable)
13534           << Class;
13535     }
13536   }
13537   VTableUses.clear();
13538 
13539   return DefinedAnything;
13540 }
13541 
MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,const CXXRecordDecl * RD)13542 void Sema::MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
13543                                                  const CXXRecordDecl *RD) {
13544   for (const auto *I : RD->methods())
13545     if (I->isVirtual() && !I->isPure())
13546       ResolveExceptionSpec(Loc, I->getType()->castAs<FunctionProtoType>());
13547 }
13548 
MarkVirtualMembersReferenced(SourceLocation Loc,const CXXRecordDecl * RD)13549 void Sema::MarkVirtualMembersReferenced(SourceLocation Loc,
13550                                         const CXXRecordDecl *RD) {
13551   // Mark all functions which will appear in RD's vtable as used.
13552   CXXFinalOverriderMap FinalOverriders;
13553   RD->getFinalOverriders(FinalOverriders);
13554   for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
13555                                             E = FinalOverriders.end();
13556        I != E; ++I) {
13557     for (OverridingMethods::const_iterator OI = I->second.begin(),
13558                                            OE = I->second.end();
13559          OI != OE; ++OI) {
13560       assert(OI->second.size() > 0 && "no final overrider");
13561       CXXMethodDecl *Overrider = OI->second.front().Method;
13562 
13563       // C++ [basic.def.odr]p2:
13564       //   [...] A virtual member function is used if it is not pure. [...]
13565       if (!Overrider->isPure())
13566         MarkFunctionReferenced(Loc, Overrider);
13567     }
13568   }
13569 
13570   // Only classes that have virtual bases need a VTT.
13571   if (RD->getNumVBases() == 0)
13572     return;
13573 
13574   for (const auto &I : RD->bases()) {
13575     const CXXRecordDecl *Base =
13576         cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
13577     if (Base->getNumVBases() == 0)
13578       continue;
13579     MarkVirtualMembersReferenced(Loc, Base);
13580   }
13581 }
13582 
13583 /// SetIvarInitializers - This routine builds initialization ASTs for the
13584 /// Objective-C implementation whose ivars need be initialized.
SetIvarInitializers(ObjCImplementationDecl * ObjCImplementation)13585 void Sema::SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation) {
13586   if (!getLangOpts().CPlusPlus)
13587     return;
13588   if (ObjCInterfaceDecl *OID = ObjCImplementation->getClassInterface()) {
13589     SmallVector<ObjCIvarDecl*, 8> ivars;
13590     CollectIvarsToConstructOrDestruct(OID, ivars);
13591     if (ivars.empty())
13592       return;
13593     SmallVector<CXXCtorInitializer*, 32> AllToInit;
13594     for (unsigned i = 0; i < ivars.size(); i++) {
13595       FieldDecl *Field = ivars[i];
13596       if (Field->isInvalidDecl())
13597         continue;
13598 
13599       CXXCtorInitializer *Member;
13600       InitializedEntity InitEntity = InitializedEntity::InitializeMember(Field);
13601       InitializationKind InitKind =
13602         InitializationKind::CreateDefault(ObjCImplementation->getLocation());
13603 
13604       InitializationSequence InitSeq(*this, InitEntity, InitKind, None);
13605       ExprResult MemberInit =
13606         InitSeq.Perform(*this, InitEntity, InitKind, None);
13607       MemberInit = MaybeCreateExprWithCleanups(MemberInit);
13608       // Note, MemberInit could actually come back empty if no initialization
13609       // is required (e.g., because it would call a trivial default constructor)
13610       if (!MemberInit.get() || MemberInit.isInvalid())
13611         continue;
13612 
13613       Member =
13614         new (Context) CXXCtorInitializer(Context, Field, SourceLocation(),
13615                                          SourceLocation(),
13616                                          MemberInit.getAs<Expr>(),
13617                                          SourceLocation());
13618       AllToInit.push_back(Member);
13619 
13620       // Be sure that the destructor is accessible and is marked as referenced.
13621       if (const RecordType *RecordTy =
13622               Context.getBaseElementType(Field->getType())
13623                   ->getAs<RecordType>()) {
13624         CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
13625         if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
13626           MarkFunctionReferenced(Field->getLocation(), Destructor);
13627           CheckDestructorAccess(Field->getLocation(), Destructor,
13628                             PDiag(diag::err_access_dtor_ivar)
13629                               << Context.getBaseElementType(Field->getType()));
13630         }
13631       }
13632     }
13633     ObjCImplementation->setIvarInitializers(Context,
13634                                             AllToInit.data(), AllToInit.size());
13635   }
13636 }
13637 
13638 static
DelegatingCycleHelper(CXXConstructorDecl * Ctor,llvm::SmallSet<CXXConstructorDecl *,4> & Valid,llvm::SmallSet<CXXConstructorDecl *,4> & Invalid,llvm::SmallSet<CXXConstructorDecl *,4> & Current,Sema & S)13639 void DelegatingCycleHelper(CXXConstructorDecl* Ctor,
13640                            llvm::SmallSet<CXXConstructorDecl*, 4> &Valid,
13641                            llvm::SmallSet<CXXConstructorDecl*, 4> &Invalid,
13642                            llvm::SmallSet<CXXConstructorDecl*, 4> &Current,
13643                            Sema &S) {
13644   if (Ctor->isInvalidDecl())
13645     return;
13646 
13647   CXXConstructorDecl *Target = Ctor->getTargetConstructor();
13648 
13649   // Target may not be determinable yet, for instance if this is a dependent
13650   // call in an uninstantiated template.
13651   if (Target) {
13652     const FunctionDecl *FNTarget = nullptr;
13653     (void)Target->hasBody(FNTarget);
13654     Target = const_cast<CXXConstructorDecl*>(
13655       cast_or_null<CXXConstructorDecl>(FNTarget));
13656   }
13657 
13658   CXXConstructorDecl *Canonical = Ctor->getCanonicalDecl(),
13659                      // Avoid dereferencing a null pointer here.
13660                      *TCanonical = Target? Target->getCanonicalDecl() : nullptr;
13661 
13662   if (!Current.insert(Canonical).second)
13663     return;
13664 
13665   // We know that beyond here, we aren't chaining into a cycle.
13666   if (!Target || !Target->isDelegatingConstructor() ||
13667       Target->isInvalidDecl() || Valid.count(TCanonical)) {
13668     Valid.insert(Current.begin(), Current.end());
13669     Current.clear();
13670   // We've hit a cycle.
13671   } else if (TCanonical == Canonical || Invalid.count(TCanonical) ||
13672              Current.count(TCanonical)) {
13673     // If we haven't diagnosed this cycle yet, do so now.
13674     if (!Invalid.count(TCanonical)) {
13675       S.Diag((*Ctor->init_begin())->getSourceLocation(),
13676              diag::warn_delegating_ctor_cycle)
13677         << Ctor;
13678 
13679       // Don't add a note for a function delegating directly to itself.
13680       if (TCanonical != Canonical)
13681         S.Diag(Target->getLocation(), diag::note_it_delegates_to);
13682 
13683       CXXConstructorDecl *C = Target;
13684       while (C->getCanonicalDecl() != Canonical) {
13685         const FunctionDecl *FNTarget = nullptr;
13686         (void)C->getTargetConstructor()->hasBody(FNTarget);
13687         assert(FNTarget && "Ctor cycle through bodiless function");
13688 
13689         C = const_cast<CXXConstructorDecl*>(
13690           cast<CXXConstructorDecl>(FNTarget));
13691         S.Diag(C->getLocation(), diag::note_which_delegates_to);
13692       }
13693     }
13694 
13695     Invalid.insert(Current.begin(), Current.end());
13696     Current.clear();
13697   } else {
13698     DelegatingCycleHelper(Target, Valid, Invalid, Current, S);
13699   }
13700 }
13701 
13702 
CheckDelegatingCtorCycles()13703 void Sema::CheckDelegatingCtorCycles() {
13704   llvm::SmallSet<CXXConstructorDecl*, 4> Valid, Invalid, Current;
13705 
13706   for (DelegatingCtorDeclsType::iterator
13707          I = DelegatingCtorDecls.begin(ExternalSource),
13708          E = DelegatingCtorDecls.end();
13709        I != E; ++I)
13710     DelegatingCycleHelper(*I, Valid, Invalid, Current, *this);
13711 
13712   for (llvm::SmallSet<CXXConstructorDecl *, 4>::iterator CI = Invalid.begin(),
13713                                                          CE = Invalid.end();
13714        CI != CE; ++CI)
13715     (*CI)->setInvalidDecl();
13716 }
13717 
13718 namespace {
13719   /// \brief AST visitor that finds references to the 'this' expression.
13720   class FindCXXThisExpr : public RecursiveASTVisitor<FindCXXThisExpr> {
13721     Sema &S;
13722 
13723   public:
FindCXXThisExpr(Sema & S)13724     explicit FindCXXThisExpr(Sema &S) : S(S) { }
13725 
VisitCXXThisExpr(CXXThisExpr * E)13726     bool VisitCXXThisExpr(CXXThisExpr *E) {
13727       S.Diag(E->getLocation(), diag::err_this_static_member_func)
13728         << E->isImplicit();
13729       return false;
13730     }
13731   };
13732 }
13733 
checkThisInStaticMemberFunctionType(CXXMethodDecl * Method)13734 bool Sema::checkThisInStaticMemberFunctionType(CXXMethodDecl *Method) {
13735   TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
13736   if (!TSInfo)
13737     return false;
13738 
13739   TypeLoc TL = TSInfo->getTypeLoc();
13740   FunctionProtoTypeLoc ProtoTL = TL.getAs<FunctionProtoTypeLoc>();
13741   if (!ProtoTL)
13742     return false;
13743 
13744   // C++11 [expr.prim.general]p3:
13745   //   [The expression this] shall not appear before the optional
13746   //   cv-qualifier-seq and it shall not appear within the declaration of a
13747   //   static member function (although its type and value category are defined
13748   //   within a static member function as they are within a non-static member
13749   //   function). [ Note: this is because declaration matching does not occur
13750   //  until the complete declarator is known. - end note ]
13751   const FunctionProtoType *Proto = ProtoTL.getTypePtr();
13752   FindCXXThisExpr Finder(*this);
13753 
13754   // If the return type came after the cv-qualifier-seq, check it now.
13755   if (Proto->hasTrailingReturn() &&
13756       !Finder.TraverseTypeLoc(ProtoTL.getReturnLoc()))
13757     return true;
13758 
13759   // Check the exception specification.
13760   if (checkThisInStaticMemberFunctionExceptionSpec(Method))
13761     return true;
13762 
13763   return checkThisInStaticMemberFunctionAttributes(Method);
13764 }
13765 
checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl * Method)13766 bool Sema::checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method) {
13767   TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
13768   if (!TSInfo)
13769     return false;
13770 
13771   TypeLoc TL = TSInfo->getTypeLoc();
13772   FunctionProtoTypeLoc ProtoTL = TL.getAs<FunctionProtoTypeLoc>();
13773   if (!ProtoTL)
13774     return false;
13775 
13776   const FunctionProtoType *Proto = ProtoTL.getTypePtr();
13777   FindCXXThisExpr Finder(*this);
13778 
13779   switch (Proto->getExceptionSpecType()) {
13780   case EST_Unparsed:
13781   case EST_Uninstantiated:
13782   case EST_Unevaluated:
13783   case EST_BasicNoexcept:
13784   case EST_DynamicNone:
13785   case EST_MSAny:
13786   case EST_None:
13787     break;
13788 
13789   case EST_ComputedNoexcept:
13790     if (!Finder.TraverseStmt(Proto->getNoexceptExpr()))
13791       return true;
13792 
13793   case EST_Dynamic:
13794     for (const auto &E : Proto->exceptions()) {
13795       if (!Finder.TraverseType(E))
13796         return true;
13797     }
13798     break;
13799   }
13800 
13801   return false;
13802 }
13803 
checkThisInStaticMemberFunctionAttributes(CXXMethodDecl * Method)13804 bool Sema::checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method) {
13805   FindCXXThisExpr Finder(*this);
13806 
13807   // Check attributes.
13808   for (const auto *A : Method->attrs()) {
13809     // FIXME: This should be emitted by tblgen.
13810     Expr *Arg = nullptr;
13811     ArrayRef<Expr *> Args;
13812     if (const auto *G = dyn_cast<GuardedByAttr>(A))
13813       Arg = G->getArg();
13814     else if (const auto *G = dyn_cast<PtGuardedByAttr>(A))
13815       Arg = G->getArg();
13816     else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
13817       Args = llvm::makeArrayRef(AA->args_begin(), AA->args_size());
13818     else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
13819       Args = llvm::makeArrayRef(AB->args_begin(), AB->args_size());
13820     else if (const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
13821       Arg = ETLF->getSuccessValue();
13822       Args = llvm::makeArrayRef(ETLF->args_begin(), ETLF->args_size());
13823     } else if (const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
13824       Arg = STLF->getSuccessValue();
13825       Args = llvm::makeArrayRef(STLF->args_begin(), STLF->args_size());
13826     } else if (const auto *LR = dyn_cast<LockReturnedAttr>(A))
13827       Arg = LR->getArg();
13828     else if (const auto *LE = dyn_cast<LocksExcludedAttr>(A))
13829       Args = llvm::makeArrayRef(LE->args_begin(), LE->args_size());
13830     else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
13831       Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());
13832     else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
13833       Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
13834     else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
13835       Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
13836     else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
13837       Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());
13838 
13839     if (Arg && !Finder.TraverseStmt(Arg))
13840       return true;
13841 
13842     for (unsigned I = 0, N = Args.size(); I != N; ++I) {
13843       if (!Finder.TraverseStmt(Args[I]))
13844         return true;
13845     }
13846   }
13847 
13848   return false;
13849 }
13850 
checkExceptionSpecification(bool IsTopLevel,ExceptionSpecificationType EST,ArrayRef<ParsedType> DynamicExceptions,ArrayRef<SourceRange> DynamicExceptionRanges,Expr * NoexceptExpr,SmallVectorImpl<QualType> & Exceptions,FunctionProtoType::ExceptionSpecInfo & ESI)13851 void Sema::checkExceptionSpecification(
13852     bool IsTopLevel, ExceptionSpecificationType EST,
13853     ArrayRef<ParsedType> DynamicExceptions,
13854     ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr,
13855     SmallVectorImpl<QualType> &Exceptions,
13856     FunctionProtoType::ExceptionSpecInfo &ESI) {
13857   Exceptions.clear();
13858   ESI.Type = EST;
13859   if (EST == EST_Dynamic) {
13860     Exceptions.reserve(DynamicExceptions.size());
13861     for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
13862       // FIXME: Preserve type source info.
13863       QualType ET = GetTypeFromParser(DynamicExceptions[ei]);
13864 
13865       if (IsTopLevel) {
13866         SmallVector<UnexpandedParameterPack, 2> Unexpanded;
13867         collectUnexpandedParameterPacks(ET, Unexpanded);
13868         if (!Unexpanded.empty()) {
13869           DiagnoseUnexpandedParameterPacks(
13870               DynamicExceptionRanges[ei].getBegin(), UPPC_ExceptionType,
13871               Unexpanded);
13872           continue;
13873         }
13874       }
13875 
13876       // Check that the type is valid for an exception spec, and
13877       // drop it if not.
13878       if (!CheckSpecifiedExceptionType(ET, DynamicExceptionRanges[ei]))
13879         Exceptions.push_back(ET);
13880     }
13881     ESI.Exceptions = Exceptions;
13882     return;
13883   }
13884 
13885   if (EST == EST_ComputedNoexcept) {
13886     // If an error occurred, there's no expression here.
13887     if (NoexceptExpr) {
13888       assert((NoexceptExpr->isTypeDependent() ||
13889               NoexceptExpr->getType()->getCanonicalTypeUnqualified() ==
13890               Context.BoolTy) &&
13891              "Parser should have made sure that the expression is boolean");
13892       if (IsTopLevel && NoexceptExpr &&
13893           DiagnoseUnexpandedParameterPack(NoexceptExpr)) {
13894         ESI.Type = EST_BasicNoexcept;
13895         return;
13896       }
13897 
13898       if (!NoexceptExpr->isValueDependent())
13899         NoexceptExpr = VerifyIntegerConstantExpression(NoexceptExpr, nullptr,
13900                          diag::err_noexcept_needs_constant_expression,
13901                          /*AllowFold*/ false).get();
13902       ESI.NoexceptExpr = NoexceptExpr;
13903     }
13904     return;
13905   }
13906 }
13907 
actOnDelayedExceptionSpecification(Decl * MethodD,ExceptionSpecificationType EST,SourceRange SpecificationRange,ArrayRef<ParsedType> DynamicExceptions,ArrayRef<SourceRange> DynamicExceptionRanges,Expr * NoexceptExpr)13908 void Sema::actOnDelayedExceptionSpecification(Decl *MethodD,
13909              ExceptionSpecificationType EST,
13910              SourceRange SpecificationRange,
13911              ArrayRef<ParsedType> DynamicExceptions,
13912              ArrayRef<SourceRange> DynamicExceptionRanges,
13913              Expr *NoexceptExpr) {
13914   if (!MethodD)
13915     return;
13916 
13917   // Dig out the method we're referring to.
13918   if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(MethodD))
13919     MethodD = FunTmpl->getTemplatedDecl();
13920 
13921   CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(MethodD);
13922   if (!Method)
13923     return;
13924 
13925   // Check the exception specification.
13926   llvm::SmallVector<QualType, 4> Exceptions;
13927   FunctionProtoType::ExceptionSpecInfo ESI;
13928   checkExceptionSpecification(/*IsTopLevel*/true, EST, DynamicExceptions,
13929                               DynamicExceptionRanges, NoexceptExpr, Exceptions,
13930                               ESI);
13931 
13932   // Update the exception specification on the function type.
13933   Context.adjustExceptionSpec(Method, ESI, /*AsWritten*/true);
13934 
13935   if (Method->isStatic())
13936     checkThisInStaticMemberFunctionExceptionSpec(Method);
13937 
13938   if (Method->isVirtual()) {
13939     // Check overrides, which we previously had to delay.
13940     for (CXXMethodDecl::method_iterator O = Method->begin_overridden_methods(),
13941                                      OEnd = Method->end_overridden_methods();
13942          O != OEnd; ++O)
13943       CheckOverridingFunctionExceptionSpec(Method, *O);
13944   }
13945 }
13946 
13947 /// HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
13948 ///
HandleMSProperty(Scope * S,RecordDecl * Record,SourceLocation DeclStart,Declarator & D,Expr * BitWidth,InClassInitStyle InitStyle,AccessSpecifier AS,AttributeList * MSPropertyAttr)13949 MSPropertyDecl *Sema::HandleMSProperty(Scope *S, RecordDecl *Record,
13950                                        SourceLocation DeclStart,
13951                                        Declarator &D, Expr *BitWidth,
13952                                        InClassInitStyle InitStyle,
13953                                        AccessSpecifier AS,
13954                                        AttributeList *MSPropertyAttr) {
13955   IdentifierInfo *II = D.getIdentifier();
13956   if (!II) {
13957     Diag(DeclStart, diag::err_anonymous_property);
13958     return nullptr;
13959   }
13960   SourceLocation Loc = D.getIdentifierLoc();
13961 
13962   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
13963   QualType T = TInfo->getType();
13964   if (getLangOpts().CPlusPlus) {
13965     CheckExtraCXXDefaultArguments(D);
13966 
13967     if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
13968                                         UPPC_DataMemberType)) {
13969       D.setInvalidType();
13970       T = Context.IntTy;
13971       TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
13972     }
13973   }
13974 
13975   DiagnoseFunctionSpecifiers(D.getDeclSpec());
13976 
13977   if (D.getDeclSpec().isInlineSpecified())
13978     Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
13979         << getLangOpts().CPlusPlus1z;
13980   if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
13981     Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
13982          diag::err_invalid_thread)
13983       << DeclSpec::getSpecifierName(TSCS);
13984 
13985   // Check to see if this name was declared as a member previously
13986   NamedDecl *PrevDecl = nullptr;
13987   LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration);
13988   LookupName(Previous, S);
13989   switch (Previous.getResultKind()) {
13990   case LookupResult::Found:
13991   case LookupResult::FoundUnresolvedValue:
13992     PrevDecl = Previous.getAsSingle<NamedDecl>();
13993     break;
13994 
13995   case LookupResult::FoundOverloaded:
13996     PrevDecl = Previous.getRepresentativeDecl();
13997     break;
13998 
13999   case LookupResult::NotFound:
14000   case LookupResult::NotFoundInCurrentInstantiation:
14001   case LookupResult::Ambiguous:
14002     break;
14003   }
14004 
14005   if (PrevDecl && PrevDecl->isTemplateParameter()) {
14006     // Maybe we will complain about the shadowed template parameter.
14007     DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
14008     // Just pretend that we didn't see the previous declaration.
14009     PrevDecl = nullptr;
14010   }
14011 
14012   if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
14013     PrevDecl = nullptr;
14014 
14015   SourceLocation TSSL = D.getLocStart();
14016   const AttributeList::PropertyData &Data = MSPropertyAttr->getPropertyData();
14017   MSPropertyDecl *NewPD = MSPropertyDecl::Create(
14018       Context, Record, Loc, II, T, TInfo, TSSL, Data.GetterId, Data.SetterId);
14019   ProcessDeclAttributes(TUScope, NewPD, D);
14020   NewPD->setAccess(AS);
14021 
14022   if (NewPD->isInvalidDecl())
14023     Record->setInvalidDecl();
14024 
14025   if (D.getDeclSpec().isModulePrivateSpecified())
14026     NewPD->setModulePrivate();
14027 
14028   if (NewPD->isInvalidDecl() && PrevDecl) {
14029     // Don't introduce NewFD into scope; there's already something
14030     // with the same name in the same scope.
14031   } else if (II) {
14032     PushOnScopeChains(NewPD, S);
14033   } else
14034     Record->addDecl(NewPD);
14035 
14036   return NewPD;
14037 }
14038