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__anon3b64c2cb0411::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__anon3b64c2cb0411::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__anon3b64c2cb0411::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__anon3b64c2cb0411::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__anon3b64c2cb0411::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__anon3b64c2cb0611::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__anon3b64c2cb0611::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__anon3b64c2cb0611::CheckAbstractUsage4509 CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
4510 : Info(Info), Ctx(Ctx) {}
4511
Visit__anon3b64c2cb0611::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__anon3b64c2cb0611::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__anon3b64c2cb0611::CheckAbstractUsage4532 void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) {
4533 Visit(TL.getElementLoc(), Sema::AbstractArrayType);
4534 }
4535
Check__anon3b64c2cb0611::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__anon3b64c2cb0611::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__anon3b64c2cb0711::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__anon3b64c2cb0711::SpecialMemberDeletionInfo5614 bool inUnion() const { return MD->getParent()->isUnion(); }
5615
getEffectiveCSM__anon3b64c2cb0711::SpecialMemberDeletionInfo5616 Sema::CXXSpecialMember getEffectiveCSM() {
5617 return ICI ? Sema::CXXInvalid : CSM;
5618 }
5619
5620 /// Look up the corresponding special member in the given class.
lookupIn__anon3b64c2cb0711::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__anon3b64c2cb0811::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 ()__anon3b64c2cb0811::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__anon3b64c2cb1011::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__anon3b64c2cb1011::DeclaringSpecialMember9105 ~DeclaringSpecialMember() {
9106 if (!WasAlreadyBeingDeclared)
9107 S.SpecialMembersBeingDeclared.erase(D);
9108 }
9109
9110 /// \brief Are we already trying to declare this special member?
isAlreadyBeingDeclared__anon3b64c2cb1011::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