clang 20.0.0git
SemaDeclCXX.cpp
Go to the documentation of this file.
1//===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements semantic analysis for C++ declarations.
10//
11//===----------------------------------------------------------------------===//
12
17#include "clang/AST/CharUnits.h"
19#include "clang/AST/DeclCXX.h"
23#include "clang/AST/Expr.h"
24#include "clang/AST/ExprCXX.h"
27#include "clang/AST/TypeLoc.h"
36#include "clang/Sema/DeclSpec.h"
39#include "clang/Sema/Lookup.h"
42#include "clang/Sema/Scope.h"
44#include "clang/Sema/SemaCUDA.h"
46#include "clang/Sema/SemaObjC.h"
48#include "clang/Sema/Template.h"
49#include "llvm/ADT/ArrayRef.h"
50#include "llvm/ADT/STLExtras.h"
51#include "llvm/ADT/STLForwardCompat.h"
52#include "llvm/ADT/StringExtras.h"
53#include "llvm/Support/ConvertUTF.h"
54#include "llvm/Support/SaveAndRestore.h"
55#include <map>
56#include <optional>
57#include <set>
58
59using namespace clang;
60
61//===----------------------------------------------------------------------===//
62// CheckDefaultArgumentVisitor
63//===----------------------------------------------------------------------===//
64
65namespace {
66/// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
67/// the default argument of a parameter to determine whether it
68/// contains any ill-formed subexpressions. For example, this will
69/// diagnose the use of local variables or parameters within the
70/// default argument expression.
71class CheckDefaultArgumentVisitor
72 : public ConstStmtVisitor<CheckDefaultArgumentVisitor, bool> {
73 Sema &S;
74 const Expr *DefaultArg;
75
76public:
77 CheckDefaultArgumentVisitor(Sema &S, const Expr *DefaultArg)
78 : S(S), DefaultArg(DefaultArg) {}
79
80 bool VisitExpr(const Expr *Node);
81 bool VisitDeclRefExpr(const DeclRefExpr *DRE);
82 bool VisitCXXThisExpr(const CXXThisExpr *ThisE);
83 bool VisitLambdaExpr(const LambdaExpr *Lambda);
84 bool VisitPseudoObjectExpr(const PseudoObjectExpr *POE);
85};
86
87/// VisitExpr - Visit all of the children of this expression.
88bool CheckDefaultArgumentVisitor::VisitExpr(const Expr *Node) {
89 bool IsInvalid = false;
90 for (const Stmt *SubStmt : Node->children())
91 if (SubStmt)
92 IsInvalid |= Visit(SubStmt);
93 return IsInvalid;
94}
95
96/// VisitDeclRefExpr - Visit a reference to a declaration, to
97/// determine whether this declaration can be used in the default
98/// argument expression.
99bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(const DeclRefExpr *DRE) {
100 const ValueDecl *Decl = dyn_cast<ValueDecl>(DRE->getDecl());
101
102 if (!isa<VarDecl, BindingDecl>(Decl))
103 return false;
104
105 if (const auto *Param = dyn_cast<ParmVarDecl>(Decl)) {
106 // C++ [dcl.fct.default]p9:
107 // [...] parameters of a function shall not be used in default
108 // argument expressions, even if they are not evaluated. [...]
109 //
110 // C++17 [dcl.fct.default]p9 (by CWG 2082):
111 // [...] A parameter shall not appear as a potentially-evaluated
112 // expression in a default argument. [...]
113 //
114 if (DRE->isNonOdrUse() != NOUR_Unevaluated)
115 return S.Diag(DRE->getBeginLoc(),
116 diag::err_param_default_argument_references_param)
117 << Param->getDeclName() << DefaultArg->getSourceRange();
118 } else if (auto *VD = Decl->getPotentiallyDecomposedVarDecl()) {
119 // C++ [dcl.fct.default]p7:
120 // Local variables shall not be used in default argument
121 // expressions.
122 //
123 // C++17 [dcl.fct.default]p7 (by CWG 2082):
124 // A local variable shall not appear as a potentially-evaluated
125 // expression in a default argument.
126 //
127 // C++20 [dcl.fct.default]p7 (DR as part of P0588R1, see also CWG 2346):
128 // Note: A local variable cannot be odr-used (6.3) in a default
129 // argument.
130 //
131 if (VD->isLocalVarDecl() && !DRE->isNonOdrUse())
132 return S.Diag(DRE->getBeginLoc(),
133 diag::err_param_default_argument_references_local)
134 << Decl << DefaultArg->getSourceRange();
135 }
136 return false;
137}
138
139/// VisitCXXThisExpr - Visit a C++ "this" expression.
140bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(const CXXThisExpr *ThisE) {
141 // C++ [dcl.fct.default]p8:
142 // The keyword this shall not be used in a default argument of a
143 // member function.
144 return S.Diag(ThisE->getBeginLoc(),
145 diag::err_param_default_argument_references_this)
146 << ThisE->getSourceRange();
147}
148
149bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(
150 const PseudoObjectExpr *POE) {
151 bool Invalid = false;
152 for (const Expr *E : POE->semantics()) {
153 // Look through bindings.
154 if (const auto *OVE = dyn_cast<OpaqueValueExpr>(E)) {
155 E = OVE->getSourceExpr();
156 assert(E && "pseudo-object binding without source expression?");
157 }
158
159 Invalid |= Visit(E);
160 }
161 return Invalid;
162}
163
164bool CheckDefaultArgumentVisitor::VisitLambdaExpr(const LambdaExpr *Lambda) {
165 // [expr.prim.lambda.capture]p9
166 // a lambda-expression appearing in a default argument cannot implicitly or
167 // explicitly capture any local entity. Such a lambda-expression can still
168 // have an init-capture if any full-expression in its initializer satisfies
169 // the constraints of an expression appearing in a default argument.
170 bool Invalid = false;
171 for (const LambdaCapture &LC : Lambda->captures()) {
172 if (!Lambda->isInitCapture(&LC))
173 return S.Diag(LC.getLocation(), diag::err_lambda_capture_default_arg);
174 // Init captures are always VarDecl.
175 auto *D = cast<VarDecl>(LC.getCapturedVar());
176 Invalid |= Visit(D->getInit());
177 }
178 return Invalid;
179}
180} // namespace
181
182void
184 const CXXMethodDecl *Method) {
185 // If we have an MSAny spec already, don't bother.
186 if (!Method || ComputedEST == EST_MSAny)
187 return;
188
189 const FunctionProtoType *Proto
190 = Method->getType()->getAs<FunctionProtoType>();
191 Proto = Self->ResolveExceptionSpec(CallLoc, Proto);
192 if (!Proto)
193 return;
194
196
197 // If we have a throw-all spec at this point, ignore the function.
198 if (ComputedEST == EST_None)
199 return;
200
201 if (EST == EST_None && Method->hasAttr<NoThrowAttr>())
202 EST = EST_BasicNoexcept;
203
204 switch (EST) {
205 case EST_Unparsed:
207 case EST_Unevaluated:
208 llvm_unreachable("should not see unresolved exception specs here");
209
210 // If this function can throw any exceptions, make a note of that.
211 case EST_MSAny:
212 case EST_None:
213 // FIXME: Whichever we see last of MSAny and None determines our result.
214 // We should make a consistent, order-independent choice here.
215 ClearExceptions();
216 ComputedEST = EST;
217 return;
219 ClearExceptions();
220 ComputedEST = EST_None;
221 return;
222 // FIXME: If the call to this decl is using any of its default arguments, we
223 // need to search them for potentially-throwing calls.
224 // If this function has a basic noexcept, it doesn't affect the outcome.
226 case EST_NoexceptTrue:
227 case EST_NoThrow:
228 return;
229 // If we're still at noexcept(true) and there's a throw() callee,
230 // change to that specification.
231 case EST_DynamicNone:
232 if (ComputedEST == EST_BasicNoexcept)
233 ComputedEST = EST_DynamicNone;
234 return;
236 llvm_unreachable(
237 "should not generate implicit declarations for dependent cases");
238 case EST_Dynamic:
239 break;
240 }
241 assert(EST == EST_Dynamic && "EST case not considered earlier.");
242 assert(ComputedEST != EST_None &&
243 "Shouldn't collect exceptions when throw-all is guaranteed.");
244 ComputedEST = EST_Dynamic;
245 // Record the exceptions in this function's exception specification.
246 for (const auto &E : Proto->exceptions())
247 if (ExceptionsSeen.insert(Self->Context.getCanonicalType(E)).second)
248 Exceptions.push_back(E);
249}
250
252 if (!S || ComputedEST == EST_MSAny)
253 return;
254
255 // FIXME:
256 //
257 // C++0x [except.spec]p14:
258 // [An] implicit exception-specification specifies the type-id T if and
259 // only if T is allowed by the exception-specification of a function directly
260 // invoked by f's implicit definition; f shall allow all exceptions if any
261 // function it directly invokes allows all exceptions, and f shall allow no
262 // exceptions if every function it directly invokes allows no exceptions.
263 //
264 // Note in particular that if an implicit exception-specification is generated
265 // for a function containing a throw-expression, that specification can still
266 // be noexcept(true).
267 //
268 // Note also that 'directly invoked' is not defined in the standard, and there
269 // is no indication that we should only consider potentially-evaluated calls.
270 //
271 // Ultimately we should implement the intent of the standard: the exception
272 // specification should be the set of exceptions which can be thrown by the
273 // implicit definition. For now, we assume that any non-nothrow expression can
274 // throw any exception.
275
276 if (Self->canThrow(S))
277 ComputedEST = EST_None;
278}
279
281 SourceLocation EqualLoc) {
282 if (RequireCompleteType(Param->getLocation(), Param->getType(),
283 diag::err_typecheck_decl_incomplete_type))
284 return true;
285
286 // C++ [dcl.fct.default]p5
287 // A default argument expression is implicitly converted (clause
288 // 4) to the parameter type. The default argument expression has
289 // the same semantic constraints as the initializer expression in
290 // a declaration of a variable of the parameter type, using the
291 // copy-initialization semantics (8.5).
293 Param);
295 EqualLoc);
296 InitializationSequence InitSeq(*this, Entity, Kind, Arg);
297 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg);
298 if (Result.isInvalid())
299 return true;
300 Arg = Result.getAs<Expr>();
301
302 CheckCompletedExpr(Arg, EqualLoc);
304
305 return Arg;
306}
307
309 SourceLocation EqualLoc) {
310 // Add the default argument to the parameter
311 Param->setDefaultArg(Arg);
312
313 // We have already instantiated this parameter; provide each of the
314 // instantiations with the uninstantiated default argument.
315 UnparsedDefaultArgInstantiationsMap::iterator InstPos
317 if (InstPos != UnparsedDefaultArgInstantiations.end()) {
318 for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
319 InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
320
321 // We're done tracking this parameter's instantiations.
323 }
324}
325
326void
328 Expr *DefaultArg) {
329 if (!param || !DefaultArg)
330 return;
331
332 ParmVarDecl *Param = cast<ParmVarDecl>(param);
333 UnparsedDefaultArgLocs.erase(Param);
334
335 // Default arguments are only permitted in C++
336 if (!getLangOpts().CPlusPlus) {
337 Diag(EqualLoc, diag::err_param_default_argument)
338 << DefaultArg->getSourceRange();
339 return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);
340 }
341
342 // Check for unexpanded parameter packs.
344 return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);
345
346 // C++11 [dcl.fct.default]p3
347 // A default argument expression [...] shall not be specified for a
348 // parameter pack.
349 if (Param->isParameterPack()) {
350 Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
351 << DefaultArg->getSourceRange();
352 // Recover by discarding the default argument.
353 Param->setDefaultArg(nullptr);
354 return;
355 }
356
357 ExprResult Result = ConvertParamDefaultArgument(Param, DefaultArg, EqualLoc);
358 if (Result.isInvalid())
359 return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);
360
361 DefaultArg = Result.getAs<Expr>();
362
363 // Check that the default argument is well-formed
364 CheckDefaultArgumentVisitor DefaultArgChecker(*this, DefaultArg);
365 if (DefaultArgChecker.Visit(DefaultArg))
366 return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);
367
368 SetParamDefaultArgument(Param, DefaultArg, EqualLoc);
369}
370
372 SourceLocation EqualLoc,
373 SourceLocation ArgLoc) {
374 if (!param)
375 return;
376
377 ParmVarDecl *Param = cast<ParmVarDecl>(param);
378 Param->setUnparsedDefaultArg();
379 UnparsedDefaultArgLocs[Param] = ArgLoc;
380}
381
383 Expr *DefaultArg) {
384 if (!param)
385 return;
386
387 ParmVarDecl *Param = cast<ParmVarDecl>(param);
388 Param->setInvalidDecl();
389 UnparsedDefaultArgLocs.erase(Param);
390 ExprResult RE;
391 if (DefaultArg) {
392 RE = CreateRecoveryExpr(EqualLoc, DefaultArg->getEndLoc(), {DefaultArg},
393 Param->getType().getNonReferenceType());
394 } else {
395 RE = CreateRecoveryExpr(EqualLoc, EqualLoc, {},
396 Param->getType().getNonReferenceType());
397 }
398 Param->setDefaultArg(RE.get());
399}
400
402 // C++ [dcl.fct.default]p3
403 // A default argument expression shall be specified only in the
404 // parameter-declaration-clause of a function declaration or in a
405 // template-parameter (14.1). It shall not be specified for a
406 // parameter pack. If it is specified in a
407 // parameter-declaration-clause, it shall not occur within a
408 // declarator or abstract-declarator of a parameter-declaration.
409 bool MightBeFunction = D.isFunctionDeclarationContext();
410 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
411 DeclaratorChunk &chunk = D.getTypeObject(i);
412 if (chunk.Kind == DeclaratorChunk::Function) {
413 if (MightBeFunction) {
414 // This is a function declaration. It can have default arguments, but
415 // keep looking in case its return type is a function type with default
416 // arguments.
417 MightBeFunction = false;
418 continue;
419 }
420 for (unsigned argIdx = 0, e = chunk.Fun.NumParams; argIdx != e;
421 ++argIdx) {
422 ParmVarDecl *Param = cast<ParmVarDecl>(chunk.Fun.Params[argIdx].Param);
423 if (Param->hasUnparsedDefaultArg()) {
424 std::unique_ptr<CachedTokens> Toks =
425 std::move(chunk.Fun.Params[argIdx].DefaultArgTokens);
426 SourceRange SR;
427 if (Toks->size() > 1)
428 SR = SourceRange((*Toks)[1].getLocation(),
429 Toks->back().getLocation());
430 else
431 SR = UnparsedDefaultArgLocs[Param];
432 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
433 << SR;
434 } else if (Param->getDefaultArg()) {
435 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
436 << Param->getDefaultArg()->getSourceRange();
437 Param->setDefaultArg(nullptr);
438 }
439 }
440 } else if (chunk.Kind != DeclaratorChunk::Paren) {
441 MightBeFunction = false;
442 }
443 }
444}
445
447 return llvm::any_of(FD->parameters(), [](ParmVarDecl *P) {
448 return P->hasDefaultArg() && !P->hasInheritedDefaultArg();
449 });
450}
451
453 Scope *S) {
454 bool Invalid = false;
455
456 // The declaration context corresponding to the scope is the semantic
457 // parent, unless this is a local function declaration, in which case
458 // it is that surrounding function.
459 DeclContext *ScopeDC = New->isLocalExternDecl()
460 ? New->getLexicalDeclContext()
461 : New->getDeclContext();
462
463 // Find the previous declaration for the purpose of default arguments.
464 FunctionDecl *PrevForDefaultArgs = Old;
465 for (/**/; PrevForDefaultArgs;
466 // Don't bother looking back past the latest decl if this is a local
467 // extern declaration; nothing else could work.
468 PrevForDefaultArgs = New->isLocalExternDecl()
469 ? nullptr
470 : PrevForDefaultArgs->getPreviousDecl()) {
471 // Ignore hidden declarations.
472 if (!LookupResult::isVisible(*this, PrevForDefaultArgs))
473 continue;
474
475 if (S && !isDeclInScope(PrevForDefaultArgs, ScopeDC, S) &&
476 !New->isCXXClassMember()) {
477 // Ignore default arguments of old decl if they are not in
478 // the same scope and this is not an out-of-line definition of
479 // a member function.
480 continue;
481 }
482
483 if (PrevForDefaultArgs->isLocalExternDecl() != New->isLocalExternDecl()) {
484 // If only one of these is a local function declaration, then they are
485 // declared in different scopes, even though isDeclInScope may think
486 // they're in the same scope. (If both are local, the scope check is
487 // sufficient, and if neither is local, then they are in the same scope.)
488 continue;
489 }
490
491 // We found the right previous declaration.
492 break;
493 }
494
495 // C++ [dcl.fct.default]p4:
496 // For non-template functions, default arguments can be added in
497 // later declarations of a function in the same
498 // scope. Declarations in different scopes have completely
499 // distinct sets of default arguments. That is, declarations in
500 // inner scopes do not acquire default arguments from
501 // declarations in outer scopes, and vice versa. In a given
502 // function declaration, all parameters subsequent to a
503 // parameter with a default argument shall have default
504 // arguments supplied in this or previous declarations. A
505 // default argument shall not be redefined by a later
506 // declaration (not even to the same value).
507 //
508 // C++ [dcl.fct.default]p6:
509 // Except for member functions of class templates, the default arguments
510 // in a member function definition that appears outside of the class
511 // definition are added to the set of default arguments provided by the
512 // member function declaration in the class definition.
513 for (unsigned p = 0, NumParams = PrevForDefaultArgs
514 ? PrevForDefaultArgs->getNumParams()
515 : 0;
516 p < NumParams; ++p) {
517 ParmVarDecl *OldParam = PrevForDefaultArgs->getParamDecl(p);
518 ParmVarDecl *NewParam = New->getParamDecl(p);
519
520 bool OldParamHasDfl = OldParam ? OldParam->hasDefaultArg() : false;
521 bool NewParamHasDfl = NewParam->hasDefaultArg();
522
523 if (OldParamHasDfl && NewParamHasDfl) {
524 unsigned DiagDefaultParamID =
525 diag::err_param_default_argument_redefinition;
526
527 // MSVC accepts that default parameters be redefined for member functions
528 // of template class. The new default parameter's value is ignored.
529 Invalid = true;
530 if (getLangOpts().MicrosoftExt) {
531 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(New);
532 if (MD && MD->getParent()->getDescribedClassTemplate()) {
533 // Merge the old default argument into the new parameter.
534 NewParam->setHasInheritedDefaultArg();
535 if (OldParam->hasUninstantiatedDefaultArg())
537 OldParam->getUninstantiatedDefaultArg());
538 else
539 NewParam->setDefaultArg(OldParam->getInit());
540 DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
541 Invalid = false;
542 }
543 }
544
545 // FIXME: If we knew where the '=' was, we could easily provide a fix-it
546 // hint here. Alternatively, we could walk the type-source information
547 // for NewParam to find the last source location in the type... but it
548 // isn't worth the effort right now. This is the kind of test case that
549 // is hard to get right:
550 // int f(int);
551 // void g(int (*fp)(int) = f);
552 // void g(int (*fp)(int) = &f);
553 Diag(NewParam->getLocation(), DiagDefaultParamID)
554 << NewParam->getDefaultArgRange();
555
556 // Look for the function declaration where the default argument was
557 // actually written, which may be a declaration prior to Old.
558 for (auto Older = PrevForDefaultArgs;
559 OldParam->hasInheritedDefaultArg(); /**/) {
560 Older = Older->getPreviousDecl();
561 OldParam = Older->getParamDecl(p);
562 }
563
564 Diag(OldParam->getLocation(), diag::note_previous_definition)
565 << OldParam->getDefaultArgRange();
566 } else if (OldParamHasDfl) {
567 // Merge the old default argument into the new parameter unless the new
568 // function is a friend declaration in a template class. In the latter
569 // case the default arguments will be inherited when the friend
570 // declaration will be instantiated.
571 if (New->getFriendObjectKind() == Decl::FOK_None ||
573 // It's important to use getInit() here; getDefaultArg()
574 // strips off any top-level ExprWithCleanups.
575 NewParam->setHasInheritedDefaultArg();
576 if (OldParam->hasUnparsedDefaultArg())
577 NewParam->setUnparsedDefaultArg();
578 else if (OldParam->hasUninstantiatedDefaultArg())
580 OldParam->getUninstantiatedDefaultArg());
581 else
582 NewParam->setDefaultArg(OldParam->getInit());
583 }
584 } else if (NewParamHasDfl) {
585 if (New->getDescribedFunctionTemplate()) {
586 // Paragraph 4, quoted above, only applies to non-template functions.
587 Diag(NewParam->getLocation(),
588 diag::err_param_default_argument_template_redecl)
589 << NewParam->getDefaultArgRange();
590 Diag(PrevForDefaultArgs->getLocation(),
591 diag::note_template_prev_declaration)
592 << false;
593 } else if (New->getTemplateSpecializationKind()
596 // C++ [temp.expr.spec]p21:
597 // Default function arguments shall not be specified in a declaration
598 // or a definition for one of the following explicit specializations:
599 // - the explicit specialization of a function template;
600 // - the explicit specialization of a member function template;
601 // - the explicit specialization of a member function of a class
602 // template where the class template specialization to which the
603 // member function specialization belongs is implicitly
604 // instantiated.
605 Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
607 << New->getDeclName()
608 << NewParam->getDefaultArgRange();
609 } else if (New->getDeclContext()->isDependentContext()) {
610 // C++ [dcl.fct.default]p6 (DR217):
611 // Default arguments for a member function of a class template shall
612 // be specified on the initial declaration of the member function
613 // within the class template.
614 //
615 // Reading the tea leaves a bit in DR217 and its reference to DR205
616 // leads me to the conclusion that one cannot add default function
617 // arguments for an out-of-line definition of a member function of a
618 // dependent type.
619 int WhichKind = 2;
621 = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
622 if (Record->getDescribedClassTemplate())
623 WhichKind = 0;
624 else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
625 WhichKind = 1;
626 else
627 WhichKind = 2;
628 }
629
630 Diag(NewParam->getLocation(),
631 diag::err_param_default_argument_member_template_redecl)
632 << WhichKind
633 << NewParam->getDefaultArgRange();
634 }
635 }
636 }
637
638 // DR1344: If a default argument is added outside a class definition and that
639 // default argument makes the function a special member function, the program
640 // is ill-formed. This can only happen for constructors.
641 if (isa<CXXConstructorDecl>(New) &&
643 CXXSpecialMemberKind NewSM = getSpecialMember(cast<CXXMethodDecl>(New)),
644 OldSM = getSpecialMember(cast<CXXMethodDecl>(Old));
645 if (NewSM != OldSM) {
646 ParmVarDecl *NewParam = New->getParamDecl(New->getMinRequiredArguments());
647 assert(NewParam->hasDefaultArg());
648 Diag(NewParam->getLocation(), diag::err_default_arg_makes_ctor_special)
649 << NewParam->getDefaultArgRange() << llvm::to_underlying(NewSM);
650 Diag(Old->getLocation(), diag::note_previous_declaration);
651 }
652 }
653
654 const FunctionDecl *Def;
655 // C++11 [dcl.constexpr]p1: If any declaration of a function or function
656 // template has a constexpr specifier then all its declarations shall
657 // contain the constexpr specifier.
658 if (New->getConstexprKind() != Old->getConstexprKind()) {
659 Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
660 << New << static_cast<int>(New->getConstexprKind())
661 << static_cast<int>(Old->getConstexprKind());
662 Diag(Old->getLocation(), diag::note_previous_declaration);
663 Invalid = true;
664 } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
665 Old->isDefined(Def) &&
666 // If a friend function is inlined but does not have 'inline'
667 // specifier, it is a definition. Do not report attribute conflict
668 // in this case, redefinition will be diagnosed later.
669 (New->isInlineSpecified() ||
671 // C++11 [dcl.fcn.spec]p4:
672 // If the definition of a function appears in a translation unit before its
673 // first declaration as inline, the program is ill-formed.
674 Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
675 Diag(Def->getLocation(), diag::note_previous_definition);
676 Invalid = true;
677 }
678
679 // C++17 [temp.deduct.guide]p3:
680 // Two deduction guide declarations in the same translation unit
681 // for the same class template shall not have equivalent
682 // parameter-declaration-clauses.
683 if (isa<CXXDeductionGuideDecl>(New) &&
685 Diag(New->getLocation(), diag::err_deduction_guide_redeclared);
686 Diag(Old->getLocation(), diag::note_previous_declaration);
687 }
688
689 // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
690 // argument expression, that declaration shall be a definition and shall be
691 // the only declaration of the function or function template in the
692 // translation unit.
695 Diag(New->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
696 Diag(Old->getLocation(), diag::note_previous_declaration);
697 Invalid = true;
698 }
699
700 // C++11 [temp.friend]p4 (DR329):
701 // When a function is defined in a friend function declaration in a class
702 // template, the function is instantiated when the function is odr-used.
703 // The same restrictions on multiple declarations and definitions that
704 // apply to non-template function declarations and definitions also apply
705 // to these implicit definitions.
706 const FunctionDecl *OldDefinition = nullptr;
708 Old->isDefined(OldDefinition, true))
709 CheckForFunctionRedefinition(New, OldDefinition);
710
711 return Invalid;
712}
713
716 ? diag::warn_cxx23_placeholder_var_definition
717 : diag::ext_placeholder_var_definition);
718}
719
720NamedDecl *
722 MultiTemplateParamsArg TemplateParamLists) {
723 assert(D.isDecompositionDeclarator());
724 const DecompositionDeclarator &Decomp = D.getDecompositionDeclarator();
725
726 // The syntax only allows a decomposition declarator as a simple-declaration,
727 // a for-range-declaration, or a condition in Clang, but we parse it in more
728 // cases than that.
729 if (!D.mayHaveDecompositionDeclarator()) {
730 Diag(Decomp.getLSquareLoc(), diag::err_decomp_decl_context)
731 << Decomp.getSourceRange();
732 return nullptr;
733 }
734
735 if (!TemplateParamLists.empty()) {
736 // FIXME: There's no rule against this, but there are also no rules that
737 // would actually make it usable, so we reject it for now.
738 Diag(TemplateParamLists.front()->getTemplateLoc(),
739 diag::err_decomp_decl_template);
740 return nullptr;
741 }
742
743 Diag(Decomp.getLSquareLoc(),
745 ? diag::ext_decomp_decl
746 : D.getContext() == DeclaratorContext::Condition
747 ? diag::ext_decomp_decl_cond
748 : diag::warn_cxx14_compat_decomp_decl)
749 << Decomp.getSourceRange();
750
751 // The semantic context is always just the current context.
752 DeclContext *const DC = CurContext;
753
754 // C++17 [dcl.dcl]/8:
755 // The decl-specifier-seq shall contain only the type-specifier auto
756 // and cv-qualifiers.
757 // C++20 [dcl.dcl]/8:
758 // If decl-specifier-seq contains any decl-specifier other than static,
759 // thread_local, auto, or cv-qualifiers, the program is ill-formed.
760 // C++23 [dcl.pre]/6:
761 // Each decl-specifier in the decl-specifier-seq shall be static,
762 // thread_local, auto (9.2.9.6 [dcl.spec.auto]), or a cv-qualifier.
763 auto &DS = D.getDeclSpec();
764 {
765 // Note: While constrained-auto needs to be checked, we do so separately so
766 // we can emit a better diagnostic.
767 SmallVector<StringRef, 8> BadSpecifiers;
768 SmallVector<SourceLocation, 8> BadSpecifierLocs;
769 SmallVector<StringRef, 8> CPlusPlus20Specifiers;
770 SmallVector<SourceLocation, 8> CPlusPlus20SpecifierLocs;
771 if (auto SCS = DS.getStorageClassSpec()) {
772 if (SCS == DeclSpec::SCS_static) {
773 CPlusPlus20Specifiers.push_back(DeclSpec::getSpecifierName(SCS));
774 CPlusPlus20SpecifierLocs.push_back(DS.getStorageClassSpecLoc());
775 } else {
776 BadSpecifiers.push_back(DeclSpec::getSpecifierName(SCS));
777 BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());
778 }
779 }
780 if (auto TSCS = DS.getThreadStorageClassSpec()) {
781 CPlusPlus20Specifiers.push_back(DeclSpec::getSpecifierName(TSCS));
782 CPlusPlus20SpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());
783 }
784 if (DS.hasConstexprSpecifier()) {
785 BadSpecifiers.push_back(
786 DeclSpec::getSpecifierName(DS.getConstexprSpecifier()));
787 BadSpecifierLocs.push_back(DS.getConstexprSpecLoc());
788 }
789 if (DS.isInlineSpecified()) {
790 BadSpecifiers.push_back("inline");
791 BadSpecifierLocs.push_back(DS.getInlineSpecLoc());
792 }
793
794 if (!BadSpecifiers.empty()) {
795 auto &&Err = Diag(BadSpecifierLocs.front(), diag::err_decomp_decl_spec);
796 Err << (int)BadSpecifiers.size()
797 << llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(), " ");
798 // Don't add FixItHints to remove the specifiers; we do still respect
799 // them when building the underlying variable.
800 for (auto Loc : BadSpecifierLocs)
801 Err << SourceRange(Loc, Loc);
802 } else if (!CPlusPlus20Specifiers.empty()) {
803 auto &&Warn = Diag(CPlusPlus20SpecifierLocs.front(),
805 ? diag::warn_cxx17_compat_decomp_decl_spec
806 : diag::ext_decomp_decl_spec);
807 Warn << (int)CPlusPlus20Specifiers.size()
808 << llvm::join(CPlusPlus20Specifiers.begin(),
809 CPlusPlus20Specifiers.end(), " ");
810 for (auto Loc : CPlusPlus20SpecifierLocs)
811 Warn << SourceRange(Loc, Loc);
812 }
813 // We can't recover from it being declared as a typedef.
814 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
815 return nullptr;
816 }
817
818 // C++2a [dcl.struct.bind]p1:
819 // A cv that includes volatile is deprecated
820 if ((DS.getTypeQualifiers() & DeclSpec::TQ_volatile) &&
822 Diag(DS.getVolatileSpecLoc(),
823 diag::warn_deprecated_volatile_structured_binding);
824
826 QualType R = TInfo->getType();
827
828 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
830 D.setInvalidType();
831
832 // The syntax only allows a single ref-qualifier prior to the decomposition
833 // declarator. No other declarator chunks are permitted. Also check the type
834 // specifier here.
835 if (DS.getTypeSpecType() != DeclSpec::TST_auto ||
836 D.hasGroupingParens() || D.getNumTypeObjects() > 1 ||
837 (D.getNumTypeObjects() == 1 &&
838 D.getTypeObject(0).Kind != DeclaratorChunk::Reference)) {
839 Diag(Decomp.getLSquareLoc(),
840 (D.hasGroupingParens() ||
841 (D.getNumTypeObjects() &&
842 D.getTypeObject(0).Kind == DeclaratorChunk::Paren))
843 ? diag::err_decomp_decl_parens
844 : diag::err_decomp_decl_type)
845 << R;
846
847 // In most cases, there's no actual problem with an explicitly-specified
848 // type, but a function type won't work here, and ActOnVariableDeclarator
849 // shouldn't be called for such a type.
850 if (R->isFunctionType())
851 D.setInvalidType();
852 }
853
854 // Constrained auto is prohibited by [decl.pre]p6, so check that here.
855 if (DS.isConstrainedAuto()) {
856 TemplateIdAnnotation *TemplRep = DS.getRepAsTemplateId();
857 assert(TemplRep->Kind == TNK_Concept_template &&
858 "No other template kind should be possible for a constrained auto");
859
860 SourceRange TemplRange{TemplRep->TemplateNameLoc,
861 TemplRep->RAngleLoc.isValid()
862 ? TemplRep->RAngleLoc
863 : TemplRep->TemplateNameLoc};
864 Diag(TemplRep->TemplateNameLoc, diag::err_decomp_decl_constraint)
865 << TemplRange << FixItHint::CreateRemoval(TemplRange);
866 }
867
868 // Build the BindingDecls.
870
871 // Build the BindingDecls.
872 for (auto &B : D.getDecompositionDeclarator().bindings()) {
873 // Check for name conflicts.
874 DeclarationNameInfo NameInfo(B.Name, B.NameLoc);
875 IdentifierInfo *VarName = B.Name;
876 assert(VarName && "Cannot have an unnamed binding declaration");
877
879 RedeclarationKind::ForVisibleRedeclaration);
881 /*CreateBuiltins*/DC->getRedeclContext()->isTranslationUnit());
882
883 // It's not permitted to shadow a template parameter name.
884 if (Previous.isSingleResult() &&
885 Previous.getFoundDecl()->isTemplateParameter()) {
886 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
887 Previous.getFoundDecl());
888 Previous.clear();
889 }
890
891 auto *BD = BindingDecl::Create(Context, DC, B.NameLoc, VarName);
892
893 ProcessDeclAttributeList(S, BD, *B.Attrs);
894
895 // Find the shadowed declaration before filtering for scope.
896 NamedDecl *ShadowedDecl = D.getCXXScopeSpec().isEmpty()
898 : nullptr;
899
900 bool ConsiderLinkage = DC->isFunctionOrMethod() &&
901 DS.getStorageClassSpec() == DeclSpec::SCS_extern;
902 FilterLookupForScope(Previous, DC, S, ConsiderLinkage,
903 /*AllowInlineNamespace*/false);
904
905 bool IsPlaceholder = DS.getStorageClassSpec() != DeclSpec::SCS_static &&
906 DC->isFunctionOrMethod() && VarName->isPlaceholder();
907 if (!Previous.empty()) {
908 if (IsPlaceholder) {
909 bool sameDC = (Previous.end() - 1)
910 ->getDeclContext()
911 ->getRedeclContext()
912 ->Equals(DC->getRedeclContext());
913 if (sameDC &&
914 isDeclInScope(*(Previous.end() - 1), CurContext, S, false)) {
915 Previous.clear();
917 }
918 } else {
919 auto *Old = Previous.getRepresentativeDecl();
920 Diag(B.NameLoc, diag::err_redefinition) << B.Name;
921 Diag(Old->getLocation(), diag::note_previous_definition);
922 }
923 } else if (ShadowedDecl && !D.isRedeclaration()) {
924 CheckShadow(BD, ShadowedDecl, Previous);
925 }
926 PushOnScopeChains(BD, S, true);
927 Bindings.push_back(BD);
928 ParsingInitForAutoVars.insert(BD);
929 }
930
931 // There are no prior lookup results for the variable itself, because it
932 // is unnamed.
933 DeclarationNameInfo NameInfo((IdentifierInfo *)nullptr,
934 Decomp.getLSquareLoc());
936 RedeclarationKind::ForVisibleRedeclaration);
937
938 // Build the variable that holds the non-decomposed object.
939 bool AddToScope = true;
940 NamedDecl *New =
941 ActOnVariableDeclarator(S, D, DC, TInfo, Previous,
942 MultiTemplateParamsArg(), AddToScope, Bindings);
943 if (AddToScope) {
944 S->AddDecl(New);
946 }
947
948 if (OpenMP().isInOpenMPDeclareTargetContext())
950
951 return New;
952}
953
956 QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType,
957 llvm::function_ref<ExprResult(SourceLocation, Expr *, unsigned)> GetInit) {
958 if ((int64_t)Bindings.size() != NumElems) {
959 S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
960 << DecompType << (unsigned)Bindings.size()
961 << (unsigned)NumElems.getLimitedValue(UINT_MAX)
962 << toString(NumElems, 10) << (NumElems < Bindings.size());
963 return true;
964 }
965
966 unsigned I = 0;
967 for (auto *B : Bindings) {
968 SourceLocation Loc = B->getLocation();
969 ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
970 if (E.isInvalid())
971 return true;
972 E = GetInit(Loc, E.get(), I++);
973 if (E.isInvalid())
974 return true;
975 B->setBinding(ElemType, E.get());
976 }
977
978 return false;
979}
980
983 ValueDecl *Src, QualType DecompType,
984 const llvm::APSInt &NumElems,
985 QualType ElemType) {
987 S, Bindings, Src, DecompType, NumElems, ElemType,
988 [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
990 if (E.isInvalid())
991 return ExprError();
992 return S.CreateBuiltinArraySubscriptExpr(Base, Loc, E.get(), Loc);
993 });
994}
995
997 ValueDecl *Src, QualType DecompType,
998 const ConstantArrayType *CAT) {
999 return checkArrayLikeDecomposition(S, Bindings, Src, DecompType,
1000 llvm::APSInt(CAT->getSize()),
1001 CAT->getElementType());
1002}
1003
1005 ValueDecl *Src, QualType DecompType,
1006 const VectorType *VT) {
1008 S, Bindings, Src, DecompType, llvm::APSInt::get(VT->getNumElements()),
1010 DecompType.getQualifiers()));
1011}
1012
1015 ValueDecl *Src, QualType DecompType,
1016 const ComplexType *CT) {
1018 S, Bindings, Src, DecompType, llvm::APSInt::get(2),
1020 DecompType.getQualifiers()),
1021 [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
1022 return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
1023 });
1024}
1025
1028 const TemplateParameterList *Params) {
1030 llvm::raw_svector_ostream OS(SS);
1031 bool First = true;
1032 unsigned I = 0;
1033 for (auto &Arg : Args.arguments()) {
1034 if (!First)
1035 OS << ", ";
1036 Arg.getArgument().print(PrintingPolicy, OS,
1038 PrintingPolicy, Params, I));
1039 First = false;
1040 I++;
1041 }
1042 return std::string(OS.str());
1043}
1044
1045static bool lookupStdTypeTraitMember(Sema &S, LookupResult &TraitMemberLookup,
1046 SourceLocation Loc, StringRef Trait,
1048 unsigned DiagID) {
1049 auto DiagnoseMissing = [&] {
1050 if (DiagID)
1052 Args, /*Params*/ nullptr);
1053 return true;
1054 };
1055
1056 // FIXME: Factor out duplication with lookupPromiseType in SemaCoroutine.
1058 if (!Std)
1059 return DiagnoseMissing();
1060
1061 // Look up the trait itself, within namespace std. We can diagnose various
1062 // problems with this lookup even if we've been asked to not diagnose a
1063 // missing specialization, because this can only fail if the user has been
1064 // declaring their own names in namespace std or we don't support the
1065 // standard library implementation in use.
1069 return DiagnoseMissing();
1070 if (Result.isAmbiguous())
1071 return true;
1072
1073 ClassTemplateDecl *TraitTD = Result.getAsSingle<ClassTemplateDecl>();
1074 if (!TraitTD) {
1075 Result.suppressDiagnostics();
1076 NamedDecl *Found = *Result.begin();
1077 S.Diag(Loc, diag::err_std_type_trait_not_class_template) << Trait;
1078 S.Diag(Found->getLocation(), diag::note_declared_at);
1079 return true;
1080 }
1081
1082 // Build the template-id.
1083 QualType TraitTy = S.CheckTemplateIdType(TemplateName(TraitTD), Loc, Args);
1084 if (TraitTy.isNull())
1085 return true;
1086 if (!S.isCompleteType(Loc, TraitTy)) {
1087 if (DiagID)
1089 Loc, TraitTy, DiagID,
1091 TraitTD->getTemplateParameters()));
1092 return true;
1093 }
1094
1095 CXXRecordDecl *RD = TraitTy->getAsCXXRecordDecl();
1096 assert(RD && "specialization of class template is not a class?");
1097
1098 // Look up the member of the trait type.
1099 S.LookupQualifiedName(TraitMemberLookup, RD);
1100 return TraitMemberLookup.isAmbiguous();
1101}
1102
1105 uint64_t I) {
1107 return S.getTrivialTemplateArgumentLoc(Arg, T, Loc);
1108}
1109
1113}
1114
1115namespace { enum class IsTupleLike { TupleLike, NotTupleLike, Error }; }
1116
1118 llvm::APSInt &Size) {
1121
1124
1125 // Form template argument list for tuple_size<T>.
1128
1129 // If there's no tuple_size specialization or the lookup of 'value' is empty,
1130 // it's not tuple-like.
1131 if (lookupStdTypeTraitMember(S, R, Loc, "tuple_size", Args, /*DiagID*/ 0) ||
1132 R.empty())
1133 return IsTupleLike::NotTupleLike;
1134
1135 // If we get this far, we've committed to the tuple interpretation, but
1136 // we can still fail if there actually isn't a usable ::value.
1137
1138 struct ICEDiagnoser : Sema::VerifyICEDiagnoser {
1139 LookupResult &R;
1141 ICEDiagnoser(LookupResult &R, TemplateArgumentListInfo &Args)
1142 : R(R), Args(Args) {}
1143 Sema::SemaDiagnosticBuilder diagnoseNotICE(Sema &S,
1144 SourceLocation Loc) override {
1145 return S.Diag(Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
1147 /*Params*/ nullptr);
1148 }
1149 } Diagnoser(R, Args);
1150
1151 ExprResult E =
1152 S.BuildDeclarationNameExpr(CXXScopeSpec(), R, /*NeedsADL*/false);
1153 if (E.isInvalid())
1154 return IsTupleLike::Error;
1155
1156 E = S.VerifyIntegerConstantExpression(E.get(), &Size, Diagnoser);
1157 if (E.isInvalid())
1158 return IsTupleLike::Error;
1159
1160 return IsTupleLike::TupleLike;
1161}
1162
1163/// \return std::tuple_element<I, T>::type.
1165 unsigned I, QualType T) {
1166 // Form template argument list for tuple_element<I, T>.
1168 Args.addArgument(
1171
1172 DeclarationName TypeDN = S.PP.getIdentifierInfo("type");
1175 S, R, Loc, "tuple_element", Args,
1176 diag::err_decomp_decl_std_tuple_element_not_specialized))
1177 return QualType();
1178
1179 auto *TD = R.getAsSingle<TypeDecl>();
1180 if (!TD) {
1182 S.Diag(Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
1184 /*Params*/ nullptr);
1185 if (!R.empty())
1186 S.Diag(R.getRepresentativeDecl()->getLocation(), diag::note_declared_at);
1187 return QualType();
1188 }
1189
1190 return S.Context.getTypeDeclType(TD);
1191}
1192
1193namespace {
1194struct InitializingBinding {
1195 Sema &S;
1196 InitializingBinding(Sema &S, BindingDecl *BD) : S(S) {
1200 Ctx.Entity = BD;
1202 }
1203 ~InitializingBinding() {
1205 }
1206};
1207}
1208
1211 VarDecl *Src, QualType DecompType,
1212 const llvm::APSInt &TupleSize) {
1213 if ((int64_t)Bindings.size() != TupleSize) {
1214 S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1215 << DecompType << (unsigned)Bindings.size()
1216 << (unsigned)TupleSize.getLimitedValue(UINT_MAX)
1217 << toString(TupleSize, 10) << (TupleSize < Bindings.size());
1218 return true;
1219 }
1220
1221 if (Bindings.empty())
1222 return false;
1223
1224 DeclarationName GetDN = S.PP.getIdentifierInfo("get");
1225
1226 // [dcl.decomp]p3:
1227 // The unqualified-id get is looked up in the scope of E by class member
1228 // access lookup ...
1229 LookupResult MemberGet(S, GetDN, Src->getLocation(), Sema::LookupMemberName);
1230 bool UseMemberGet = false;
1231 if (S.isCompleteType(Src->getLocation(), DecompType)) {
1232 if (auto *RD = DecompType->getAsCXXRecordDecl())
1233 S.LookupQualifiedName(MemberGet, RD);
1234 if (MemberGet.isAmbiguous())
1235 return true;
1236 // ... and if that finds at least one declaration that is a function
1237 // template whose first template parameter is a non-type parameter ...
1238 for (NamedDecl *D : MemberGet) {
1239 if (FunctionTemplateDecl *FTD =
1240 dyn_cast<FunctionTemplateDecl>(D->getUnderlyingDecl())) {
1241 TemplateParameterList *TPL = FTD->getTemplateParameters();
1242 if (TPL->size() != 0 &&
1243 isa<NonTypeTemplateParmDecl>(TPL->getParam(0))) {
1244 // ... the initializer is e.get<i>().
1245 UseMemberGet = true;
1246 break;
1247 }
1248 }
1249 }
1250 }
1251
1252 unsigned I = 0;
1253 for (auto *B : Bindings) {
1254 InitializingBinding InitContext(S, B);
1255 SourceLocation Loc = B->getLocation();
1256
1257 ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1258 if (E.isInvalid())
1259 return true;
1260
1261 // e is an lvalue if the type of the entity is an lvalue reference and
1262 // an xvalue otherwise
1263 if (!Src->getType()->isLValueReferenceType())
1264 E = ImplicitCastExpr::Create(S.Context, E.get()->getType(), CK_NoOp,
1265 E.get(), nullptr, VK_XValue,
1267
1269 Args.addArgument(
1271
1272 if (UseMemberGet) {
1273 // if [lookup of member get] finds at least one declaration, the
1274 // initializer is e.get<i-1>().
1275 E = S.BuildMemberReferenceExpr(E.get(), DecompType, Loc, false,
1276 CXXScopeSpec(), SourceLocation(), nullptr,
1277 MemberGet, &Args, nullptr);
1278 if (E.isInvalid())
1279 return true;
1280
1281 E = S.BuildCallExpr(nullptr, E.get(), Loc, {}, Loc);
1282 } else {
1283 // Otherwise, the initializer is get<i-1>(e), where get is looked up
1284 // in the associated namespaces.
1287 DeclarationNameInfo(GetDN, Loc), /*RequiresADL=*/true, &Args,
1289 /*KnownDependent=*/false, /*KnownInstantiationDependent=*/false);
1290
1291 Expr *Arg = E.get();
1292 E = S.BuildCallExpr(nullptr, Get, Loc, Arg, Loc);
1293 }
1294 if (E.isInvalid())
1295 return true;
1296 Expr *Init = E.get();
1297
1298 // Given the type T designated by std::tuple_element<i - 1, E>::type,
1299 QualType T = getTupleLikeElementType(S, Loc, I, DecompType);
1300 if (T.isNull())
1301 return true;
1302
1303 // each vi is a variable of type "reference to T" initialized with the
1304 // initializer, where the reference is an lvalue reference if the
1305 // initializer is an lvalue and an rvalue reference otherwise
1306 QualType RefType =
1307 S.BuildReferenceType(T, E.get()->isLValue(), Loc, B->getDeclName());
1308 if (RefType.isNull())
1309 return true;
1310 auto *RefVD = VarDecl::Create(
1311 S.Context, Src->getDeclContext(), Loc, Loc,
1312 B->getDeclName().getAsIdentifierInfo(), RefType,
1314 RefVD->setLexicalDeclContext(Src->getLexicalDeclContext());
1315 RefVD->setTSCSpec(Src->getTSCSpec());
1316 RefVD->setImplicit();
1317 if (Src->isInlineSpecified())
1318 RefVD->setInlineSpecified();
1319 RefVD->getLexicalDeclContext()->addHiddenDecl(RefVD);
1320
1323 InitializationSequence Seq(S, Entity, Kind, Init);
1324 E = Seq.Perform(S, Entity, Kind, Init);
1325 if (E.isInvalid())
1326 return true;
1327 E = S.ActOnFinishFullExpr(E.get(), Loc, /*DiscardedValue*/ false);
1328 if (E.isInvalid())
1329 return true;
1330 RefVD->setInit(E.get());
1332
1334 DeclarationNameInfo(B->getDeclName(), Loc),
1335 RefVD);
1336 if (E.isInvalid())
1337 return true;
1338
1339 B->setBinding(T, E.get());
1340 I++;
1341 }
1342
1343 return false;
1344}
1345
1346/// Find the base class to decompose in a built-in decomposition of a class type.
1347/// This base class search is, unfortunately, not quite like any other that we
1348/// perform anywhere else in C++.
1350 const CXXRecordDecl *RD,
1351 CXXCastPath &BasePath) {
1352 auto BaseHasFields = [](const CXXBaseSpecifier *Specifier,
1353 CXXBasePath &Path) {
1354 return Specifier->getType()->getAsCXXRecordDecl()->hasDirectFields();
1355 };
1356
1357 const CXXRecordDecl *ClassWithFields = nullptr;
1359 if (RD->hasDirectFields())
1360 // [dcl.decomp]p4:
1361 // Otherwise, all of E's non-static data members shall be public direct
1362 // members of E ...
1363 ClassWithFields = RD;
1364 else {
1365 // ... or of ...
1366 CXXBasePaths Paths;
1367 Paths.setOrigin(const_cast<CXXRecordDecl*>(RD));
1368 if (!RD->lookupInBases(BaseHasFields, Paths)) {
1369 // If no classes have fields, just decompose RD itself. (This will work
1370 // if and only if zero bindings were provided.)
1371 return DeclAccessPair::make(const_cast<CXXRecordDecl*>(RD), AS_public);
1372 }
1373
1374 CXXBasePath *BestPath = nullptr;
1375 for (auto &P : Paths) {
1376 if (!BestPath)
1377 BestPath = &P;
1378 else if (!S.Context.hasSameType(P.back().Base->getType(),
1379 BestPath->back().Base->getType())) {
1380 // ... the same ...
1381 S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1382 << false << RD << BestPath->back().Base->getType()
1383 << P.back().Base->getType();
1384 return DeclAccessPair();
1385 } else if (P.Access < BestPath->Access) {
1386 BestPath = &P;
1387 }
1388 }
1389
1390 // ... unambiguous ...
1391 QualType BaseType = BestPath->back().Base->getType();
1392 if (Paths.isAmbiguous(S.Context.getCanonicalType(BaseType))) {
1393 S.Diag(Loc, diag::err_decomp_decl_ambiguous_base)
1394 << RD << BaseType << S.getAmbiguousPathsDisplayString(Paths);
1395 return DeclAccessPair();
1396 }
1397
1398 // ... [accessible, implied by other rules] base class of E.
1399 S.CheckBaseClassAccess(Loc, BaseType, S.Context.getRecordType(RD),
1400 *BestPath, diag::err_decomp_decl_inaccessible_base);
1401 AS = BestPath->Access;
1402
1403 ClassWithFields = BaseType->getAsCXXRecordDecl();
1404 S.BuildBasePathArray(Paths, BasePath);
1405 }
1406
1407 // The above search did not check whether the selected class itself has base
1408 // classes with fields, so check that now.
1409 CXXBasePaths Paths;
1410 if (ClassWithFields->lookupInBases(BaseHasFields, Paths)) {
1411 S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1412 << (ClassWithFields == RD) << RD << ClassWithFields
1413 << Paths.front().back().Base->getType();
1414 return DeclAccessPair();
1415 }
1416
1417 return DeclAccessPair::make(const_cast<CXXRecordDecl*>(ClassWithFields), AS);
1418}
1419
1421 ValueDecl *Src, QualType DecompType,
1422 const CXXRecordDecl *OrigRD) {
1423 if (S.RequireCompleteType(Src->getLocation(), DecompType,
1424 diag::err_incomplete_type))
1425 return true;
1426
1427 CXXCastPath BasePath;
1428 DeclAccessPair BasePair =
1429 findDecomposableBaseClass(S, Src->getLocation(), OrigRD, BasePath);
1430 const CXXRecordDecl *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
1431 if (!RD)
1432 return true;
1434 DecompType.getQualifiers());
1435
1436 auto DiagnoseBadNumberOfBindings = [&]() -> bool {
1437 unsigned NumFields = llvm::count_if(
1438 RD->fields(), [](FieldDecl *FD) { return !FD->isUnnamedBitField(); });
1439 assert(Bindings.size() != NumFields);
1440 S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1441 << DecompType << (unsigned)Bindings.size() << NumFields << NumFields
1442 << (NumFields < Bindings.size());
1443 return true;
1444 };
1445
1446 // all of E's non-static data members shall be [...] well-formed
1447 // when named as e.name in the context of the structured binding,
1448 // E shall not have an anonymous union member, ...
1449 unsigned I = 0;
1450 for (auto *FD : RD->fields()) {
1451 if (FD->isUnnamedBitField())
1452 continue;
1453
1454 // All the non-static data members are required to be nameable, so they
1455 // must all have names.
1456 if (!FD->getDeclName()) {
1457 if (RD->isLambda()) {
1458 S.Diag(Src->getLocation(), diag::err_decomp_decl_lambda);
1459 S.Diag(RD->getLocation(), diag::note_lambda_decl);
1460 return true;
1461 }
1462
1463 if (FD->isAnonymousStructOrUnion()) {
1464 S.Diag(Src->getLocation(), diag::err_decomp_decl_anon_union_member)
1465 << DecompType << FD->getType()->isUnionType();
1466 S.Diag(FD->getLocation(), diag::note_declared_at);
1467 return true;
1468 }
1469
1470 // FIXME: Are there any other ways we could have an anonymous member?
1471 }
1472
1473 // We have a real field to bind.
1474 if (I >= Bindings.size())
1475 return DiagnoseBadNumberOfBindings();
1476 auto *B = Bindings[I++];
1477 SourceLocation Loc = B->getLocation();
1478
1479 // The field must be accessible in the context of the structured binding.
1480 // We already checked that the base class is accessible.
1481 // FIXME: Add 'const' to AccessedEntity's classes so we can remove the
1482 // const_cast here.
1484 Loc, const_cast<CXXRecordDecl *>(OrigRD),
1486 BasePair.getAccess(), FD->getAccess())));
1487
1488 // Initialize the binding to Src.FD.
1489 ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1490 if (E.isInvalid())
1491 return true;
1492 E = S.ImpCastExprToType(E.get(), BaseType, CK_UncheckedDerivedToBase,
1493 VK_LValue, &BasePath);
1494 if (E.isInvalid())
1495 return true;
1496 E = S.BuildFieldReferenceExpr(E.get(), /*IsArrow*/ false, Loc,
1497 CXXScopeSpec(), FD,
1498 DeclAccessPair::make(FD, FD->getAccess()),
1499 DeclarationNameInfo(FD->getDeclName(), Loc));
1500 if (E.isInvalid())
1501 return true;
1502
1503 // If the type of the member is T, the referenced type is cv T, where cv is
1504 // the cv-qualification of the decomposition expression.
1505 //
1506 // FIXME: We resolve a defect here: if the field is mutable, we do not add
1507 // 'const' to the type of the field.
1508 Qualifiers Q = DecompType.getQualifiers();
1509 if (FD->isMutable())
1510 Q.removeConst();
1511 B->setBinding(S.BuildQualifiedType(FD->getType(), Loc, Q), E.get());
1512 }
1513
1514 if (I != Bindings.size())
1515 return DiagnoseBadNumberOfBindings();
1516
1517 return false;
1518}
1519
1521 QualType DecompType = DD->getType();
1522
1523 // If the type of the decomposition is dependent, then so is the type of
1524 // each binding.
1525 if (DecompType->isDependentType()) {
1526 for (auto *B : DD->bindings())
1527 B->setType(Context.DependentTy);
1528 return;
1529 }
1530
1531 DecompType = DecompType.getNonReferenceType();
1533
1534 // C++1z [dcl.decomp]/2:
1535 // If E is an array type [...]
1536 // As an extension, we also support decomposition of built-in complex and
1537 // vector types.
1538 if (auto *CAT = Context.getAsConstantArrayType(DecompType)) {
1539 if (checkArrayDecomposition(*this, Bindings, DD, DecompType, CAT))
1540 DD->setInvalidDecl();
1541 return;
1542 }
1543 if (auto *VT = DecompType->getAs<VectorType>()) {
1544 if (checkVectorDecomposition(*this, Bindings, DD, DecompType, VT))
1545 DD->setInvalidDecl();
1546 return;
1547 }
1548 if (auto *CT = DecompType->getAs<ComplexType>()) {
1549 if (checkComplexDecomposition(*this, Bindings, DD, DecompType, CT))
1550 DD->setInvalidDecl();
1551 return;
1552 }
1553
1554 // C++1z [dcl.decomp]/3:
1555 // if the expression std::tuple_size<E>::value is a well-formed integral
1556 // constant expression, [...]
1557 llvm::APSInt TupleSize(32);
1558 switch (isTupleLike(*this, DD->getLocation(), DecompType, TupleSize)) {
1559 case IsTupleLike::Error:
1560 DD->setInvalidDecl();
1561 return;
1562
1563 case IsTupleLike::TupleLike:
1564 if (checkTupleLikeDecomposition(*this, Bindings, DD, DecompType, TupleSize))
1565 DD->setInvalidDecl();
1566 return;
1567
1568 case IsTupleLike::NotTupleLike:
1569 break;
1570 }
1571
1572 // C++1z [dcl.dcl]/8:
1573 // [E shall be of array or non-union class type]
1574 CXXRecordDecl *RD = DecompType->getAsCXXRecordDecl();
1575 if (!RD || RD->isUnion()) {
1576 Diag(DD->getLocation(), diag::err_decomp_decl_unbindable_type)
1577 << DD << !RD << DecompType;
1578 DD->setInvalidDecl();
1579 return;
1580 }
1581
1582 // C++1z [dcl.decomp]/4:
1583 // all of E's non-static data members shall be [...] direct members of
1584 // E or of the same unambiguous public base class of E, ...
1585 if (checkMemberDecomposition(*this, Bindings, DD, DecompType, RD))
1586 DD->setInvalidDecl();
1587}
1588
1590 // Shortcut if exceptions are disabled.
1591 if (!getLangOpts().CXXExceptions)
1592 return;
1593
1594 assert(Context.hasSameType(New->getType(), Old->getType()) &&
1595 "Should only be called if types are otherwise the same.");
1596
1597 QualType NewType = New->getType();
1598 QualType OldType = Old->getType();
1599
1600 // We're only interested in pointers and references to functions, as well
1601 // as pointers to member functions.
1602 if (const ReferenceType *R = NewType->getAs<ReferenceType>()) {
1603 NewType = R->getPointeeType();
1604 OldType = OldType->castAs<ReferenceType>()->getPointeeType();
1605 } else if (const PointerType *P = NewType->getAs<PointerType>()) {
1606 NewType = P->getPointeeType();
1607 OldType = OldType->castAs<PointerType>()->getPointeeType();
1608 } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) {
1609 NewType = M->getPointeeType();
1610 OldType = OldType->castAs<MemberPointerType>()->getPointeeType();
1611 }
1612
1613 if (!NewType->isFunctionProtoType())
1614 return;
1615
1616 // There's lots of special cases for functions. For function pointers, system
1617 // libraries are hopefully not as broken so that we don't need these
1618 // workarounds.
1620 OldType->getAs<FunctionProtoType>(), Old->getLocation(),
1621 NewType->getAs<FunctionProtoType>(), New->getLocation())) {
1622 New->setInvalidDecl();
1623 }
1624}
1625
1626/// CheckCXXDefaultArguments - Verify that the default arguments for a
1627/// function declaration are well-formed according to C++
1628/// [dcl.fct.default].
1630 // This checking doesn't make sense for explicit specializations; their
1631 // default arguments are determined by the declaration we're specializing,
1632 // not by FD.
1634 return;
1635 if (auto *FTD = FD->getDescribedFunctionTemplate())
1636 if (FTD->isMemberSpecialization())
1637 return;
1638
1639 unsigned NumParams = FD->getNumParams();
1640 unsigned ParamIdx = 0;
1641
1642 // Find first parameter with a default argument
1643 for (; ParamIdx < NumParams; ++ParamIdx) {
1644 ParmVarDecl *Param = FD->getParamDecl(ParamIdx);
1645 if (Param->hasDefaultArg())
1646 break;
1647 }
1648
1649 // C++20 [dcl.fct.default]p4:
1650 // In a given function declaration, each parameter subsequent to a parameter
1651 // with a default argument shall have a default argument supplied in this or
1652 // a previous declaration, unless the parameter was expanded from a
1653 // parameter pack, or shall be a function parameter pack.
1654 for (++ParamIdx; ParamIdx < NumParams; ++ParamIdx) {
1655 ParmVarDecl *Param = FD->getParamDecl(ParamIdx);
1656 if (Param->hasDefaultArg() || Param->isParameterPack() ||
1659 continue;
1660 if (Param->isInvalidDecl())
1661 /* We already complained about this parameter. */;
1662 else if (Param->getIdentifier())
1663 Diag(Param->getLocation(), diag::err_param_default_argument_missing_name)
1664 << Param->getIdentifier();
1665 else
1666 Diag(Param->getLocation(), diag::err_param_default_argument_missing);
1667 }
1668}
1669
1670/// Check that the given type is a literal type. Issue a diagnostic if not,
1671/// if Kind is Diagnose.
1672/// \return \c true if a problem has been found (and optionally diagnosed).
1673template <typename... Ts>
1675 SourceLocation Loc, QualType T, unsigned DiagID,
1676 Ts &&...DiagArgs) {
1677 if (T->isDependentType())
1678 return false;
1679
1680 switch (Kind) {
1682 return SemaRef.RequireLiteralType(Loc, T, DiagID,
1683 std::forward<Ts>(DiagArgs)...);
1684
1686 return !T->isLiteralType(SemaRef.Context);
1687 }
1688
1689 llvm_unreachable("unknown CheckConstexprKind");
1690}
1691
1692/// Determine whether a destructor cannot be constexpr due to
1694 const CXXDestructorDecl *DD,
1696 assert(!SemaRef.getLangOpts().CPlusPlus23 &&
1697 "this check is obsolete for C++23");
1698 auto Check = [&](SourceLocation Loc, QualType T, const FieldDecl *FD) {
1699 const CXXRecordDecl *RD =
1701 if (!RD || RD->hasConstexprDestructor())
1702 return true;
1703
1705 SemaRef.Diag(DD->getLocation(), diag::err_constexpr_dtor_subobject)
1706 << static_cast<int>(DD->getConstexprKind()) << !FD
1707 << (FD ? FD->getDeclName() : DeclarationName()) << T;
1708 SemaRef.Diag(Loc, diag::note_constexpr_dtor_subobject)
1709 << !FD << (FD ? FD->getDeclName() : DeclarationName()) << T;
1710 }
1711 return false;
1712 };
1713
1714 const CXXRecordDecl *RD = DD->getParent();
1715 for (const CXXBaseSpecifier &B : RD->bases())
1716 if (!Check(B.getBaseTypeLoc(), B.getType(), nullptr))
1717 return false;
1718 for (const FieldDecl *FD : RD->fields())
1719 if (!Check(FD->getLocation(), FD->getType(), FD))
1720 return false;
1721 return true;
1722}
1723
1724/// Check whether a function's parameter types are all literal types. If so,
1725/// return true. If not, produce a suitable diagnostic and return false.
1727 const FunctionDecl *FD,
1729 assert(!SemaRef.getLangOpts().CPlusPlus23 &&
1730 "this check is obsolete for C++23");
1731 unsigned ArgIndex = 0;
1732 const auto *FT = FD->getType()->castAs<FunctionProtoType>();
1733 for (FunctionProtoType::param_type_iterator i = FT->param_type_begin(),
1734 e = FT->param_type_end();
1735 i != e; ++i, ++ArgIndex) {
1736 const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
1737 assert(PD && "null in a parameter list");
1738 SourceLocation ParamLoc = PD->getLocation();
1739 if (CheckLiteralType(SemaRef, Kind, ParamLoc, *i,
1740 diag::err_constexpr_non_literal_param, ArgIndex + 1,
1741 PD->getSourceRange(), isa<CXXConstructorDecl>(FD),
1742 FD->isConsteval()))
1743 return false;
1744 }
1745 return true;
1746}
1747
1748/// Check whether a function's return type is a literal type. If so, return
1749/// true. If not, produce a suitable diagnostic and return false.
1752 assert(!SemaRef.getLangOpts().CPlusPlus23 &&
1753 "this check is obsolete for C++23");
1754 if (CheckLiteralType(SemaRef, Kind, FD->getLocation(), FD->getReturnType(),
1755 diag::err_constexpr_non_literal_return,
1756 FD->isConsteval()))
1757 return false;
1758 return true;
1759}
1760
1761/// Get diagnostic %select index for tag kind for
1762/// record diagnostic message.
1763/// WARNING: Indexes apply to particular diagnostics only!
1764///
1765/// \returns diagnostic %select index.
1767 switch (Tag) {
1769 return 0;
1771 return 1;
1772 case TagTypeKind::Class:
1773 return 2;
1774 default: llvm_unreachable("Invalid tag kind for record diagnostic!");
1775 }
1776}
1777
1778static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl,
1779 Stmt *Body,
1781static bool CheckConstexprMissingReturn(Sema &SemaRef, const FunctionDecl *Dcl);
1782
1784 CheckConstexprKind Kind) {
1785 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
1786 if (MD && MD->isInstance()) {
1787 // C++11 [dcl.constexpr]p4:
1788 // The definition of a constexpr constructor shall satisfy the following
1789 // constraints:
1790 // - the class shall not have any virtual base classes;
1791 //
1792 // FIXME: This only applies to constructors and destructors, not arbitrary
1793 // member functions.
1794 const CXXRecordDecl *RD = MD->getParent();
1795 if (RD->getNumVBases()) {
1797 return false;
1798
1799 Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base)
1800 << isa<CXXConstructorDecl>(NewFD)
1802 for (const auto &I : RD->vbases())
1803 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
1804 << I.getSourceRange();
1805 return false;
1806 }
1807 }
1808
1809 if (!isa<CXXConstructorDecl>(NewFD)) {
1810 // C++11 [dcl.constexpr]p3:
1811 // The definition of a constexpr function shall satisfy the following
1812 // constraints:
1813 // - it shall not be virtual; (removed in C++20)
1814 const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
1815 if (Method && Method->isVirtual()) {
1816 if (getLangOpts().CPlusPlus20) {
1817 if (Kind == CheckConstexprKind::Diagnose)
1818 Diag(Method->getLocation(), diag::warn_cxx17_compat_constexpr_virtual);
1819 } else {
1821 return false;
1822
1823 Method = Method->getCanonicalDecl();
1824 Diag(Method->getLocation(), diag::err_constexpr_virtual);
1825
1826 // If it's not obvious why this function is virtual, find an overridden
1827 // function which uses the 'virtual' keyword.
1828 const CXXMethodDecl *WrittenVirtual = Method;
1829 while (!WrittenVirtual->isVirtualAsWritten())
1830 WrittenVirtual = *WrittenVirtual->begin_overridden_methods();
1831 if (WrittenVirtual != Method)
1832 Diag(WrittenVirtual->getLocation(),
1833 diag::note_overridden_virtual_function);
1834 return false;
1835 }
1836 }
1837
1838 // - its return type shall be a literal type; (removed in C++23)
1839 if (!getLangOpts().CPlusPlus23 &&
1840 !CheckConstexprReturnType(*this, NewFD, Kind))
1841 return false;
1842 }
1843
1844 if (auto *Dtor = dyn_cast<CXXDestructorDecl>(NewFD)) {
1845 // A destructor can be constexpr only if the defaulted destructor could be;
1846 // we don't need to check the members and bases if we already know they all
1847 // have constexpr destructors. (removed in C++23)
1848 if (!getLangOpts().CPlusPlus23 &&
1849 !Dtor->getParent()->defaultedDestructorIsConstexpr()) {
1851 return false;
1852 if (!CheckConstexprDestructorSubobjects(*this, Dtor, Kind))
1853 return false;
1854 }
1855 }
1856
1857 // - each of its parameter types shall be a literal type; (removed in C++23)
1858 if (!getLangOpts().CPlusPlus23 &&
1859 !CheckConstexprParameterTypes(*this, NewFD, Kind))
1860 return false;
1861
1862 Stmt *Body = NewFD->getBody();
1863 assert(Body &&
1864 "CheckConstexprFunctionDefinition called on function with no body");
1865 return CheckConstexprFunctionBody(*this, NewFD, Body, Kind);
1866}
1867
1868/// Check the given declaration statement is legal within a constexpr function
1869/// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.
1870///
1871/// \return true if the body is OK (maybe only as an extension), false if we
1872/// have diagnosed a problem.
1874 DeclStmt *DS, SourceLocation &Cxx1yLoc,
1876 // C++11 [dcl.constexpr]p3 and p4:
1877 // The definition of a constexpr function(p3) or constructor(p4) [...] shall
1878 // contain only
1879 for (const auto *DclIt : DS->decls()) {
1880 switch (DclIt->getKind()) {
1881 case Decl::StaticAssert:
1882 case Decl::Using:
1883 case Decl::UsingShadow:
1884 case Decl::UsingDirective:
1885 case Decl::UnresolvedUsingTypename:
1886 case Decl::UnresolvedUsingValue:
1887 case Decl::UsingEnum:
1888 // - static_assert-declarations
1889 // - using-declarations,
1890 // - using-directives,
1891 // - using-enum-declaration
1892 continue;
1893
1894 case Decl::Typedef:
1895 case Decl::TypeAlias: {
1896 // - typedef declarations and alias-declarations that do not define
1897 // classes or enumerations,
1898 const auto *TN = cast<TypedefNameDecl>(DclIt);
1899 if (TN->getUnderlyingType()->isVariablyModifiedType()) {
1900 // Don't allow variably-modified types in constexpr functions.
1902 TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
1903 SemaRef.Diag(TL.getBeginLoc(), diag::err_constexpr_vla)
1904 << TL.getSourceRange() << TL.getType()
1905 << isa<CXXConstructorDecl>(Dcl);
1906 }
1907 return false;
1908 }
1909 continue;
1910 }
1911
1912 case Decl::Enum:
1913 case Decl::CXXRecord:
1914 // C++1y allows types to be defined, not just declared.
1915 if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition()) {
1917 SemaRef.Diag(DS->getBeginLoc(),
1918 SemaRef.getLangOpts().CPlusPlus14
1919 ? diag::warn_cxx11_compat_constexpr_type_definition
1920 : diag::ext_constexpr_type_definition)
1921 << isa<CXXConstructorDecl>(Dcl);
1922 } else if (!SemaRef.getLangOpts().CPlusPlus14) {
1923 return false;
1924 }
1925 }
1926 continue;
1927
1928 case Decl::EnumConstant:
1929 case Decl::IndirectField:
1930 case Decl::ParmVar:
1931 // These can only appear with other declarations which are banned in
1932 // C++11 and permitted in C++1y, so ignore them.
1933 continue;
1934
1935 case Decl::Var:
1936 case Decl::Decomposition: {
1937 // C++1y [dcl.constexpr]p3 allows anything except:
1938 // a definition of a variable of non-literal type or of static or
1939 // thread storage duration or [before C++2a] for which no
1940 // initialization is performed.
1941 const auto *VD = cast<VarDecl>(DclIt);
1942 if (VD->isThisDeclarationADefinition()) {
1943 if (VD->isStaticLocal()) {
1945 SemaRef.Diag(VD->getLocation(),
1946 SemaRef.getLangOpts().CPlusPlus23
1947 ? diag::warn_cxx20_compat_constexpr_var
1948 : diag::ext_constexpr_static_var)
1949 << isa<CXXConstructorDecl>(Dcl)
1950 << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
1951 } else if (!SemaRef.getLangOpts().CPlusPlus23) {
1952 return false;
1953 }
1954 }
1955 if (SemaRef.LangOpts.CPlusPlus23) {
1956 CheckLiteralType(SemaRef, Kind, VD->getLocation(), VD->getType(),
1957 diag::warn_cxx20_compat_constexpr_var,
1958 isa<CXXConstructorDecl>(Dcl),
1959 /*variable of non-literal type*/ 2);
1960 } else if (CheckLiteralType(
1961 SemaRef, Kind, VD->getLocation(), VD->getType(),
1962 diag::err_constexpr_local_var_non_literal_type,
1963 isa<CXXConstructorDecl>(Dcl))) {
1964 return false;
1965 }
1966 if (!VD->getType()->isDependentType() &&
1967 !VD->hasInit() && !VD->isCXXForRangeDecl()) {
1969 SemaRef.Diag(
1970 VD->getLocation(),
1971 SemaRef.getLangOpts().CPlusPlus20
1972 ? diag::warn_cxx17_compat_constexpr_local_var_no_init
1973 : diag::ext_constexpr_local_var_no_init)
1974 << isa<CXXConstructorDecl>(Dcl);
1975 } else if (!SemaRef.getLangOpts().CPlusPlus20) {
1976 return false;
1977 }
1978 continue;
1979 }
1980 }
1982 SemaRef.Diag(VD->getLocation(),
1983 SemaRef.getLangOpts().CPlusPlus14
1984 ? diag::warn_cxx11_compat_constexpr_local_var
1985 : diag::ext_constexpr_local_var)
1986 << isa<CXXConstructorDecl>(Dcl);
1987 } else if (!SemaRef.getLangOpts().CPlusPlus14) {
1988 return false;
1989 }
1990 continue;
1991 }
1992
1993 case Decl::NamespaceAlias:
1994 case Decl::Function:
1995 // These are disallowed in C++11 and permitted in C++1y. Allow them
1996 // everywhere as an extension.
1997 if (!Cxx1yLoc.isValid())
1998 Cxx1yLoc = DS->getBeginLoc();
1999 continue;
2000
2001 default:
2003 SemaRef.Diag(DS->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
2004 << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval();
2005 }
2006 return false;
2007 }
2008 }
2009
2010 return true;
2011}
2012
2013/// Check that the given field is initialized within a constexpr constructor.
2014///
2015/// \param Dcl The constexpr constructor being checked.
2016/// \param Field The field being checked. This may be a member of an anonymous
2017/// struct or union nested within the class being checked.
2018/// \param Inits All declarations, including anonymous struct/union members and
2019/// indirect members, for which any initialization was provided.
2020/// \param Diagnosed Whether we've emitted the error message yet. Used to attach
2021/// multiple notes for different members to the same error.
2022/// \param Kind Whether we're diagnosing a constructor as written or determining
2023/// whether the formal requirements are satisfied.
2024/// \return \c false if we're checking for validity and the constructor does
2025/// not satisfy the requirements on a constexpr constructor.
2027 const FunctionDecl *Dcl,
2028 FieldDecl *Field,
2029 llvm::SmallSet<Decl*, 16> &Inits,
2030 bool &Diagnosed,
2032 // In C++20 onwards, there's nothing to check for validity.
2034 SemaRef.getLangOpts().CPlusPlus20)
2035 return true;
2036
2037 if (Field->isInvalidDecl())
2038 return true;
2039
2040 if (Field->isUnnamedBitField())
2041 return true;
2042
2043 // Anonymous unions with no variant members and empty anonymous structs do not
2044 // need to be explicitly initialized. FIXME: Anonymous structs that contain no
2045 // indirect fields don't need initializing.
2046 if (Field->isAnonymousStructOrUnion() &&
2047 (Field->getType()->isUnionType()
2048 ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
2049 : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
2050 return true;
2051
2052 if (!Inits.count(Field)) {
2054 if (!Diagnosed) {
2055 SemaRef.Diag(Dcl->getLocation(),
2056 SemaRef.getLangOpts().CPlusPlus20
2057 ? diag::warn_cxx17_compat_constexpr_ctor_missing_init
2058 : diag::ext_constexpr_ctor_missing_init);
2059 Diagnosed = true;
2060 }
2061 SemaRef.Diag(Field->getLocation(),
2062 diag::note_constexpr_ctor_missing_init);
2063 } else if (!SemaRef.getLangOpts().CPlusPlus20) {
2064 return false;
2065 }
2066 } else if (Field->isAnonymousStructOrUnion()) {
2067 const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
2068 for (auto *I : RD->fields())
2069 // If an anonymous union contains an anonymous struct of which any member
2070 // is initialized, all members must be initialized.
2071 if (!RD->isUnion() || Inits.count(I))
2072 if (!CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed,
2073 Kind))
2074 return false;
2075 }
2076 return true;
2077}
2078
2079/// Check the provided statement is allowed in a constexpr function
2080/// definition.
2081static bool
2084 SourceLocation &Cxx1yLoc, SourceLocation &Cxx2aLoc,
2085 SourceLocation &Cxx2bLoc,
2087 // - its function-body shall be [...] a compound-statement that contains only
2088 switch (S->getStmtClass()) {
2089 case Stmt::NullStmtClass:
2090 // - null statements,
2091 return true;
2092
2093 case Stmt::DeclStmtClass:
2094 // - static_assert-declarations
2095 // - using-declarations,
2096 // - using-directives,
2097 // - typedef declarations and alias-declarations that do not define
2098 // classes or enumerations,
2099 if (!CheckConstexprDeclStmt(SemaRef, Dcl, cast<DeclStmt>(S), Cxx1yLoc, Kind))
2100 return false;
2101 return true;
2102
2103 case Stmt::ReturnStmtClass:
2104 // - and exactly one return statement;
2105 if (isa<CXXConstructorDecl>(Dcl)) {
2106 // C++1y allows return statements in constexpr constructors.
2107 if (!Cxx1yLoc.isValid())
2108 Cxx1yLoc = S->getBeginLoc();
2109 return true;
2110 }
2111
2112 ReturnStmts.push_back(S->getBeginLoc());
2113 return true;
2114
2115 case Stmt::AttributedStmtClass:
2116 // Attributes on a statement don't affect its formal kind and hence don't
2117 // affect its validity in a constexpr function.
2119 SemaRef, Dcl, cast<AttributedStmt>(S)->getSubStmt(), ReturnStmts,
2120 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind);
2121
2122 case Stmt::CompoundStmtClass: {
2123 // C++1y allows compound-statements.
2124 if (!Cxx1yLoc.isValid())
2125 Cxx1yLoc = S->getBeginLoc();
2126
2127 CompoundStmt *CompStmt = cast<CompoundStmt>(S);
2128 for (auto *BodyIt : CompStmt->body()) {
2129 if (!CheckConstexprFunctionStmt(SemaRef, Dcl, BodyIt, ReturnStmts,
2130 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2131 return false;
2132 }
2133 return true;
2134 }
2135
2136 case Stmt::IfStmtClass: {
2137 // C++1y allows if-statements.
2138 if (!Cxx1yLoc.isValid())
2139 Cxx1yLoc = S->getBeginLoc();
2140
2141 IfStmt *If = cast<IfStmt>(S);
2142 if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
2143 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2144 return false;
2145 if (If->getElse() &&
2146 !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
2147 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2148 return false;
2149 return true;
2150 }
2151
2152 case Stmt::WhileStmtClass:
2153 case Stmt::DoStmtClass:
2154 case Stmt::ForStmtClass:
2155 case Stmt::CXXForRangeStmtClass:
2156 case Stmt::ContinueStmtClass:
2157 // C++1y allows all of these. We don't allow them as extensions in C++11,
2158 // because they don't make sense without variable mutation.
2159 if (!SemaRef.getLangOpts().CPlusPlus14)
2160 break;
2161 if (!Cxx1yLoc.isValid())
2162 Cxx1yLoc = S->getBeginLoc();
2163 for (Stmt *SubStmt : S->children()) {
2164 if (SubStmt &&
2165 !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2166 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2167 return false;
2168 }
2169 return true;
2170
2171 case Stmt::SwitchStmtClass:
2172 case Stmt::CaseStmtClass:
2173 case Stmt::DefaultStmtClass:
2174 case Stmt::BreakStmtClass:
2175 // C++1y allows switch-statements, and since they don't need variable
2176 // mutation, we can reasonably allow them in C++11 as an extension.
2177 if (!Cxx1yLoc.isValid())
2178 Cxx1yLoc = S->getBeginLoc();
2179 for (Stmt *SubStmt : S->children()) {
2180 if (SubStmt &&
2181 !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2182 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2183 return false;
2184 }
2185 return true;
2186
2187 case Stmt::LabelStmtClass:
2188 case Stmt::GotoStmtClass:
2189 if (Cxx2bLoc.isInvalid())
2190 Cxx2bLoc = S->getBeginLoc();
2191 for (Stmt *SubStmt : S->children()) {
2192 if (SubStmt &&
2193 !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2194 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2195 return false;
2196 }
2197 return true;
2198
2199 case Stmt::GCCAsmStmtClass:
2200 case Stmt::MSAsmStmtClass:
2201 // C++2a allows inline assembly statements.
2202 case Stmt::CXXTryStmtClass:
2203 if (Cxx2aLoc.isInvalid())
2204 Cxx2aLoc = S->getBeginLoc();
2205 for (Stmt *SubStmt : S->children()) {
2206 if (SubStmt &&
2207 !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2208 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2209 return false;
2210 }
2211 return true;
2212
2213 case Stmt::CXXCatchStmtClass:
2214 // Do not bother checking the language mode (already covered by the
2215 // try block check).
2217 SemaRef, Dcl, cast<CXXCatchStmt>(S)->getHandlerBlock(), ReturnStmts,
2218 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2219 return false;
2220 return true;
2221
2222 default:
2223 if (!isa<Expr>(S))
2224 break;
2225
2226 // C++1y allows expression-statements.
2227 if (!Cxx1yLoc.isValid())
2228 Cxx1yLoc = S->getBeginLoc();
2229 return true;
2230 }
2231
2233 SemaRef.Diag(S->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
2234 << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval();
2235 }
2236 return false;
2237}
2238
2239/// Check the body for the given constexpr function declaration only contains
2240/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.
2241///
2242/// \return true if the body is OK, false if we have found or diagnosed a
2243/// problem.
2245 Stmt *Body,
2248
2249 if (isa<CXXTryStmt>(Body)) {
2250 // C++11 [dcl.constexpr]p3:
2251 // The definition of a constexpr function shall satisfy the following
2252 // constraints: [...]
2253 // - its function-body shall be = delete, = default, or a
2254 // compound-statement
2255 //
2256 // C++11 [dcl.constexpr]p4:
2257 // In the definition of a constexpr constructor, [...]
2258 // - its function-body shall not be a function-try-block;
2259 //
2260 // This restriction is lifted in C++2a, as long as inner statements also
2261 // apply the general constexpr rules.
2262 switch (Kind) {
2264 if (!SemaRef.getLangOpts().CPlusPlus20)
2265 return false;
2266 break;
2267
2269 SemaRef.Diag(Body->getBeginLoc(),
2270 !SemaRef.getLangOpts().CPlusPlus20
2271 ? diag::ext_constexpr_function_try_block_cxx20
2272 : diag::warn_cxx17_compat_constexpr_function_try_block)
2273 << isa<CXXConstructorDecl>(Dcl);
2274 break;
2275 }
2276 }
2277
2278 // - its function-body shall be [...] a compound-statement that contains only
2279 // [... list of cases ...]
2280 //
2281 // Note that walking the children here is enough to properly check for
2282 // CompoundStmt and CXXTryStmt body.
2283 SourceLocation Cxx1yLoc, Cxx2aLoc, Cxx2bLoc;
2284 for (Stmt *SubStmt : Body->children()) {
2285 if (SubStmt &&
2286 !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
2287 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
2288 return false;
2289 }
2290
2292 // If this is only valid as an extension, report that we don't satisfy the
2293 // constraints of the current language.
2294 if ((Cxx2bLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus23) ||
2295 (Cxx2aLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus20) ||
2296 (Cxx1yLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus17))
2297 return false;
2298 } else if (Cxx2bLoc.isValid()) {
2299 SemaRef.Diag(Cxx2bLoc,
2300 SemaRef.getLangOpts().CPlusPlus23
2301 ? diag::warn_cxx20_compat_constexpr_body_invalid_stmt
2302 : diag::ext_constexpr_body_invalid_stmt_cxx23)
2303 << isa<CXXConstructorDecl>(Dcl);
2304 } else if (Cxx2aLoc.isValid()) {
2305 SemaRef.Diag(Cxx2aLoc,
2306 SemaRef.getLangOpts().CPlusPlus20
2307 ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt
2308 : diag::ext_constexpr_body_invalid_stmt_cxx20)
2309 << isa<CXXConstructorDecl>(Dcl);
2310 } else if (Cxx1yLoc.isValid()) {
2311 SemaRef.Diag(Cxx1yLoc,
2312 SemaRef.getLangOpts().CPlusPlus14
2313 ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
2314 : diag::ext_constexpr_body_invalid_stmt)
2315 << isa<CXXConstructorDecl>(Dcl);
2316 }
2317
2318 if (const CXXConstructorDecl *Constructor
2319 = dyn_cast<CXXConstructorDecl>(Dcl)) {
2320 const CXXRecordDecl *RD = Constructor->getParent();
2321 // DR1359:
2322 // - every non-variant non-static data member and base class sub-object
2323 // shall be initialized;
2324 // DR1460:
2325 // - if the class is a union having variant members, exactly one of them
2326 // shall be initialized;
2327 if (RD->isUnion()) {
2328 if (Constructor->getNumCtorInitializers() == 0 &&
2329 RD->hasVariantMembers()) {
2331 SemaRef.Diag(
2332 Dcl->getLocation(),
2333 SemaRef.getLangOpts().CPlusPlus20
2334 ? diag::warn_cxx17_compat_constexpr_union_ctor_no_init
2335 : diag::ext_constexpr_union_ctor_no_init);
2336 } else if (!SemaRef.getLangOpts().CPlusPlus20) {
2337 return false;
2338 }
2339 }
2340 } else if (!Constructor->isDependentContext() &&
2341 !Constructor->isDelegatingConstructor()) {
2342 assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases");
2343
2344 // Skip detailed checking if we have enough initializers, and we would
2345 // allow at most one initializer per member.
2346 bool AnyAnonStructUnionMembers = false;
2347 unsigned Fields = 0;
2349 E = RD->field_end(); I != E; ++I, ++Fields) {
2350 if (I->isAnonymousStructOrUnion()) {
2351 AnyAnonStructUnionMembers = true;
2352 break;
2353 }
2354 }
2355 // DR1460:
2356 // - if the class is a union-like class, but is not a union, for each of
2357 // its anonymous union members having variant members, exactly one of
2358 // them shall be initialized;
2359 if (AnyAnonStructUnionMembers ||
2360 Constructor->getNumCtorInitializers() != RD->getNumBases() + Fields) {
2361 // Check initialization of non-static data members. Base classes are
2362 // always initialized so do not need to be checked. Dependent bases
2363 // might not have initializers in the member initializer list.
2364 llvm::SmallSet<Decl*, 16> Inits;
2365 for (const auto *I: Constructor->inits()) {
2366 if (FieldDecl *FD = I->getMember())
2367 Inits.insert(FD);
2368 else if (IndirectFieldDecl *ID = I->getIndirectMember())
2369 Inits.insert(ID->chain_begin(), ID->chain_end());
2370 }
2371
2372 bool Diagnosed = false;
2373 for (auto *I : RD->fields())
2374 if (!CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed,
2375 Kind))
2376 return false;
2377 }
2378 }
2379 } else {
2380 if (ReturnStmts.empty()) {
2381 switch (Kind) {
2384 return false;
2385 break;
2386
2388 // The formal requirements don't include this rule in C++14, even
2389 // though the "must be able to produce a constant expression" rules
2390 // still imply it in some cases.
2391 if (!SemaRef.getLangOpts().CPlusPlus14)
2392 return false;
2393 break;
2394 }
2395 } else if (ReturnStmts.size() > 1) {
2396 switch (Kind) {
2398 SemaRef.Diag(
2399 ReturnStmts.back(),
2400 SemaRef.getLangOpts().CPlusPlus14
2401 ? diag::warn_cxx11_compat_constexpr_body_multiple_return
2402 : diag::ext_constexpr_body_multiple_return);
2403 for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
2404 SemaRef.Diag(ReturnStmts[I],
2405 diag::note_constexpr_body_previous_return);
2406 break;
2407
2409 if (!SemaRef.getLangOpts().CPlusPlus14)
2410 return false;
2411 break;
2412 }
2413 }
2414 }
2415
2416 // C++11 [dcl.constexpr]p5:
2417 // if no function argument values exist such that the function invocation
2418 // substitution would produce a constant expression, the program is
2419 // ill-formed; no diagnostic required.
2420 // C++11 [dcl.constexpr]p3:
2421 // - every constructor call and implicit conversion used in initializing the
2422 // return value shall be one of those allowed in a constant expression.
2423 // C++11 [dcl.constexpr]p4:
2424 // - every constructor involved in initializing non-static data members and
2425 // base class sub-objects shall be a constexpr constructor.
2426 //
2427 // Note that this rule is distinct from the "requirements for a constexpr
2428 // function", so is not checked in CheckValid mode. Because the check for
2429 // constexpr potential is expensive, skip the check if the diagnostic is
2430 // disabled, the function is declared in a system header, or we're in C++23
2431 // or later mode (see https://wg21.link/P2448).
2432 bool SkipCheck =
2433 !SemaRef.getLangOpts().CheckConstexprFunctionBodies ||
2436 diag::ext_constexpr_function_never_constant_expr, Dcl->getLocation());
2438 if (Kind == Sema::CheckConstexprKind::Diagnose && !SkipCheck &&
2440 SemaRef.Diag(Dcl->getLocation(),
2441 diag::ext_constexpr_function_never_constant_expr)
2442 << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval()
2443 << Dcl->getNameInfo().getSourceRange();
2444 for (size_t I = 0, N = Diags.size(); I != N; ++I)
2445 SemaRef.Diag(Diags[I].first, Diags[I].second);
2446 // Don't return false here: we allow this for compatibility in
2447 // system headers.
2448 }
2449
2450 return true;
2451}
2452
2454 const FunctionDecl *Dcl) {
2455 bool IsVoidOrDependentType = Dcl->getReturnType()->isVoidType() ||
2457 // Skip emitting a missing return error diagnostic for non-void functions
2458 // since C++23 no longer mandates constexpr functions to yield constant
2459 // expressions.
2460 if (SemaRef.getLangOpts().CPlusPlus23 && !IsVoidOrDependentType)
2461 return true;
2462
2463 // C++14 doesn't require constexpr functions to contain a 'return'
2464 // statement. We still do, unless the return type might be void, because
2465 // otherwise if there's no return statement, the function cannot
2466 // be used in a core constant expression.
2467 bool OK = SemaRef.getLangOpts().CPlusPlus14 && IsVoidOrDependentType;
2468 SemaRef.Diag(Dcl->getLocation(),
2469 OK ? diag::warn_cxx11_compat_constexpr_body_no_return
2470 : diag::err_constexpr_body_no_return)
2471 << Dcl->isConsteval();
2472 return OK;
2473}
2474
2476 FunctionDecl *FD, const sema::FunctionScopeInfo *FSI) {
2478 return true;
2482 auto it = UndefinedButUsed.find(FD->getCanonicalDecl());
2483 if (it != UndefinedButUsed.end()) {
2484 Diag(it->second, diag::err_immediate_function_used_before_definition)
2485 << it->first;
2486 Diag(FD->getLocation(), diag::note_defined_here) << FD;
2487 if (FD->isImmediateFunction() && !FD->isConsteval())
2489 return false;
2490 }
2491 }
2492 return true;
2493}
2494
2496 assert(FD->isImmediateEscalating() && !FD->isConsteval() &&
2497 "expected an immediate function");
2498 assert(FD->hasBody() && "expected the function to have a body");
2499 struct ImmediateEscalatingExpressionsVisitor : DynamicRecursiveASTVisitor {
2500 Sema &SemaRef;
2501
2502 const FunctionDecl *ImmediateFn;
2503 bool ImmediateFnIsConstructor;
2504 CXXConstructorDecl *CurrentConstructor = nullptr;
2505 CXXCtorInitializer *CurrentInit = nullptr;
2506
2507 ImmediateEscalatingExpressionsVisitor(Sema &SemaRef, FunctionDecl *FD)
2508 : SemaRef(SemaRef), ImmediateFn(FD),
2509 ImmediateFnIsConstructor(isa<CXXConstructorDecl>(FD)) {
2510 ShouldVisitImplicitCode = true;
2511 ShouldVisitLambdaBody = false;
2512 }
2513
2514 void Diag(const Expr *E, const FunctionDecl *Fn, bool IsCall) {
2517 if (CurrentConstructor && CurrentInit) {
2518 Loc = CurrentConstructor->getLocation();
2519 Range = CurrentInit->isWritten() ? CurrentInit->getSourceRange()
2520 : SourceRange();
2521 }
2522
2523 FieldDecl* InitializedField = CurrentInit ? CurrentInit->getAnyMember() : nullptr;
2524
2525 SemaRef.Diag(Loc, diag::note_immediate_function_reason)
2526 << ImmediateFn << Fn << Fn->isConsteval() << IsCall
2527 << isa<CXXConstructorDecl>(Fn) << ImmediateFnIsConstructor
2528 << (InitializedField != nullptr)
2529 << (CurrentInit && !CurrentInit->isWritten())
2530 << InitializedField << Range;
2531 }
2532 bool TraverseCallExpr(CallExpr *E) override {
2533 if (const auto *DR =
2534 dyn_cast<DeclRefExpr>(E->getCallee()->IgnoreImplicit());
2535 DR && DR->isImmediateEscalating()) {
2536 Diag(E, E->getDirectCallee(), /*IsCall=*/true);
2537 return false;
2538 }
2539
2540 for (Expr *A : E->arguments())
2541 if (!TraverseStmt(A))
2542 return false;
2543
2544 return true;
2545 }
2546
2547 bool VisitDeclRefExpr(DeclRefExpr *E) override {
2548 if (const auto *ReferencedFn = dyn_cast<FunctionDecl>(E->getDecl());
2549 ReferencedFn && E->isImmediateEscalating()) {
2550 Diag(E, ReferencedFn, /*IsCall=*/false);
2551 return false;
2552 }
2553
2554 return true;
2555 }
2556
2557 bool VisitCXXConstructExpr(CXXConstructExpr *E) override {
2558 CXXConstructorDecl *D = E->getConstructor();
2559 if (E->isImmediateEscalating()) {
2560 Diag(E, D, /*IsCall=*/true);
2561 return false;
2562 }
2563 return true;
2564 }
2565
2566 bool TraverseConstructorInitializer(CXXCtorInitializer *Init) override {
2567 llvm::SaveAndRestore RAII(CurrentInit, Init);
2569 }
2570
2571 bool TraverseCXXConstructorDecl(CXXConstructorDecl *Ctr) override {
2572 llvm::SaveAndRestore RAII(CurrentConstructor, Ctr);
2573 return DynamicRecursiveASTVisitor::TraverseCXXConstructorDecl(Ctr);
2574 }
2575
2576 bool TraverseType(QualType T) override { return true; }
2577 bool VisitBlockExpr(BlockExpr *T) override { return true; }
2578
2579 } Visitor(*this, FD);
2580 Visitor.TraverseDecl(FD);
2581}
2582
2584 assert(getLangOpts().CPlusPlus && "No class names in C!");
2585
2586 if (SS && SS->isInvalid())
2587 return nullptr;
2588
2589 if (SS && SS->isNotEmpty()) {
2590 DeclContext *DC = computeDeclContext(*SS, true);
2591 return dyn_cast_or_null<CXXRecordDecl>(DC);
2592 }
2593
2594 return dyn_cast_or_null<CXXRecordDecl>(CurContext);
2595}
2596
2598 const CXXScopeSpec *SS) {
2599 CXXRecordDecl *CurDecl = getCurrentClass(S, SS);
2600 return CurDecl && &II == CurDecl->getIdentifier();
2601}
2602
2604 assert(getLangOpts().CPlusPlus && "No class names in C!");
2605
2606 if (!getLangOpts().SpellChecking)
2607 return false;
2608
2609 CXXRecordDecl *CurDecl;
2610 if (SS && SS->isSet() && !SS->isInvalid()) {
2611 DeclContext *DC = computeDeclContext(*SS, true);
2612 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
2613 } else
2614 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
2615
2616 if (CurDecl && CurDecl->getIdentifier() && II != CurDecl->getIdentifier() &&
2617 3 * II->getName().edit_distance(CurDecl->getIdentifier()->getName())
2618 < II->getLength()) {
2619 II = CurDecl->getIdentifier();
2620 return true;
2621 }
2622
2623 return false;
2624}
2625
2627 SourceRange SpecifierRange,
2628 bool Virtual, AccessSpecifier Access,
2629 TypeSourceInfo *TInfo,
2630 SourceLocation EllipsisLoc) {
2631 QualType BaseType = TInfo->getType();
2632 SourceLocation BaseLoc = TInfo->getTypeLoc().getBeginLoc();
2633 if (BaseType->containsErrors()) {
2634 // Already emitted a diagnostic when parsing the error type.
2635 return nullptr;
2636 }
2637
2638 if (EllipsisLoc.isValid() && !BaseType->containsUnexpandedParameterPack()) {
2639 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
2640 << TInfo->getTypeLoc().getSourceRange();
2641 EllipsisLoc = SourceLocation();
2642 }
2643
2644 auto *BaseDecl =
2645 dyn_cast_if_present<CXXRecordDecl>(computeDeclContext(BaseType));
2646 // C++ [class.derived.general]p2:
2647 // A class-or-decltype shall denote a (possibly cv-qualified) class type
2648 // that is not an incompletely defined class; any cv-qualifiers are
2649 // ignored.
2650 if (BaseDecl) {
2651 // C++ [class.union.general]p4:
2652 // [...] A union shall not be used as a base class.
2653 if (BaseDecl->isUnion()) {
2654 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
2655 return nullptr;
2656 }
2657
2658 // For the MS ABI, propagate DLL attributes to base class templates.
2660 Context.getTargetInfo().getTriple().isPS()) {
2661 if (Attr *ClassAttr = getDLLAttr(Class)) {
2662 if (auto *BaseSpec =
2663 dyn_cast<ClassTemplateSpecializationDecl>(BaseDecl)) {
2664 propagateDLLAttrToBaseClassTemplate(Class, ClassAttr, BaseSpec,
2665 BaseLoc);
2666 }
2667 }
2668 }
2669
2670 if (RequireCompleteType(BaseLoc, BaseType, diag::err_incomplete_base_class,
2671 SpecifierRange)) {
2672 Class->setInvalidDecl();
2673 return nullptr;
2674 }
2675
2676 BaseDecl = BaseDecl->getDefinition();
2677 assert(BaseDecl && "Base type is not incomplete, but has no definition");
2678
2679 // Microsoft docs say:
2680 // "If a base-class has a code_seg attribute, derived classes must have the
2681 // same attribute."
2682 const auto *BaseCSA = BaseDecl->getAttr<CodeSegAttr>();
2683 const auto *DerivedCSA = Class->getAttr<CodeSegAttr>();
2684 if ((DerivedCSA || BaseCSA) &&
2685 (!BaseCSA || !DerivedCSA ||
2686 BaseCSA->getName() != DerivedCSA->getName())) {
2687 Diag(Class->getLocation(), diag::err_mismatched_code_seg_base);
2688 Diag(BaseDecl->getLocation(), diag::note_base_class_specified_here)
2689 << BaseDecl;
2690 return nullptr;
2691 }
2692
2693 // A class which contains a flexible array member is not suitable for use as
2694 // a base class:
2695 // - If the layout determines that a base comes before another base,
2696 // the flexible array member would index into the subsequent base.
2697 // - If the layout determines that base comes before the derived class,
2698 // the flexible array member would index into the derived class.
2699 if (BaseDecl->hasFlexibleArrayMember()) {
2700 Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
2701 << BaseDecl->getDeclName();
2702 return nullptr;
2703 }
2704
2705 // C++ [class]p3:
2706 // If a class is marked final and it appears as a base-type-specifier in
2707 // base-clause, the program is ill-formed.
2708 if (FinalAttr *FA = BaseDecl->getAttr<FinalAttr>()) {
2709 Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
2710 << BaseDecl->getDeclName() << FA->isSpelledAsSealed();
2711 Diag(BaseDecl->getLocation(), diag::note_entity_declared_at)
2712 << BaseDecl->getDeclName() << FA->getRange();
2713 return nullptr;
2714 }
2715
2716 // If the base class is invalid the derived class is as well.
2717 if (BaseDecl->isInvalidDecl())
2718 Class->setInvalidDecl();
2719 } else if (BaseType->isDependentType()) {
2720 // Make sure that we don't make an ill-formed AST where the type of the
2721 // Class is non-dependent and its attached base class specifier is an
2722 // dependent type, which violates invariants in many clang code paths (e.g.
2723 // constexpr evaluator). If this case happens (in errory-recovery mode), we
2724 // explicitly mark the Class decl invalid. The diagnostic was already
2725 // emitted.
2726 if (!Class->isDependentContext())
2727 Class->setInvalidDecl();
2728 } else {
2729 // The base class is some non-dependent non-class type.
2730 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
2731 return nullptr;
2732 }
2733
2734 // In HLSL, unspecified class access is public rather than private.
2735 if (getLangOpts().HLSL && Class->getTagKind() == TagTypeKind::Class &&
2736 Access == AS_none)
2737 Access = AS_public;
2738
2739 // Create the base specifier.
2740 return new (Context) CXXBaseSpecifier(
2741 SpecifierRange, Virtual, Class->getTagKind() == TagTypeKind::Class,
2742 Access, TInfo, EllipsisLoc);
2743}
2744
2746 const ParsedAttributesView &Attributes,
2747 bool Virtual, AccessSpecifier Access,
2748 ParsedType basetype, SourceLocation BaseLoc,
2749 SourceLocation EllipsisLoc) {
2750 if (!classdecl)
2751 return true;
2752
2753 AdjustDeclIfTemplate(classdecl);
2754 CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl);
2755 if (!Class)
2756 return true;
2757
2758 // We haven't yet attached the base specifiers.
2759 Class->setIsParsingBaseSpecifiers();
2760
2761 // We do not support any C++11 attributes on base-specifiers yet.
2762 // Diagnose any attributes we see.
2763 for (const ParsedAttr &AL : Attributes) {
2764 if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute)
2765 continue;
2766 if (AL.getKind() == ParsedAttr::UnknownAttribute)
2767 Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
2768 << AL << AL.getRange();
2769 else
2770 Diag(AL.getLoc(), diag::err_base_specifier_attribute)
2771 << AL << AL.isRegularKeywordAttribute() << AL.getRange();
2772 }
2773
2774 TypeSourceInfo *TInfo = nullptr;
2775 GetTypeFromParser(basetype, &TInfo);
2776
2777 if (EllipsisLoc.isInvalid() &&
2778 DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo,
2780 return true;
2781
2782 // C++ [class.union.general]p4:
2783 // [...] A union shall not have base classes.
2784 if (Class->isUnion()) {
2785 Diag(Class->getLocation(), diag::err_base_clause_on_union)
2786 << SpecifierRange;
2787 return true;
2788 }
2789
2790 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
2791 Virtual, Access, TInfo,
2792 EllipsisLoc))
2793 return BaseSpec;
2794
2795 Class->setInvalidDecl();
2796 return true;
2797}
2798
2799/// Use small set to collect indirect bases. As this is only used
2800/// locally, there's no need to abstract the small size parameter.
2802
2803/// Recursively add the bases of Type. Don't add Type itself.
2804static void
2806 const QualType &Type)
2807{
2808 // Even though the incoming type is a base, it might not be
2809 // a class -- it could be a template parm, for instance.
2810 if (auto Rec = Type->getAs<RecordType>()) {
2811 auto Decl = Rec->getAsCXXRecordDecl();
2812
2813 // Iterate over its bases.
2814 for (const auto &BaseSpec : Decl->bases()) {
2815 QualType Base = Context.getCanonicalType(BaseSpec.getType())
2817 if (Set.insert(Base).second)
2818 // If we've not already seen it, recurse.
2820 }
2821 }
2822}
2823
2826 if (Bases.empty())
2827 return false;
2828
2829 // Used to keep track of which base types we have already seen, so
2830 // that we can properly diagnose redundant direct base types. Note
2831 // that the key is always the unqualified canonical type of the base
2832 // class.
2833 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
2834
2835 // Used to track indirect bases so we can see if a direct base is
2836 // ambiguous.
2837 IndirectBaseSet IndirectBaseTypes;
2838
2839 // Copy non-redundant base specifiers into permanent storage.
2840 unsigned NumGoodBases = 0;
2841 bool Invalid = false;
2842 for (unsigned idx = 0; idx < Bases.size(); ++idx) {
2843 QualType NewBaseType
2844 = Context.getCanonicalType(Bases[idx]->getType());
2845 NewBaseType = NewBaseType.getLocalUnqualifiedType();
2846
2847 CXXBaseSpecifier *&KnownBase = KnownBaseTypes[NewBaseType];
2848 if (KnownBase) {
2849 // C++ [class.mi]p3:
2850 // A class shall not be specified as a direct base class of a
2851 // derived class more than once.
2852 Diag(Bases[idx]->getBeginLoc(), diag::err_duplicate_base_class)
2853 << KnownBase->getType() << Bases[idx]->getSourceRange();
2854
2855 // Delete the duplicate base class specifier; we're going to
2856 // overwrite its pointer later.
2857 Context.Deallocate(Bases[idx]);
2858
2859 Invalid = true;
2860 } else {
2861 // Okay, add this new base class.
2862 KnownBase = Bases[idx];
2863 Bases[NumGoodBases++] = Bases[idx];
2864
2865 if (NewBaseType->isDependentType())
2866 continue;
2867 // Note this base's direct & indirect bases, if there could be ambiguity.
2868 if (Bases.size() > 1)
2869 NoteIndirectBases(Context, IndirectBaseTypes, NewBaseType);
2870
2871 if (const RecordType *Record = NewBaseType->getAs<RecordType>()) {
2872 const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
2873 if (Class->isInterface() &&
2874 (!RD->isInterfaceLike() ||
2875 KnownBase->getAccessSpecifier() != AS_public)) {
2876 // The Microsoft extension __interface does not permit bases that
2877 // are not themselves public interfaces.
2878 Diag(KnownBase->getBeginLoc(), diag::err_invalid_base_in_interface)
2879 << getRecordDiagFromTagKind(RD->getTagKind()) << RD
2880 << RD->getSourceRange();
2881 Invalid = true;
2882 }
2883 if (RD->hasAttr<WeakAttr>())
2884 Class->addAttr(WeakAttr::CreateImplicit(Context));
2885 }
2886 }
2887 }
2888
2889 // Attach the remaining base class specifiers to the derived class.
2890 Class->setBases(Bases.data(), NumGoodBases);
2891
2892 // Check that the only base classes that are duplicate are virtual.
2893 for (unsigned idx = 0; idx < NumGoodBases; ++idx) {
2894 // Check whether this direct base is inaccessible due to ambiguity.
2895 QualType BaseType = Bases[idx]->getType();
2896
2897 // Skip all dependent types in templates being used as base specifiers.
2898 // Checks below assume that the base specifier is a CXXRecord.
2899 if (BaseType->isDependentType())
2900 continue;
2901
2902 CanQualType CanonicalBase = Context.getCanonicalType(BaseType)
2904
2905 if (IndirectBaseTypes.count(CanonicalBase)) {
2906 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
2907 /*DetectVirtual=*/true);
2908 bool found
2909 = Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
2910 assert(found);
2911 (void)found;
2912
2913 if (Paths.isAmbiguous(CanonicalBase))
2914 Diag(Bases[idx]->getBeginLoc(), diag::warn_inaccessible_base_class)
2915 << BaseType << getAmbiguousPathsDisplayString(Paths)
2916 << Bases[idx]->getSourceRange();
2917 else
2918 assert(Bases[idx]->isVirtual());
2919 }
2920
2921 // Delete the base class specifier, since its data has been copied
2922 // into the CXXRecordDecl.
2923 Context.Deallocate(Bases[idx]);
2924 }
2925
2926 return Invalid;
2927}
2928
2931 if (!ClassDecl || Bases.empty())
2932 return;
2933
2934 AdjustDeclIfTemplate(ClassDecl);
2935 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), Bases);
2936}
2937
2939 if (!getLangOpts().CPlusPlus)
2940 return false;
2941
2942 CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
2943 if (!DerivedRD)
2944 return false;
2945
2946 CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
2947 if (!BaseRD)
2948 return false;
2949
2950 // If either the base or the derived type is invalid, don't try to
2951 // check whether one is derived from the other.
2952 if (BaseRD->isInvalidDecl() || DerivedRD->isInvalidDecl())
2953 return false;
2954
2955 // FIXME: In a modules build, do we need the entire path to be visible for us
2956 // to be able to use the inheritance relationship?
2957 if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
2958 return false;
2959
2960 return DerivedRD->isDerivedFrom(BaseRD);
2961}
2962
2964 CXXBasePaths &Paths) {
2965 if (!getLangOpts().CPlusPlus)
2966 return false;
2967
2968 CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
2969 if (!DerivedRD)
2970 return false;
2971
2972 CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
2973 if (!BaseRD)
2974 return false;
2975
2976 if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
2977 return false;
2978
2979 return DerivedRD->isDerivedFrom(BaseRD, Paths);
2980}
2981
2983 CXXCastPath &BasePathArray) {
2984 // We first go backward and check if we have a virtual base.
2985 // FIXME: It would be better if CXXBasePath had the base specifier for
2986 // the nearest virtual base.
2987 unsigned Start = 0;
2988 for (unsigned I = Path.size(); I != 0; --I) {
2989 if (Path[I - 1].Base->isVirtual()) {
2990 Start = I - 1;
2991 break;
2992 }
2993 }
2994
2995 // Now add all bases.
2996 for (unsigned I = Start, E = Path.size(); I != E; ++I)
2997 BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
2998}
2999
3000
3002 CXXCastPath &BasePathArray) {
3003 assert(BasePathArray.empty() && "Base path array must be empty!");
3004 assert(Paths.isRecordingPaths() && "Must record paths!");
3005 return ::BuildBasePathArray(Paths.front(), BasePathArray);
3006}
3007
3008bool
3010 unsigned InaccessibleBaseID,
3011 unsigned AmbiguousBaseConvID,
3013 DeclarationName Name,
3014 CXXCastPath *BasePath,
3015 bool IgnoreAccess) {
3016 // First, determine whether the path from Derived to Base is
3017 // ambiguous. This is slightly more expensive than checking whether
3018 // the Derived to Base conversion exists, because here we need to
3019 // explore multiple paths to determine if there is an ambiguity.
3020 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3021 /*DetectVirtual=*/false);
3022 bool DerivationOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
3023 if (!DerivationOkay)
3024 return true;
3025
3026 const CXXBasePath *Path = nullptr;
3027 if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType()))
3028 Path = &Paths.front();
3029
3030 // For MSVC compatibility, check if Derived directly inherits from Base. Clang
3031 // warns about this hierarchy under -Winaccessible-base, but MSVC allows the
3032 // user to access such bases.
3033 if (!Path && getLangOpts().MSVCCompat) {
3034 for (const CXXBasePath &PossiblePath : Paths) {
3035 if (PossiblePath.size() == 1) {
3036 Path = &PossiblePath;
3037 if (AmbiguousBaseConvID)
3038 Diag(Loc, diag::ext_ms_ambiguous_direct_base)
3039 << Base << Derived << Range;
3040 break;
3041 }
3042 }
3043 }
3044
3045 if (Path) {
3046 if (!IgnoreAccess) {
3047 // Check that the base class can be accessed.
3048 switch (
3049 CheckBaseClassAccess(Loc, Base, Derived, *Path, InaccessibleBaseID)) {
3050 case AR_inaccessible:
3051 return true;
3052 case AR_accessible:
3053 case AR_dependent:
3054 case AR_delayed:
3055 break;
3056 }
3057 }
3058
3059 // Build a base path if necessary.
3060 if (BasePath)
3061 ::BuildBasePathArray(*Path, *BasePath);
3062 return false;
3063 }
3064
3065 if (AmbiguousBaseConvID) {
3066 // We know that the derived-to-base conversion is ambiguous, and
3067 // we're going to produce a diagnostic. Perform the derived-to-base
3068 // search just one more time to compute all of the possible paths so
3069 // that we can print them out. This is more expensive than any of
3070 // the previous derived-to-base checks we've done, but at this point
3071 // performance isn't as much of an issue.
3072 Paths.clear();
3073 Paths.setRecordingPaths(true);
3074 bool StillOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
3075 assert(StillOkay && "Can only be used with a derived-to-base conversion");
3076 (void)StillOkay;
3077
3078 // Build up a textual representation of the ambiguous paths, e.g.,
3079 // D -> B -> A, that will be used to illustrate the ambiguous
3080 // conversions in the diagnostic. We only print one of the paths
3081 // to each base class subobject.
3082 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
3083
3084 Diag(Loc, AmbiguousBaseConvID)
3085 << Derived << Base << PathDisplayStr << Range << Name;
3086 }
3087 return true;
3088}
3089
3090bool
3093 CXXCastPath *BasePath,
3094 bool IgnoreAccess) {
3096 Derived, Base, diag::err_upcast_to_inaccessible_base,
3097 diag::err_ambiguous_derived_to_base_conv, Loc, Range, DeclarationName(),
3098 BasePath, IgnoreAccess);
3099}
3100
3102 std::string PathDisplayStr;
3103 std::set<unsigned> DisplayedPaths;
3104 for (CXXBasePaths::paths_iterator Path = Paths.begin();
3105 Path != Paths.end(); ++Path) {
3106 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
3107 // We haven't displayed a path to this particular base
3108 // class subobject yet.
3109 PathDisplayStr += "\n ";
3110 PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
3111 for (CXXBasePath::const_iterator Element = Path->begin();
3112 Element != Path->end(); ++Element)
3113 PathDisplayStr += " -> " + Element->Base->getType().getAsString();
3114 }
3115 }
3116
3117 return PathDisplayStr;
3118}
3119
3120//===----------------------------------------------------------------------===//
3121// C++ class member Handling
3122//===----------------------------------------------------------------------===//
3123
3125 SourceLocation ColonLoc,
3126 const ParsedAttributesView &Attrs) {
3127 assert(Access != AS_none && "Invalid kind for syntactic access specifier!");
3129 ASLoc, ColonLoc);
3130 CurContext->addHiddenDecl(ASDecl);
3131 return ProcessAccessDeclAttributeList(ASDecl, Attrs);
3132}
3133
3135 if (D->isInvalidDecl())
3136 return;
3137
3138 // We only care about "override" and "final" declarations.
3139 if (!D->hasAttr<OverrideAttr>() && !D->hasAttr<FinalAttr>())
3140 return;
3141
3142 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
3143
3144 // We can't check dependent instance methods.
3145 if (MD && MD->isInstance() &&
3146 (MD->getParent()->hasAnyDependentBases() ||
3147 MD->getType()->isDependentType()))
3148 return;
3149
3150 if (MD && !MD->isVirtual()) {
3151 // If we have a non-virtual method, check if it hides a virtual method.
3152 // (In that case, it's most likely the method has the wrong type.)
3153 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
3154 FindHiddenVirtualMethods(MD, OverloadedMethods);
3155
3156 if (!OverloadedMethods.empty()) {
3157 if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
3158 Diag(OA->getLocation(),
3159 diag::override_keyword_hides_virtual_member_function)
3160 << "override" << (OverloadedMethods.size() > 1);
3161 } else if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
3162 Diag(FA->getLocation(),
3163 diag::override_keyword_hides_virtual_member_function)
3164 << (FA->isSpelledAsSealed() ? "sealed" : "final")
3165 << (OverloadedMethods.size() > 1);
3166 }
3167 NoteHiddenVirtualMethods(MD, OverloadedMethods);
3168 MD->setInvalidDecl();
3169 return;
3170 }
3171 // Fall through into the general case diagnostic.
3172 // FIXME: We might want to attempt typo correction here.
3173 }
3174
3175 if (!MD || !MD->isVirtual()) {
3176 if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
3177 Diag(OA->getLocation(),
3178 diag::override_keyword_only_allowed_on_virtual_member_functions)
3179 << "override" << FixItHint::CreateRemoval(OA->getLocation());
3180 D->dropAttr<OverrideAttr>();
3181 }
3182 if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
3183 Diag(FA->getLocation(),
3184 diag::override_keyword_only_allowed_on_virtual_member_functions)
3185 << (FA->isSpelledAsSealed() ? "sealed" : "final")
3186 << FixItHint::CreateRemoval(FA->getLocation());
3187 D->dropAttr<FinalAttr>();
3188 }
3189 return;
3190 }
3191
3192 // C++11 [class.virtual]p5:
3193 // If a function is marked with the virt-specifier override and
3194 // does not override a member function of a base class, the program is
3195 // ill-formed.
3196 bool HasOverriddenMethods = MD->size_overridden_methods() != 0;
3197 if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)
3198 Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding)
3199 << MD->getDeclName();
3200}
3201
3203 if (D->isInvalidDecl() || D->hasAttr<OverrideAttr>())
3204 return;
3205 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
3206 if (!MD || MD->isImplicit() || MD->hasAttr<FinalAttr>())
3207 return;
3208
3210 SourceLocation SpellingLoc = Loc;
3211 if (getSourceManager().isMacroArgExpansion(Loc))
3213 SpellingLoc = getSourceManager().getSpellingLoc(SpellingLoc);
3214 if (SpellingLoc.isValid() && getSourceManager().isInSystemHeader(SpellingLoc))
3215 return;
3216
3217 if (MD->size_overridden_methods() > 0) {
3218 auto EmitDiag = [&](unsigned DiagInconsistent, unsigned DiagSuggest) {
3219 unsigned DiagID =
3220 Inconsistent && !Diags.isIgnored(DiagInconsistent, MD->getLocation())
3221 ? DiagInconsistent
3222 : DiagSuggest;
3223 Diag(MD->getLocation(), DiagID) << MD->getDeclName();
3224 const CXXMethodDecl *OMD = *MD->begin_overridden_methods();
3225 Diag(OMD->getLocation(), diag::note_overridden_virtual_function);
3226 };
3227 if (isa<CXXDestructorDecl>(MD))
3228 EmitDiag(
3229 diag::warn_inconsistent_destructor_marked_not_override_overriding,
3230 diag::warn_suggest_destructor_marked_not_override_overriding);
3231 else
3232 EmitDiag(diag::warn_inconsistent_function_marked_not_override_overriding,
3233 diag::warn_suggest_function_marked_not_override_overriding);
3234 }
3235}
3236
3238 const CXXMethodDecl *Old) {
3239 FinalAttr *FA = Old->getAttr<FinalAttr>();
3240 if (!FA)
3241 return false;
3242
3243 Diag(New->getLocation(), diag::err_final_function_overridden)
3244 << New->getDeclName()
3245 << FA->isSpelledAsSealed();
3246 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
3247 return true;
3248}
3249
3251 const Type *T = FD.getType()->getBaseElementTypeUnsafe();
3252 // FIXME: Destruction of ObjC lifetime types has side-effects.
3253 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
3254 return !RD->isCompleteDefinition() ||
3255 !RD->hasTrivialDefaultConstructor() ||
3256 !RD->hasTrivialDestructor();
3257 return false;
3258}
3259
3260void Sema::CheckShadowInheritedFields(const SourceLocation &Loc,
3261 DeclarationName FieldName,
3262 const CXXRecordDecl *RD,
3263 bool DeclIsField) {
3264 if (Diags.isIgnored(diag::warn_shadow_field, Loc))
3265 return;
3266
3267 // To record a shadowed field in a base
3268 std::map<CXXRecordDecl*, NamedDecl*> Bases;
3269 auto FieldShadowed = [&](const CXXBaseSpecifier *Specifier,
3270 CXXBasePath &Path) {
3271 const auto Base = Specifier->getType()->getAsCXXRecordDecl();
3272 // Record an ambiguous path directly
3273 if (Bases.find(Base) != Bases.end())
3274 return true;
3275 for (const auto Field : Base->lookup(FieldName)) {
3276 if ((isa<FieldDecl>(Field) || isa<IndirectFieldDecl>(Field)) &&
3277 Field->getAccess() != AS_private) {
3278 assert(Field->getAccess() != AS_none);
3279 assert(Bases.find(Base) == Bases.end());
3280 Bases[Base] = Field;
3281 return true;
3282 }
3283 }
3284 return false;
3285 };
3286
3287 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3288 /*DetectVirtual=*/true);
3289 if (!RD->lookupInBases(FieldShadowed, Paths))
3290 return;
3291
3292 for (const auto &P : Paths) {
3293 auto Base = P.back().Base->getType()->getAsCXXRecordDecl();
3294 auto It = Bases.find(Base);
3295 // Skip duplicated bases
3296 if (It == Bases.end())
3297 continue;
3298 auto BaseField = It->second;
3299 assert(BaseField->getAccess() != AS_private);
3300 if (AS_none !=
3301 CXXRecordDecl::MergeAccess(P.Access, BaseField->getAccess())) {
3302 Diag(Loc, diag::warn_shadow_field)
3303 << FieldName << RD << Base << DeclIsField;
3304 Diag(BaseField->getLocation(), diag::note_shadow_field);
3305 Bases.erase(It);
3306 }
3307 }
3308}
3309
3310NamedDecl *
3312 MultiTemplateParamsArg TemplateParameterLists,
3313 Expr *BW, const VirtSpecifiers &VS,
3314 InClassInitStyle InitStyle) {
3315 const DeclSpec &DS = D.getDeclSpec();
3317 DeclarationName Name = NameInfo.getName();
3318 SourceLocation Loc = NameInfo.getLoc();
3319
3320 // For anonymous bitfields, the location should point to the type.
3321 if (Loc.isInvalid())
3322 Loc = D.getBeginLoc();
3323
3324 Expr *BitWidth = static_cast<Expr*>(BW);
3325
3326 assert(isa<CXXRecordDecl>(CurContext));
3327 assert(!DS.isFriendSpecified());
3328
3329 bool isFunc = D.isDeclarationOfFunction();
3330 const ParsedAttr *MSPropertyAttr =
3331 D.getDeclSpec().getAttributes().getMSPropertyAttr();
3332
3333 if (cast<CXXRecordDecl>(CurContext)->isInterface()) {
3334 // The Microsoft extension __interface only permits public member functions
3335 // and prohibits constructors, destructors, operators, non-public member
3336 // functions, static methods and data members.
3337 unsigned InvalidDecl;
3338 bool ShowDeclName = true;
3339 if (!isFunc &&
3340 (DS.getStorageClassSpec() == DeclSpec::SCS_typedef || MSPropertyAttr))
3341 InvalidDecl = 0;
3342 else if (!isFunc)
3343 InvalidDecl = 1;
3344 else if (AS != AS_public)
3345 InvalidDecl = 2;
3347 InvalidDecl = 3;
3348 else switch (Name.getNameKind()) {
3350 InvalidDecl = 4;
3351 ShowDeclName = false;
3352 break;
3353
3355 InvalidDecl = 5;
3356 ShowDeclName = false;
3357 break;
3358
3361 InvalidDecl = 6;
3362 break;
3363
3364 default:
3365 InvalidDecl = 0;
3366 break;
3367 }
3368
3369 if (InvalidDecl) {
3370 if (ShowDeclName)
3371 Diag(Loc, diag::err_invalid_member_in_interface)
3372 << (InvalidDecl-1) << Name;
3373 else
3374 Diag(Loc, diag::err_invalid_member_in_interface)
3375 << (InvalidDecl-1) << "";
3376 return nullptr;
3377 }
3378 }
3379
3380 // C++ 9.2p6: A member shall not be declared to have automatic storage
3381 // duration (auto, register) or with the extern storage-class-specifier.
3382 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
3383 // data members and cannot be applied to names declared const or static,
3384 // and cannot be applied to reference members.
3385 switch (DS.getStorageClassSpec()) {
3389 break;
3391 if (isFunc) {
3392 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
3393
3394 // FIXME: It would be nicer if the keyword was ignored only for this
3395 // declarator. Otherwise we could get follow-up errors.
3396 D.getMutableDeclSpec().ClearStorageClassSpecs();
3397 }
3398 break;
3399 default:
3401 diag::err_storageclass_invalid_for_member);
3402 D.getMutableDeclSpec().ClearStorageClassSpecs();
3403 break;
3404 }
3405
3406 bool isInstField = (DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
3408 !isFunc && TemplateParameterLists.empty();
3409
3410 if (DS.hasConstexprSpecifier() && isInstField) {
3412 Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr_member);
3413 SourceLocation ConstexprLoc = DS.getConstexprSpecLoc();
3414 if (InitStyle == ICIS_NoInit) {
3415 B << 0 << 0;
3416 if (D.getDeclSpec().getTypeQualifiers() & DeclSpec::TQ_const)
3417 B << FixItHint::CreateRemoval(ConstexprLoc);
3418 else {
3419 B << FixItHint::CreateReplacement(ConstexprLoc, "const");
3420 D.getMutableDeclSpec().ClearConstexprSpec();
3421 const char *PrevSpec;
3422 unsigned DiagID;
3423 bool Failed = D.getMutableDeclSpec().SetTypeQual(
3424 DeclSpec::TQ_const, ConstexprLoc, PrevSpec, DiagID, getLangOpts());
3425 (void)Failed;
3426 assert(!Failed && "Making a constexpr member const shouldn't fail");
3427 }
3428 } else {
3429 B << 1;
3430 const char *PrevSpec;
3431 unsigned DiagID;
3432 if (D.getMutableDeclSpec().SetStorageClassSpec(
3433 *this, DeclSpec::SCS_static, ConstexprLoc, PrevSpec, DiagID,
3436 "This is the only DeclSpec that should fail to be applied");
3437 B << 1;
3438 } else {
3439 B << 0 << FixItHint::CreateInsertion(ConstexprLoc, "static ");
3440 isInstField = false;
3441 }
3442 }
3443 }
3444
3446 if (isInstField) {
3447 CXXScopeSpec &SS = D.getCXXScopeSpec();
3448
3449 // Data members must have identifiers for names.
3450 if (!Name.isIdentifier()) {
3451 Diag(Loc, diag::err_bad_variable_name)
3452 << Name;
3453 return nullptr;
3454 }
3455
3456 IdentifierInfo *II = Name.getAsIdentifierInfo();
3457 if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {
3458 Diag(D.getIdentifierLoc(), diag::err_member_with_template_arguments)
3459 << II
3460 << SourceRange(D.getName().TemplateId->LAngleLoc,
3461 D.getName().TemplateId->RAngleLoc)
3462 << D.getName().TemplateId->LAngleLoc;
3463 D.SetIdentifier(II, Loc);
3464 }
3465
3466 if (SS.isSet() && !SS.isInvalid()) {
3467 // The user provided a superfluous scope specifier inside a class
3468 // definition:
3469 //
3470 // class X {
3471 // int X::member;
3472 // };
3473 if (DeclContext *DC = computeDeclContext(SS, false)) {
3474 TemplateIdAnnotation *TemplateId =
3476 ? D.getName().TemplateId
3477 : nullptr;
3478 diagnoseQualifiedDeclaration(SS, DC, Name, D.getIdentifierLoc(),
3479 TemplateId,
3480 /*IsMemberSpecialization=*/false);
3481 } else {
3482 Diag(D.getIdentifierLoc(), diag::err_member_qualification)
3483 << Name << SS.getRange();
3484 }
3485 SS.clear();
3486 }
3487
3488 if (MSPropertyAttr) {
3489 Member = HandleMSProperty(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3490 BitWidth, InitStyle, AS, *MSPropertyAttr);
3491 if (!Member)
3492 return nullptr;
3493 isInstField = false;
3494 } else {
3495 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3496 BitWidth, InitStyle, AS);
3497 if (!Member)
3498 return nullptr;
3499 }
3500
3501 CheckShadowInheritedFields(Loc, Name, cast<CXXRecordDecl>(CurContext));
3502 } else {
3503 Member = HandleDeclarator(S, D, TemplateParameterLists);
3504 if (!Member)
3505 return nullptr;
3506
3507 // Non-instance-fields can't have a bitfield.
3508 if (BitWidth) {
3509 if (Member->isInvalidDecl()) {
3510 // don't emit another diagnostic.
3511 } else if (isa<VarDecl>(Member) || isa<VarTemplateDecl>(Member)) {
3512 // C++ 9.6p3: A bit-field shall not be a static member.
3513 // "static member 'A' cannot be a bit-field"
3514 Diag(Loc, diag::err_static_not_bitfield)
3515 << Name << BitWidth->getSourceRange();
3516 } else if (isa<TypedefDecl>(Member)) {
3517 // "typedef member 'x' cannot be a bit-field"
3518 Diag(Loc, diag::err_typedef_not_bitfield)
3519 << Name << BitWidth->getSourceRange();
3520 } else {
3521 // A function typedef ("typedef int f(); f a;").
3522 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
3523 Diag(Loc, diag::err_not_integral_type_bitfield)
3524 << Name << cast<ValueDecl>(Member)->getType()
3525 << BitWidth->getSourceRange();
3526 }
3527
3528 BitWidth = nullptr;
3529 Member->setInvalidDecl();
3530 }
3531
3532 NamedDecl *NonTemplateMember = Member;
3533 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
3534 NonTemplateMember = FunTmpl->getTemplatedDecl();
3535 else if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(Member))
3536 NonTemplateMember = VarTmpl->getTemplatedDecl();
3537
3538 Member->setAccess(AS);
3539
3540 // If we have declared a member function template or static data member
3541 // template, set the access of the templated declaration as well.
3542 if (NonTemplateMember != Member)
3543 NonTemplateMember->setAccess(AS);
3544
3545 // C++ [temp.deduct.guide]p3:
3546 // A deduction guide [...] for a member class template [shall be
3547 // declared] with the same access [as the template].
3548 if (auto *DG = dyn_cast<CXXDeductionGuideDecl>(NonTemplateMember)) {
3549 auto *TD = DG->getDeducedTemplate();
3550 // Access specifiers are only meaningful if both the template and the
3551 // deduction guide are from the same scope.
3552 if (AS != TD->getAccess() &&
3553 TD->getDeclContext()->getRedeclContext()->Equals(
3554 DG->getDeclContext()->getRedeclContext())) {
3555 Diag(DG->getBeginLoc(), diag::err_deduction_guide_wrong_access);
3556 Diag(TD->getBeginLoc(), diag::note_deduction_guide_template_access)
3557 << TD->getAccess();
3558 const AccessSpecDecl *LastAccessSpec = nullptr;
3559 for (const auto *D : cast<CXXRecordDecl>(CurContext)->decls()) {
3560 if (const auto *AccessSpec = dyn_cast<AccessSpecDecl>(D))
3561 LastAccessSpec = AccessSpec;
3562 }
3563 assert(LastAccessSpec && "differing access with no access specifier");
3564 Diag(LastAccessSpec->getBeginLoc(), diag::note_deduction_guide_access)
3565 << AS;
3566 }
3567 }
3568 }
3569
3570 if (VS.isOverrideSpecified())
3571 Member->addAttr(OverrideAttr::Create(Context, VS.getOverrideLoc()));
3572 if (VS.isFinalSpecified())
3573 Member->addAttr(FinalAttr::Create(Context, VS.getFinalLoc(),
3575 ? FinalAttr::Keyword_sealed
3576 : FinalAttr::Keyword_final));
3577
3578 if (VS.getLastLocation().isValid()) {
3579 // Update the end location of a method that has a virt-specifiers.
3580 if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member))
3581 MD->setRangeEnd(VS.getLastLocation());
3582 }
3583
3585
3586 assert((Name || isInstField) && "No identifier for non-field ?");
3587
3588 if (isInstField) {
3589 FieldDecl *FD = cast<FieldDecl>(Member);
3590 FieldCollector->Add(FD);
3591
3592 if (!Diags.isIgnored(diag::warn_unused_private_field, FD->getLocation())) {
3593 // Remember all explicit private FieldDecls that have a name, no side
3594 // effects and are not part of a dependent type declaration.
3595
3596 auto DeclHasUnusedAttr = [](const QualType &T) {
3597 if (const TagDecl *TD = T->getAsTagDecl())
3598 return TD->hasAttr<UnusedAttr>();
3599 if (const TypedefType *TDT = T->getAs<TypedefType>())
3600 return TDT->getDecl()->hasAttr<UnusedAttr>();
3601 return false;
3602 };
3603
3604 if (!FD->isImplicit() && FD->getDeclName() &&
3605 FD->getAccess() == AS_private &&
3606 !FD->hasAttr<UnusedAttr>() &&
3607 !FD->getParent()->isDependentContext() &&
3608 !DeclHasUnusedAttr(FD->getType()) &&
3610 UnusedPrivateFields.insert(FD);
3611 }
3612 }
3613
3614 return Member;
3615}
3616
3617namespace {
3618 class UninitializedFieldVisitor
3619 : public EvaluatedExprVisitor<UninitializedFieldVisitor> {
3620 Sema &S;
3621 // List of Decls to generate a warning on. Also remove Decls that become
3622 // initialized.
3623 llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
3624 // List of base classes of the record. Classes are removed after their
3625 // initializers.
3626 llvm::SmallPtrSetImpl<QualType> &BaseClasses;
3627 // Vector of decls to be removed from the Decl set prior to visiting the
3628 // nodes. These Decls may have been initialized in the prior initializer.
3630 // If non-null, add a note to the warning pointing back to the constructor.
3631 const CXXConstructorDecl *Constructor;
3632 // Variables to hold state when processing an initializer list. When
3633 // InitList is true, special case initialization of FieldDecls matching
3634 // InitListFieldDecl.
3635 bool InitList;
3636 FieldDecl *InitListFieldDecl;
3637 llvm::SmallVector<unsigned, 4> InitFieldIndex;
3638
3639 public:
3641 UninitializedFieldVisitor(Sema &S,
3642 llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
3643 llvm::SmallPtrSetImpl<QualType> &BaseClasses)
3644 : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
3645 Constructor(nullptr), InitList(false), InitListFieldDecl(nullptr) {}
3646
3647 // Returns true if the use of ME is not an uninitialized use.
3648 bool IsInitListMemberExprInitialized(MemberExpr *ME,
3649 bool CheckReferenceOnly) {
3651 bool ReferenceField = false;
3652 while (ME) {
3653 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
3654 if (!FD)
3655 return false;
3656 Fields.push_back(FD);
3657 if (FD->getType()->isReferenceType())
3658 ReferenceField = true;
3659 ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParenImpCasts());
3660 }
3661
3662 // Binding a reference to an uninitialized field is not an
3663 // uninitialized use.
3664 if (CheckReferenceOnly && !ReferenceField)
3665 return true;
3666
3667 llvm::SmallVector<unsigned, 4> UsedFieldIndex;
3668 // Discard the first field since it is the field decl that is being
3669 // initialized.
3670 for (const FieldDecl *FD : llvm::drop_begin(llvm::reverse(Fields)))
3671 UsedFieldIndex.push_back(FD->getFieldIndex());
3672
3673 for (auto UsedIter = UsedFieldIndex.begin(),
3674 UsedEnd = UsedFieldIndex.end(),
3675 OrigIter = InitFieldIndex.begin(),
3676 OrigEnd = InitFieldIndex.end();
3677 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
3678 if (*UsedIter < *OrigIter)
3679 return true;
3680 if (*UsedIter > *OrigIter)
3681 break;
3682 }
3683
3684 return false;
3685 }
3686
3687 void HandleMemberExpr(MemberExpr *ME, bool CheckReferenceOnly,
3688 bool AddressOf) {
3689 if (isa<EnumConstantDecl>(ME->getMemberDecl()))
3690 return;
3691
3692 // FieldME is the inner-most MemberExpr that is not an anonymous struct
3693 // or union.
3694 MemberExpr *FieldME = ME;
3695
3696 bool AllPODFields = FieldME->getType().isPODType(S.Context);
3697
3698 Expr *Base = ME;
3699 while (MemberExpr *SubME =
3700 dyn_cast<MemberExpr>(Base->IgnoreParenImpCasts())) {
3701
3702 if (isa<VarDecl>(SubME->getMemberDecl()))
3703 return;
3704
3705 if (FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
3706 if (!FD->isAnonymousStructOrUnion())
3707 FieldME = SubME;
3708
3709 if (!FieldME->getType().isPODType(S.Context))
3710 AllPODFields = false;
3711
3712 Base = SubME->getBase();
3713 }
3714
3715 if (!isa<CXXThisExpr>(Base->IgnoreParenImpCasts())) {
3716 Visit(Base);
3717 return;
3718 }
3719
3720 if (AddressOf && AllPODFields)
3721 return;
3722
3723 ValueDecl* FoundVD = FieldME->getMemberDecl();
3724
3725 if (ImplicitCastExpr *BaseCast = dyn_cast<ImplicitCastExpr>(Base)) {
3726 while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
3727 BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
3728 }
3729
3730 if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
3731 QualType T = BaseCast->getType();
3732 if (T->isPointerType() &&
3733 BaseClasses.count(T->getPointeeType())) {
3734 S.Diag(FieldME->getExprLoc(), diag::warn_base_class_is_uninit)
3735 << T->getPointeeType() << FoundVD;
3736 }
3737 }
3738 }
3739
3740 if (!Decls.count(FoundVD))
3741 return;
3742
3743 const bool IsReference = FoundVD->getType()->isReferenceType();
3744
3745 if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
3746 // Special checking for initializer lists.
3747 if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
3748 return;
3749 }
3750 } else {
3751 // Prevent double warnings on use of unbounded references.
3752 if (CheckReferenceOnly && !IsReference)
3753 return;
3754 }
3755
3756 unsigned diag = IsReference
3757 ? diag::warn_reference_field_is_uninit
3758 : diag::warn_field_is_uninit;
3759 S.Diag(FieldME->getExprLoc(), diag) << FoundVD;
3760 if (Constructor)
3761 S.Diag(Constructor->getLocation(),
3762 diag::note_uninit_in_this_constructor)
3763 << (Constructor->isDefaultConstructor() && Constructor->isImplicit());
3764
3765 }
3766
3767 void HandleValue(Expr *E, bool AddressOf) {
3768 E = E->IgnoreParens();
3769
3770 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
3771 HandleMemberExpr(ME, false /*CheckReferenceOnly*/,
3772 AddressOf /*AddressOf*/);
3773 return;
3774 }
3775
3776 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
3777 Visit(CO->getCond());
3778 HandleValue(CO->getTrueExpr(), AddressOf);
3779 HandleValue(CO->getFalseExpr(), AddressOf);
3780 return;
3781 }
3782
3783 if (BinaryConditionalOperator *BCO =
3784 dyn_cast<BinaryConditionalOperator>(E)) {
3785 Visit(BCO->getCond());
3786 HandleValue(BCO->getFalseExpr(), AddressOf);
3787 return;
3788 }
3789
3790 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
3791 HandleValue(OVE->getSourceExpr(), AddressOf);
3792 return;
3793 }
3794
3795 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
3796 switch (BO->getOpcode()) {
3797 default:
3798 break;
3799 case(BO_PtrMemD):
3800 case(BO_PtrMemI):
3801 HandleValue(BO->getLHS(), AddressOf);
3802 Visit(BO->getRHS());
3803 return;
3804 case(BO_Comma):
3805 Visit(BO->getLHS());
3806 HandleValue(BO->getRHS(), AddressOf);
3807 return;
3808 }
3809 }
3810
3811 Visit(E);
3812 }
3813
3814 void CheckInitListExpr(InitListExpr *ILE) {
3815 InitFieldIndex.push_back(0);
3816 for (auto *Child : ILE->children()) {
3817 if (InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
3818 CheckInitListExpr(SubList);
3819 } else {
3820 Visit(Child);
3821 }
3822 ++InitFieldIndex.back();
3823 }
3824 InitFieldIndex.pop_back();
3825 }
3826
3827 void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor,
3828 FieldDecl *Field, const Type *BaseClass) {
3829 // Remove Decls that may have been initialized in the previous
3830 // initializer.
3831 for (ValueDecl* VD : DeclsToRemove)
3832 Decls.erase(VD);
3833 DeclsToRemove.clear();
3834
3835 Constructor = FieldConstructor;
3836 InitListExpr *ILE = dyn_cast<InitListExpr>(E);
3837
3838 if (ILE && Field) {
3839 InitList = true;
3840 InitListFieldDecl = Field;
3841 InitFieldIndex.clear();
3842 CheckInitListExpr(ILE);
3843 } else {
3844 InitList = false;
3845 Visit(E);
3846 }
3847
3848 if (Field)
3849 Decls.erase(Field);
3850 if (BaseClass)
3851 BaseClasses.erase(BaseClass->getCanonicalTypeInternal());
3852 }
3853
3854 void VisitMemberExpr(MemberExpr *ME) {
3855 // All uses of unbounded reference fields will warn.
3856 HandleMemberExpr(ME, true /*CheckReferenceOnly*/, false /*AddressOf*/);
3857 }
3858
3859 void VisitImplicitCastExpr(ImplicitCastExpr *E) {
3860 if (E->getCastKind() == CK_LValueToRValue) {
3861 HandleValue(E->getSubExpr(), false /*AddressOf*/);
3862 return;
3863 }
3864
3865 Inherited::VisitImplicitCastExpr(E);
3866 }
3867
3868 void VisitCXXConstructExpr(CXXConstructExpr *E) {
3869 if (E->getConstructor()->isCopyConstructor()) {
3870 Expr *ArgExpr = E->getArg(0);
3871 if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
3872 if (ILE->getNumInits() == 1)
3873 ArgExpr = ILE->getInit(0);
3874 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
3875 if (ICE->getCastKind() == CK_NoOp)
3876 ArgExpr = ICE->getSubExpr();
3877 HandleValue(ArgExpr, false /*AddressOf*/);
3878 return;
3879 }
3880 Inherited::VisitCXXConstructExpr(E);
3881 }
3882
3883 void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
3884 Expr *Callee = E->getCallee();
3885 if (isa<MemberExpr>(Callee)) {
3886 HandleValue(Callee, false /*AddressOf*/);
3887 for (auto *Arg : E->arguments())
3888 Visit(Arg);
3889 return;
3890 }
3891
3892 Inherited::VisitCXXMemberCallExpr(E);
3893 }
3894
3895 void VisitCallExpr(CallExpr *E) {
3896 // Treat std::move as a use.
3897 if (E->isCallToStdMove()) {
3898 HandleValue(E->getArg(0), /*AddressOf=*/false);
3899 return;
3900 }
3901
3902 Inherited::VisitCallExpr(E);
3903 }
3904
3905 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
3906 Expr *Callee = E->getCallee();
3907
3908 if (isa<UnresolvedLookupExpr>(Callee))
3909 return Inherited::VisitCXXOperatorCallExpr(E);
3910
3911 Visit(Callee);
3912 for (auto *Arg : E->arguments())
3913 HandleValue(Arg->IgnoreParenImpCasts(), false /*AddressOf*/);
3914 }
3915
3916 void VisitBinaryOperator(BinaryOperator *E) {
3917 // If a field assignment is detected, remove the field from the
3918 // uninitiailized field set.
3919 if (E->getOpcode() == BO_Assign)
3920 if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getLHS()))
3921 if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
3922 if (!FD->getType()->isReferenceType())
3923 DeclsToRemove.push_back(FD);
3924
3925 if (E->isCompoundAssignmentOp()) {
3926 HandleValue(E->getLHS(), false /*AddressOf*/);
3927 Visit(E->getRHS());
3928 return;
3929 }
3930
3931 Inherited::VisitBinaryOperator(E);
3932 }
3933
3934 void VisitUnaryOperator(UnaryOperator *E) {
3935 if (E->isIncrementDecrementOp()) {
3936 HandleValue(E->getSubExpr(), false /*AddressOf*/);
3937 return;
3938 }
3939 if (E->getOpcode() == UO_AddrOf) {
3940 if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getSubExpr())) {
3941 HandleValue(ME->getBase(), true /*AddressOf*/);
3942 return;
3943 }
3944 }
3945
3946 Inherited::VisitUnaryOperator(E);
3947 }
3948 };
3949
3950 // Diagnose value-uses of fields to initialize themselves, e.g.
3951 // foo(foo)
3952 // where foo is not also a parameter to the constructor.
3953 // Also diagnose across field uninitialized use such as
3954 // x(y), y(x)
3955 // TODO: implement -Wuninitialized and fold this into that framework.
3956 static void DiagnoseUninitializedFields(
3957 Sema &SemaRef, const CXXConstructorDecl *Constructor) {
3958
3959 if (SemaRef.getDiagnostics().isIgnored(diag::warn_field_is_uninit,
3960 Constructor->getLocation())) {
3961 return;
3962 }
3963
3964 if (Constructor->isInvalidDecl())
3965 return;
3966
3967 const CXXRecordDecl *RD = Constructor->getParent();
3968
3969 if (RD->isDependentContext())
3970 return;
3971
3972 // Holds fields that are uninitialized.
3973 llvm::SmallPtrSet<ValueDecl*, 4> UninitializedFields;
3974
3975 // At the beginning, all fields are uninitialized.
3976 for (auto *I : RD->decls()) {
3977 if (auto *FD = dyn_cast<FieldDecl>(I)) {
3978 UninitializedFields.insert(FD);
3979 } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
3980 UninitializedFields.insert(IFD->getAnonField());
3981 }
3982 }
3983
3984 llvm::SmallPtrSet<QualType, 4> UninitializedBaseClasses;
3985 for (const auto &I : RD->bases())
3986 UninitializedBaseClasses.insert(I.getType().getCanonicalType());
3987
3988 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
3989 return;
3990
3991 UninitializedFieldVisitor UninitializedChecker(SemaRef,
3992 UninitializedFields,
3993 UninitializedBaseClasses);
3994
3995 for (const auto *FieldInit : Constructor->inits()) {
3996 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
3997 break;
3998
3999 Expr *InitExpr = FieldInit->getInit();
4000 if (!InitExpr)
4001 continue;
4002
4004 dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
4005 InitExpr = Default->getExpr();
4006 if (!InitExpr)
4007 continue;
4008 // In class initializers will point to the constructor.
4009 UninitializedChecker.CheckInitializer(InitExpr, Constructor,
4010 FieldInit->getAnyMember(),
4011 FieldInit->getBaseClass());
4012 } else {
4013 UninitializedChecker.CheckInitializer(InitExpr, nullptr,
4014 FieldInit->getAnyMember(),
4015 FieldInit->getBaseClass());
4016 }
4017 }
4018 }
4019} // namespace
4020
4022 // Create a synthetic function scope to represent the call to the constructor
4023 // that notionally surrounds a use of this initializer.
4025}
4026
4028 if (!D.isFunctionDeclarator())
4029 return;
4030 auto &FTI = D.getFunctionTypeInfo();
4031 if (!FTI.Params)
4032 return;
4033 for (auto &Param : ArrayRef<DeclaratorChunk::ParamInfo>(FTI.Params,
4034 FTI.NumParams)) {
4035 auto *ParamDecl = cast<NamedDecl>(Param.Param);
4036 if (ParamDecl->getDeclName())
4037 PushOnScopeChains(ParamDecl, S, /*AddToContext=*/false);
4038 }
4039}
4040
4042 return ActOnRequiresClause(ConstraintExpr);
4043}
4044
4046 if (ConstraintExpr.isInvalid())
4047 return ExprError();
4048
4049 ConstraintExpr = CorrectDelayedTyposInExpr(ConstraintExpr);
4050 if (ConstraintExpr.isInvalid())
4051 return ExprError();
4052
4053 if (DiagnoseUnexpandedParameterPack(ConstraintExpr.get(),
4055 return ExprError();
4056
4057 return ConstraintExpr;
4058}
4059
4061 Expr *InitExpr,
4062 SourceLocation InitLoc) {
4063 InitializedEntity Entity =
4065 InitializationKind Kind =
4068 InitExpr->getBeginLoc(),
4069 InitExpr->getEndLoc())
4070 : InitializationKind::CreateCopy(InitExpr->getBeginLoc(), InitLoc);
4071 InitializationSequence Seq(*this, Entity, Kind, InitExpr);
4072 return Seq.Perform(*this, Entity, Kind, InitExpr);
4073}
4074
4076 SourceLocation InitLoc,
4077 ExprResult InitExpr) {
4078 // Pop the notional constructor scope we created earlier.
4079 PopFunctionScopeInfo(nullptr, D);
4080
4081 // Microsoft C++'s property declaration cannot have a default member
4082 // initializer.
4083 if (isa<MSPropertyDecl>(D)) {
4084 D->setInvalidDecl();
4085 return;
4086 }
4087
4088 FieldDecl *FD = dyn_cast<FieldDecl>(D);
4089 assert((FD && FD->getInClassInitStyle() != ICIS_NoInit) &&
4090 "must set init style when field is created");
4091
4092 if (!InitExpr.isUsable() ||
4094 FD->setInvalidDecl();
4095 ExprResult RecoveryInit =
4096 CreateRecoveryExpr(InitLoc, InitLoc, {}, FD->getType());
4097 if (RecoveryInit.isUsable())
4098 FD->setInClassInitializer(RecoveryInit.get());
4099 return;
4100 }
4101
4102 ExprResult Init = CorrectDelayedTyposInExpr(InitExpr, /*InitDecl=*/nullptr,
4103 /*RecoverUncorrectedTypos=*/true);
4104 assert(Init.isUsable() && "Init should at least have a RecoveryExpr");
4105 if (!FD->getType()->isDependentType() && !Init.get()->isTypeDependent()) {
4106 Init = ConvertMemberDefaultInitExpression(FD, Init.get(), InitLoc);
4107 // C++11 [class.base.init]p7:
4108 // The initialization of each base and member constitutes a
4109 // full-expression.
4110 if (!Init.isInvalid())
4111 Init = ActOnFinishFullExpr(Init.get(), /*DiscarededValue=*/false);
4112 if (Init.isInvalid()) {
4113 FD->setInvalidDecl();
4114 return;
4115 }
4116 }
4117
4118 FD->setInClassInitializer(Init.get());
4119}
4120
4121/// Find the direct and/or virtual base specifiers that
4122/// correspond to the given base type, for use in base initialization
4123/// within a constructor.
4125 CXXRecordDecl *ClassDecl,
4126 QualType BaseType,
4127 const CXXBaseSpecifier *&DirectBaseSpec,
4128 const CXXBaseSpecifier *&VirtualBaseSpec) {
4129 // First, check for a direct base class.
4130 DirectBaseSpec = nullptr;
4131 for (const auto &Base : ClassDecl->bases()) {
4132 if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base.getType())) {
4133 // We found a direct base of this type. That's what we're
4134 // initializing.
4135 DirectBaseSpec = &Base;
4136 break;
4137 }
4138 }
4139
4140 // Check for a virtual base class.
4141 // FIXME: We might be able to short-circuit this if we know in advance that
4142 // there are no virtual bases.
4143 VirtualBaseSpec = nullptr;
4144 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
4145 // We haven't found a base yet; search the class hierarchy for a
4146 // virtual base class.
4147 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
4148 /*DetectVirtual=*/false);
4149 if (SemaRef.IsDerivedFrom(ClassDecl->getLocation(),
4150 SemaRef.Context.getTypeDeclType(ClassDecl),
4151 BaseType, Paths)) {
4152 for (CXXBasePaths::paths_iterator Path = Paths.begin();
4153 Path != Paths.end(); ++Path) {
4154 if (Path->back().Base->isVirtual()) {
4155 VirtualBaseSpec = Path->back().Base;
4156 break;
4157 }
4158 }
4159 }
4160 }
4161
4162 return DirectBaseSpec || VirtualBaseSpec;
4163}
4164
4167 Scope *S,
4168 CXXScopeSpec &SS,
4169 IdentifierInfo *MemberOrBase,
4170 ParsedType TemplateTypeTy,
4171 const DeclSpec &DS,
4172 SourceLocation IdLoc,
4173 Expr *InitList,
4174 SourceLocation EllipsisLoc) {
4175 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
4176 DS, IdLoc, InitList,
4177 EllipsisLoc);
4178}
4179
4182 Scope *S,
4183 CXXScopeSpec &SS,
4184 IdentifierInfo *MemberOrBase,
4185 ParsedType TemplateTypeTy,
4186 const DeclSpec &DS,
4187 SourceLocation IdLoc,
4188 SourceLocation LParenLoc,
4189 ArrayRef<Expr *> Args,
4190 SourceLocation RParenLoc,
4191 SourceLocation EllipsisLoc) {
4192 Expr *List = ParenListExpr::Create(Context, LParenLoc, Args, RParenLoc);
4193 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
4194 DS, IdLoc, List, EllipsisLoc);
4195}
4196
4197namespace {
4198
4199// Callback to only accept typo corrections that can be a valid C++ member
4200// initializer: either a non-static field member or a base class.
4201class MemInitializerValidatorCCC final : public CorrectionCandidateCallback {
4202public:
4203 explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl)
4204 : ClassDecl(ClassDecl) {}
4205
4206 bool ValidateCandidate(const TypoCorrection &candidate) override {
4207 if (NamedDecl *ND = candidate.getCorrectionDecl()) {
4208 if (FieldDecl *Member = dyn_cast<FieldDecl>(ND))
4209 return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
4210 return isa<TypeDecl>(ND);
4211 }
4212 return false;
4213 }
4214
4215 std::unique_ptr<CorrectionCandidateCallback> clone() override {
4216 return std::make_unique<MemInitializerValidatorCCC>(*this);
4217 }
4218
4219private:
4220 CXXRecordDecl *ClassDecl;
4221};
4222
4223}
4224
4226 RecordDecl *ClassDecl,
4227 const IdentifierInfo *Name) {
4228 DeclContextLookupResult Result = ClassDecl->lookup(Name);
4230 llvm::find_if(Result, [this](const NamedDecl *Elem) {
4231 return isa<FieldDecl, IndirectFieldDecl>(Elem) &&
4233 });
4234 // We did not find a placeholder variable
4235 if (Found == Result.end())
4236 return false;
4237 Diag(Loc, diag::err_using_placeholder_variable) << Name;
4238 for (DeclContextLookupResult::iterator It = Found; It != Result.end(); It++) {
4239 const NamedDecl *ND = *It;
4240 if (ND->getDeclContext() != ND->getDeclContext())
4241 break;
4242 if (isa<FieldDecl, IndirectFieldDecl>(ND) &&
4244 Diag(ND->getLocation(), diag::note_reference_placeholder) << ND;
4245 }
4246 return true;
4247}
4248
4249ValueDecl *
4251 const IdentifierInfo *MemberOrBase) {
4252 ValueDecl *ND = nullptr;
4253 for (auto *D : ClassDecl->lookup(MemberOrBase)) {
4254 if (isa<FieldDecl, IndirectFieldDecl>(D)) {
4255 bool IsPlaceholder = D->isPlaceholderVar(getLangOpts());
4256 if (ND) {
4257 if (IsPlaceholder && D->getDeclContext() == ND->getDeclContext())
4258 return nullptr;
4259 break;
4260 }
4261 if (!IsPlaceholder)
4262 return cast<ValueDecl>(D);
4263 ND = cast<ValueDecl>(D);
4264 }
4265 }
4266 return ND;
4267}
4268
4270 CXXScopeSpec &SS,
4271 ParsedType TemplateTypeTy,
4272 IdentifierInfo *MemberOrBase) {
4273 if (SS.getScopeRep() || TemplateTypeTy)
4274 return nullptr;
4275 return tryLookupUnambiguousFieldDecl(ClassDecl, MemberOrBase);
4276}
4277
4280 Scope *S,
4281 CXXScopeSpec &SS,
4282 IdentifierInfo *MemberOrBase,
4283 ParsedType TemplateTypeTy,
4284 const DeclSpec &DS,
4285 SourceLocation IdLoc,
4286 Expr *Init,
4287 SourceLocation EllipsisLoc) {
4288 ExprResult Res = CorrectDelayedTyposInExpr(Init, /*InitDecl=*/nullptr,
4289 /*RecoverUncorrectedTypos=*/true);
4290 if (!Res.isUsable())
4291 return true;
4292 Init = Res.get();
4293
4294 if (!ConstructorD)
4295 return true;
4296
4297 AdjustDeclIfTemplate(ConstructorD);
4298
4299 CXXConstructorDecl *Constructor
4300 = dyn_cast<CXXConstructorDecl>(ConstructorD);
4301 if (!Constructor) {
4302 // The user wrote a constructor initializer on a function that is
4303 // not a C++ constructor. Ignore the error for now, because we may
4304 // have more member initializers coming; we'll diagnose it just
4305 // once in ActOnMemInitializers.
4306 return true;
4307 }
4308
4309 CXXRecordDecl *ClassDecl = Constructor->getParent();
4310
4311 // C++ [class.base.init]p2:
4312 // Names in a mem-initializer-id are looked up in the scope of the
4313 // constructor's class and, if not found in that scope, are looked
4314 // up in the scope containing the constructor's definition.
4315 // [Note: if the constructor's class contains a member with the
4316 // same name as a direct or virtual base class of the class, a
4317 // mem-initializer-id naming the member or base class and composed
4318 // of a single identifier refers to the class member. A
4319 // mem-initializer-id for the hidden base class may be specified
4320 // using a qualified name. ]
4321
4322 // Look for a member, first.
4324 ClassDecl, SS, TemplateTypeTy, MemberOrBase)) {
4325 if (EllipsisLoc.isValid())
4326 Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
4327 << MemberOrBase
4328 << SourceRange(IdLoc, Init->getSourceRange().getEnd());
4329
4330 return BuildMemberInitializer(Member, Init, IdLoc);
4331 }
4332 // It didn't name a member, so see if it names a class.
4333 QualType BaseType;
4334 TypeSourceInfo *TInfo = nullptr;
4335
4336 if (TemplateTypeTy) {
4337 BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
4338 if (BaseType.isNull())
4339 return true;
4340 } else if (DS.getTypeSpecType() == TST_decltype) {
4341 BaseType = BuildDecltypeType(DS.getRepAsExpr());
4342 } else if (DS.getTypeSpecType() == TST_decltype_auto) {
4343 Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);
4344 return true;
4345 } else if (DS.getTypeSpecType() == TST_typename_pack_indexing) {
4346 BaseType =
4348 DS.getBeginLoc(), DS.getEllipsisLoc());
4349 } else {
4350 LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
4351 LookupParsedName(R, S, &SS, /*ObjectType=*/QualType());
4352
4353 TypeDecl *TyD = R.getAsSingle<TypeDecl>();
4354 if (!TyD) {
4355 if (R.isAmbiguous()) return true;
4356
4357 // We don't want access-control diagnostics here.
4359
4360 if (SS.isSet() && isDependentScopeSpecifier(SS)) {
4361 bool NotUnknownSpecialization = false;
4362 DeclContext *DC = computeDeclContext(SS, false);
4363 if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
4364 NotUnknownSpecialization = !Record->hasAnyDependentBases();
4365
4366 if (!NotUnknownSpecialization) {
4367 // When the scope specifier can refer to a member of an unknown
4368 // specialization, we take it as a type name.
4369 BaseType = CheckTypenameType(
4371 SS.getWithLocInContext(Context), *MemberOrBase, IdLoc);
4372 if (BaseType.isNull())
4373 return true;
4374
4375 TInfo = Context.CreateTypeSourceInfo(BaseType);
4378 if (!TL.isNull()) {
4379 TL.setNameLoc(IdLoc);
4382 }
4383
4384 R.clear();
4385 R.setLookupName(MemberOrBase);
4386 }
4387 }
4388
4389 if (getLangOpts().MSVCCompat && !getLangOpts().CPlusPlus20) {
4390 if (auto UnqualifiedBase = R.getAsSingle<ClassTemplateDecl>()) {
4391 auto *TempSpec = cast<TemplateSpecializationType>(
4392 UnqualifiedBase->getInjectedClassNameSpecialization());
4393 TemplateName TN = TempSpec->getTemplateName();
4394 for (auto const &Base : ClassDecl->bases()) {
4395 auto BaseTemplate =
4396 Base.getType()->getAs<TemplateSpecializationType>();
4397 if (BaseTemplate &&
4398 Context.hasSameTemplateName(BaseTemplate->getTemplateName(), TN,
4399 /*IgnoreDeduced=*/true)) {
4400 Diag(IdLoc, diag::ext_unqualified_base_class)
4401 << SourceRange(IdLoc, Init->getSourceRange().getEnd());
4402 BaseType = Base.getType();
4403 break;
4404 }
4405 }
4406 }
4407 }
4408
4409 // If no results were found, try to correct typos.
4410 TypoCorrection Corr;
4411 MemInitializerValidatorCCC CCC(ClassDecl);
4412 if (R.empty() && BaseType.isNull() &&
4413 (Corr = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
4414 CCC, CTK_ErrorRecovery, ClassDecl))) {
4416 // We have found a non-static data member with a similar
4417 // name to what was typed; complain and initialize that
4418 // member.
4419 diagnoseTypo(Corr,
4420 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4421 << MemberOrBase << true);
4422 return BuildMemberInitializer(Member, Init, IdLoc);
4423 } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
4424 const CXXBaseSpecifier *DirectBaseSpec;
4425 const CXXBaseSpecifier *VirtualBaseSpec;
4426 if (FindBaseInitializer(*this, ClassDecl,
4428 DirectBaseSpec, VirtualBaseSpec)) {
4429 // We have found a direct or virtual base class with a
4430 // similar name to what was typed; complain and initialize
4431 // that base class.
4432 diagnoseTypo(Corr,
4433 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4434 << MemberOrBase << false,
4435 PDiag() /*Suppress note, we provide our own.*/);
4436
4437 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
4438 : VirtualBaseSpec;
4439 Diag(BaseSpec->getBeginLoc(), diag::note_base_class_specified_here)
4440 << BaseSpec->getType() << BaseSpec->getSourceRange();
4441
4442 TyD = Type;
4443 }
4444 }
4445 }
4446
4447 if (!TyD && BaseType.isNull()) {
4448 Diag(IdLoc, diag::err_mem_init_not_member_or_class)
4449 << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
4450 return true;
4451 }
4452 }
4453
4454 if (BaseType.isNull()) {
4457 MarkAnyDeclReferenced(TyD->getLocation(), TyD, /*OdrUse=*/false);
4458 TInfo = Context.CreateTypeSourceInfo(BaseType);
4460 TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
4463 }
4464 }
4465
4466 if (!TInfo)
4467 TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
4468
4469 return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc);
4470}
4471
4474 SourceLocation IdLoc) {
4475 FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member);
4476 IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member);
4477 assert((DirectMember || IndirectMember) &&
4478 "Member must be a FieldDecl or IndirectFieldDecl");
4479
4481 return true;
4482
4483 if (Member->isInvalidDecl())
4484 return true;
4485
4486 MultiExprArg Args;
4487 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4488 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4489 } else if (InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
4490 Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
4491 } else {
4492 // Template instantiation doesn't reconstruct ParenListExprs for us.
4493 Args = Init;
4494 }
4495
4496 SourceRange InitRange = Init->getSourceRange();
4497
4498 if (Member->getType()->isDependentType() || Init->isTypeDependent()) {
4499 // Can't check initialization for a member of dependent type or when
4500 // any of the arguments are type-dependent expressions.
4502 } else {
4503 bool InitList = false;
4504 if (isa<InitListExpr>(Init)) {
4505 InitList = true;
4506 Args = Init;
4507 }
4508
4509 // Initialize the member.
4510 InitializedEntity MemberEntity =
4511 DirectMember ? InitializedEntity::InitializeMember(DirectMember, nullptr)
4512 : InitializedEntity::InitializeMember(IndirectMember,
4513 nullptr);
4514 InitializationKind Kind =
4516 IdLoc, Init->getBeginLoc(), Init->getEndLoc())
4517 : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(),
4518 InitRange.getEnd());
4519
4520 InitializationSequence InitSeq(*this, MemberEntity, Kind, Args);
4521 ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind, Args,
4522 nullptr);
4523 if (!MemberInit.isInvalid()) {
4524 // C++11 [class.base.init]p7:
4525 // The initialization of each base and member constitutes a
4526 // full-expression.
4527 MemberInit = ActOnFinishFullExpr(MemberInit.get(), InitRange.getBegin(),
4528 /*DiscardedValue*/ false);
4529 }
4530
4531 if (MemberInit.isInvalid()) {
4532 // Args were sensible expressions but we couldn't initialize the member
4533 // from them. Preserve them in a RecoveryExpr instead.
4534 Init = CreateRecoveryExpr(InitRange.getBegin(), InitRange.getEnd(), Args,
4535 Member->getType())
4536 .get();
4537 if (!Init)
4538 return true;
4539 } else {
4540 Init = MemberInit.get();
4541 }
4542 }
4543
4544 if (DirectMember) {
4545 return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc,
4546 InitRange.getBegin(), Init,
4547 InitRange.getEnd());
4548 } else {
4549 return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc,
4550 InitRange.getBegin(), Init,
4551 InitRange.getEnd());
4552 }
4553}
4554
4557 CXXRecordDecl *ClassDecl) {
4558 SourceLocation NameLoc = TInfo->getTypeLoc().getSourceRange().getBegin();
4559 if (!LangOpts.CPlusPlus11)
4560 return Diag(NameLoc, diag::err_delegating_ctor)
4561 << TInfo->getTypeLoc().getSourceRange();
4562 Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
4563
4564 bool InitList = true;
4565 MultiExprArg Args = Init;
4566 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4567 InitList = false;
4568 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4569 }
4570
4571 SourceRange InitRange = Init->getSourceRange();
4572 // Initialize the object.
4574 QualType(ClassDecl->getTypeForDecl(), 0));
4575 InitializationKind Kind =
4577 NameLoc, Init->getBeginLoc(), Init->getEndLoc())
4578 : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(),
4579 InitRange.getEnd());
4580 InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args);
4581 ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind,
4582 Args, nullptr);
4583 if (!DelegationInit.isInvalid()) {
4584 assert((DelegationInit.get()->containsErrors() ||
4585 cast<CXXConstructExpr>(DelegationInit.get())->getConstructor()) &&
4586 "Delegating constructor with no target?");
4587
4588 // C++11 [class.base.init]p7:
4589 // The initialization of each base and member constitutes a
4590 // full-expression.
4591 DelegationInit = ActOnFinishFullExpr(
4592 DelegationInit.get(), InitRange.getBegin(), /*DiscardedValue*/ false);
4593 }
4594
4595 if (DelegationInit.isInvalid()) {
4596 DelegationInit =
4597 CreateRecoveryExpr(InitRange.getBegin(), InitRange.getEnd(), Args,
4598 QualType(ClassDecl->getTypeForDecl(), 0));
4599 if (DelegationInit.isInvalid())
4600 return true;
4601 } else {
4602 // If we are in a dependent context, template instantiation will
4603 // perform this type-checking again. Just save the arguments that we
4604 // received in a ParenListExpr.
4605 // FIXME: This isn't quite ideal, since our ASTs don't capture all
4606 // of the information that we have about the base
4607 // initializer. However, deconstructing the ASTs is a dicey process,
4608 // and this approach is far more likely to get the corner cases right.
4610 DelegationInit = Init;
4611 }
4612
4613 return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(),
4614 DelegationInit.getAs<Expr>(),
4615 InitRange.getEnd());
4616}
4617
4620 Expr *Init, CXXRecordDecl *ClassDecl,
4621 SourceLocation EllipsisLoc) {
4622 SourceLocation BaseLoc = BaseTInfo->getTypeLoc().getBeginLoc();
4623
4624 if (!BaseType->isDependentType() && !BaseType->isRecordType())
4625 return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
4626 << BaseType << BaseTInfo->getTypeLoc().getSourceRange();
4627
4628 // C++ [class.base.init]p2:
4629 // [...] Unless the mem-initializer-id names a nonstatic data
4630 // member of the constructor's class or a direct or virtual base
4631 // of that class, the mem-initializer is ill-formed. A
4632 // mem-initializer-list can initialize a base class using any
4633 // name that denotes that base class type.
4634
4635 // We can store the initializers in "as-written" form and delay analysis until
4636 // instantiation if the constructor is dependent. But not for dependent
4637 // (broken) code in a non-template! SetCtorInitializers does not expect this.
4639 (BaseType->isDependentType() || Init->isTypeDependent());
4640
4641 SourceRange InitRange = Init->getSourceRange();
4642 if (EllipsisLoc.isValid()) {
4643 // This is a pack expansion.
4644 if (!BaseType->containsUnexpandedParameterPack()) {
4645 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
4646 << SourceRange(BaseLoc, InitRange.getEnd());
4647
4648 EllipsisLoc = SourceLocation();
4649 }
4650 } else {
4651 // Check for any unexpanded parameter packs.
4652 if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer))
4653 return true;
4654
4656 return true;
4657 }
4658
4659 // Check for direct and virtual base classes.
4660 const CXXBaseSpecifier *DirectBaseSpec = nullptr;
4661 const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
4662 if (!Dependent) {
4664 BaseType))
4665 return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl);
4666
4667 FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
4668 VirtualBaseSpec);
4669
4670 // C++ [base.class.init]p2:
4671 // Unless the mem-initializer-id names a nonstatic data member of the
4672 // constructor's class or a direct or virtual base of that class, the
4673 // mem-initializer is ill-formed.
4674 if (!DirectBaseSpec && !VirtualBaseSpec) {
4675 // If the class has any dependent bases, then it's possible that
4676 // one of those types will resolve to the same type as
4677 // BaseType. Therefore, just treat this as a dependent base
4678 // class initialization. FIXME: Should we try to check the
4679 // initialization anyway? It seems odd.
4680 if (ClassDecl->hasAnyDependentBases())
4681 Dependent = true;
4682 else
4683 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
4684 << BaseType << Context.getTypeDeclType(ClassDecl)
4685 << BaseTInfo->getTypeLoc().getSourceRange();
4686 }
4687 }
4688
4689 if (Dependent) {
4691
4692 return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4693 /*IsVirtual=*/false,
4694 InitRange.getBegin(), Init,
4695 InitRange.getEnd(), EllipsisLoc);
4696 }
4697
4698 // C++ [base.class.init]p2:
4699 // If a mem-initializer-id is ambiguous because it designates both
4700 // a direct non-virtual base class and an inherited virtual base
4701 // class, the mem-initializer is ill-formed.
4702 if (DirectBaseSpec && VirtualBaseSpec)
4703 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
4704 << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
4705
4706 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
4707 if (!BaseSpec)
4708 BaseSpec = VirtualBaseSpec;
4709
4710 // Initialize the base.
4711 bool InitList = true;
4712 MultiExprArg Args = Init;
4713 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4714 InitList = false;
4715 Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4716 }
4717
4718 InitializedEntity BaseEntity =
4719 InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec);
4720 InitializationKind Kind =
4721 InitList ? InitializationKind::CreateDirectList(BaseLoc)
4722 : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(),
4723 InitRange.getEnd());
4724 InitializationSequence InitSeq(*this, BaseEntity, Kind, Args);
4725 ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind, Args, nullptr);
4726 if (!BaseInit.isInvalid()) {
4727 // C++11 [class.base.init]p7:
4728 // The initialization of each base and member constitutes a
4729 // full-expression.
4730 BaseInit = ActOnFinishFullExpr(BaseInit.get(), InitRange.getBegin(),
4731 /*DiscardedValue*/ false);
4732 }
4733
4734 if (BaseInit.isInvalid()) {
4735 BaseInit = CreateRecoveryExpr(InitRange.getBegin(), InitRange.getEnd(),
4736 Args, BaseType);
4737 if (BaseInit.isInvalid())
4738 return true;
4739 } else {
4740 // If we are in a dependent context, template instantiation will
4741 // perform this type-checking again. Just save the arguments that we
4742 // received in a ParenListExpr.
4743 // FIXME: This isn't quite ideal, since our ASTs don't capture all
4744 // of the information that we have about the base
4745 // initializer. However, deconstructing the ASTs is a dicey process,
4746 // and this approach is far more likely to get the corner cases right.
4748 BaseInit = Init;
4749 }
4750
4751 return new (Context) CXXCtorInitializer(Context, BaseTInfo,
4752 BaseSpec->isVirtual(),
4753 InitRange.getBegin(),
4754 BaseInit.getAs<Expr>(),
4755 InitRange.getEnd(), EllipsisLoc);
4756}
4757
4758// Create a static_cast<T&&>(expr).
4760 QualType TargetType =
4761 SemaRef.BuildReferenceType(E->getType(), /*SpelledAsLValue*/ false,
4763 SourceLocation ExprLoc = E->getBeginLoc();
4765 TargetType, ExprLoc);
4766
4767 return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
4768 SourceRange(ExprLoc, ExprLoc),
4769 E->getSourceRange()).get();
4770}
4771
4772/// ImplicitInitializerKind - How an implicit base or member initializer should
4773/// initialize its base or member.
4780
4781static bool
4783 ImplicitInitializerKind ImplicitInitKind,
4784 CXXBaseSpecifier *BaseSpec,
4785 bool IsInheritedVirtualBase,
4786 CXXCtorInitializer *&CXXBaseInit) {
4787 InitializedEntity InitEntity
4789 IsInheritedVirtualBase);
4790
4791 ExprResult BaseInit;
4792
4793 switch (ImplicitInitKind) {
4794 case IIK_Inherit:
4795 case IIK_Default: {
4796 InitializationKind InitKind
4797 = InitializationKind::CreateDefault(Constructor->getLocation());
4798 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, {});
4799 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, {});
4800 break;
4801 }
4802
4803 case IIK_Move:
4804 case IIK_Copy: {
4805 bool Moving = ImplicitInitKind == IIK_Move;
4806 ParmVarDecl *Param = Constructor->getParamDecl(0);
4807 QualType ParamType = Param->getType().getNonReferenceType();
4808
4809 Expr *CopyCtorArg =
4811 SourceLocation(), Param, false,
4812 Constructor->getLocation(), ParamType,
4813 VK_LValue, nullptr);
4814
4815 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg));
4816
4817 // Cast to the base class to avoid ambiguities.
4818 QualType ArgTy =
4820 ParamType.getQualifiers());
4821
4822 if (Moving) {
4823 CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg);
4824 }
4825
4826 CXXCastPath BasePath;
4827 BasePath.push_back(BaseSpec);
4828 CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy,
4829 CK_UncheckedDerivedToBase,
4830 Moving ? VK_XValue : VK_LValue,
4831 &BasePath).get();
4832
4833 InitializationKind InitKind
4834 = InitializationKind::CreateDirect(Constructor->getLocation(),
4836 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, CopyCtorArg);
4837 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, CopyCtorArg);
4838 break;
4839 }
4840 }
4841
4842 BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit);
4843 if (BaseInit.isInvalid())
4844 return true;
4845
4846 CXXBaseInit =
4849 SourceLocation()),
4850 BaseSpec->isVirtual(),
4852 BaseInit.getAs<Expr>(),
4854 SourceLocation());
4855
4856 return false;
4857}
4858
4859static bool RefersToRValueRef(Expr *MemRef) {
4860 ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
4861 return Referenced->getType()->isRValueReferenceType();
4862}
4863
4864static bool
4866 ImplicitInitializerKind ImplicitInitKind,
4868 CXXCtorInitializer *&CXXMemberInit) {
4869 if (Field->isInvalidDecl())
4870 return true;
4871
4872 SourceLocation Loc = Constructor->getLocation();
4873
4874 if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) {
4875 bool Moving = ImplicitInitKind == IIK_Move;
4876 ParmVarDecl *Param = Constructor->getParamDecl(0);
4877 QualType ParamType = Param->getType().getNonReferenceType();
4878
4879 // Suppress copying zero-width bitfields.
4880 if (Field->isZeroLengthBitField())
4881 return false;
4882
4883 Expr *MemberExprBase =
4885 SourceLocation(), Param, false,
4886 Loc, ParamType, VK_LValue, nullptr);
4887
4888 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase));
4889
4890 if (Moving) {
4891 MemberExprBase = CastForMoving(SemaRef, MemberExprBase);
4892 }
4893
4894 // Build a reference to this field within the parameter.
4895 CXXScopeSpec SS;
4896 LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
4898 MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect)
4899 : cast<ValueDecl>(Field), AS_public);
4900 MemberLookup.resolveKind();
4901 ExprResult CtorArg
4902 = SemaRef.BuildMemberReferenceExpr(MemberExprBase,
4903 ParamType, Loc,
4904 /*IsArrow=*/false,
4905 SS,
4906 /*TemplateKWLoc=*/SourceLocation(),
4907 /*FirstQualifierInScope=*/nullptr,
4908 MemberLookup,
4909 /*TemplateArgs=*/nullptr,
4910 /*S*/nullptr);
4911 if (CtorArg.isInvalid())
4912 return true;
4913
4914 // C++11 [class.copy]p15:
4915 // - if a member m has rvalue reference type T&&, it is direct-initialized
4916 // with static_cast<T&&>(x.m);
4917 if (RefersToRValueRef(CtorArg.get())) {
4918 CtorArg = CastForMoving(SemaRef, CtorArg.get());
4919 }
4920
4921 InitializedEntity Entity =
4923 /*Implicit*/ true)
4924 : InitializedEntity::InitializeMember(Field, nullptr,
4925 /*Implicit*/ true);
4926
4927 // Direct-initialize to use the copy constructor.
4928 InitializationKind InitKind =
4930
4931 Expr *CtorArgE = CtorArg.getAs<Expr>();
4932 InitializationSequence InitSeq(SemaRef, Entity, InitKind, CtorArgE);
4933 ExprResult MemberInit =
4934 InitSeq.Perform(SemaRef, Entity, InitKind, MultiExprArg(&CtorArgE, 1));
4935 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
4936 if (MemberInit.isInvalid())
4937 return true;
4938
4939 if (Indirect)
4940 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
4941 SemaRef.Context, Indirect, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
4942 else
4943 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
4944 SemaRef.Context, Field, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
4945 return false;
4946 }
4947
4948 assert((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) &&
4949 "Unhandled implicit init kind!");
4950
4951 QualType FieldBaseElementType =
4952 SemaRef.Context.getBaseElementType(Field->getType());
4953
4954 if (FieldBaseElementType->isRecordType()) {
4955 InitializedEntity InitEntity =
4957 /*Implicit*/ true)
4958 : InitializedEntity::InitializeMember(Field, nullptr,
4959 /*Implicit*/ true);
4960 InitializationKind InitKind =
4962
4963 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, {});
4964 ExprResult MemberInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, {});
4965
4966 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
4967 if (MemberInit.isInvalid())
4968 return true;
4969
4970 if (Indirect)
4971 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4972 Indirect, Loc,
4973 Loc,
4974 MemberInit.get(),
4975 Loc);
4976 else
4977 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
4978 Field, Loc, Loc,
4979 MemberInit.get(),
4980 Loc);
4981 return false;
4982 }
4983
4984 if (!Field->getParent()->isUnion()) {
4985 if (FieldBaseElementType->isReferenceType()) {
4986 SemaRef.Diag(Constructor->getLocation(),
4987 diag::err_uninitialized_member_in_ctor)
4988 << (int)Constructor->isImplicit()
4989 << SemaRef.Context.getTagDeclType(Constructor->getParent())
4990 << 0 << Field->getDeclName();
4991 SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
4992 return true;
4993 }
4994
4995 if (FieldBaseElementType.isConstQualified()) {
4996 SemaRef.Diag(Constructor->getLocation(),
4997 diag::err_uninitialized_member_in_ctor)
4998 << (int)Constructor->isImplicit()
4999 << SemaRef.Context.getTagDeclType(Constructor->getParent())
5000 << 1 << Field->getDeclName();
5001 SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
5002 return true;
5003 }
5004 }
5005
5006 if (FieldBaseElementType.hasNonTrivialObjCLifetime()) {
5007 // ARC and Weak:
5008 // Default-initialize Objective-C pointers to NULL.
5009 CXXMemberInit
5011 Loc, Loc,
5012 new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()),
5013 Loc);
5014 return false;
5015 }
5016
5017 // Nothing to initialize.
5018 CXXMemberInit = nullptr;
5019 return false;
5020}
5021
5022namespace {
5023struct BaseAndFieldInfo {
5024 Sema &S;
5025 CXXConstructorDecl *Ctor;
5026 bool AnyErrorsInInits;
5028 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
5030 llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
5031
5032 BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits)
5033 : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
5034 bool Generated = Ctor->isImplicit() || Ctor->isDefaulted();
5035 if (Ctor->getInheritedConstructor())
5036 IIK = IIK_Inherit;
5037 else if (Generated && Ctor->isCopyConstructor())
5038 IIK = IIK_Copy;
5039 else if (Generated && Ctor->isMoveConstructor())
5040 IIK = IIK_Move;
5041 else
5042 IIK = IIK_Default;
5043 }
5044
5045 bool isImplicitCopyOrMove() const {
5046 switch (IIK) {
5047 case IIK_Copy:
5048 case IIK_Move:
5049 return true;
5050
5051 case IIK_Default:
5052 case IIK_Inherit:
5053 return false;
5054 }
5055
5056 llvm_unreachable("Invalid ImplicitInitializerKind!");
5057 }
5058
5059 bool addFieldInitializer(CXXCtorInitializer *Init) {
5060 AllToInit.push_back(Init);
5061
5062 // Check whether this initializer makes the field "used".
5063 if (Init->getInit()->HasSideEffects(S.Context))
5064 S.UnusedPrivateFields.remove(Init->getAnyMember());
5065
5066 return false;
5067 }
5068
5069 bool isInactiveUnionMember(FieldDecl *Field) {
5070 RecordDecl *Record = Field->getParent();
5071 if (!Record->isUnion())
5072 return false;
5073
5074 if (FieldDecl *Active =
5075 ActiveUnionMember.lookup(Record->getCanonicalDecl()))
5076 return Active != Field->getCanonicalDecl();
5077
5078 // In an implicit copy or move constructor, ignore any in-class initializer.
5079 if (isImplicitCopyOrMove())
5080 return true;
5081
5082 // If there's no explicit initialization, the field is active only if it
5083 // has an in-class initializer...
5084 if (Field->hasInClassInitializer())
5085 return false;
5086 // ... or it's an anonymous struct or union whose class has an in-class
5087 // initializer.
5088 if (!Field->isAnonymousStructOrUnion())
5089 return true;
5090 CXXRecordDecl *FieldRD = Field->getType()->getAsCXXRecordDecl();
5091 return !FieldRD->hasInClassInitializer();
5092 }
5093
5094 /// Determine whether the given field is, or is within, a union member
5095 /// that is inactive (because there was an initializer given for a different
5096 /// member of the union, or because the union was not initialized at all).
5097 bool isWithinInactiveUnionMember(FieldDecl *Field,
5099 if (!Indirect)
5100 return isInactiveUnionMember(Field);
5101
5102 for (auto *C : Indirect->chain()) {
5103 FieldDecl *Field = dyn_cast<FieldDecl>(C);
5104 if (Field && isInactiveUnionMember(Field))
5105 return true;
5106 }
5107 return false;
5108 }
5109};
5110}
5111
5112/// Determine whether the given type is an incomplete or zero-lenfgth
5113/// array type.
5115 if (T->isIncompleteArrayType())
5116 return true;
5117
5118 while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
5119 if (ArrayT->isZeroSize())
5120 return true;
5121
5122 T = ArrayT->getElementType();
5123 }
5124
5125 return false;
5126}
5127
5128static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
5129 FieldDecl *Field,
5130 IndirectFieldDecl *Indirect = nullptr) {
5131 if (Field->isInvalidDecl())
5132 return false;
5133
5134 // Overwhelmingly common case: we have a direct initializer for this field.
5136 Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
5137 return Info.addFieldInitializer(Init);
5138
5139 // C++11 [class.base.init]p8:
5140 // if the entity is a non-static data member that has a
5141 // brace-or-equal-initializer and either
5142 // -- the constructor's class is a union and no other variant member of that
5143 // union is designated by a mem-initializer-id or
5144 // -- the constructor's class is not a union, and, if the entity is a member
5145 // of an anonymous union, no other member of that union is designated by
5146 // a mem-initializer-id,
5147 // the entity is initialized as specified in [dcl.init].
5148 //
5149 // We also apply the same rules to handle anonymous structs within anonymous
5150 // unions.
5151 if (Info.isWithinInactiveUnionMember(Field, Indirect))
5152 return false;
5153
5154 if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
5155 ExprResult DIE =
5156 SemaRef.BuildCXXDefaultInitExpr(Info.Ctor->getLocation(), Field);
5157 if (DIE.isInvalid())
5158 return true;
5159
5160 auto Entity = InitializedEntity::InitializeMember(Field, nullptr, true);
5161 SemaRef.checkInitializerLifetime(Entity, DIE.get());
5162
5164 if (Indirect)
5165 Init = new (SemaRef.Context)
5167 SourceLocation(), DIE.get(), SourceLocation());
5168 else
5169 Init = new (SemaRef.Context)
5171 SourceLocation(), DIE.get(), SourceLocation());
5172 return Info.addFieldInitializer(Init);
5173 }
5174
5175 // Don't initialize incomplete or zero-length arrays.
5176 if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType()))
5177 return false;
5178
5179 // Don't try to build an implicit initializer if there were semantic
5180 // errors in any of the initializers (and therefore we might be
5181 // missing some that the user actually wrote).
5182 if (Info.AnyErrorsInInits)
5183 return false;
5184
5185 CXXCtorInitializer *Init = nullptr;
5186 if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field,
5187 Indirect, Init))
5188 return true;
5189
5190 if (!Init)
5191 return false;
5192
5193 return Info.addFieldInitializer(Init);
5194}
5195
5196bool
5199 assert(Initializer->isDelegatingInitializer());
5200 Constructor->setNumCtorInitializers(1);
5201 CXXCtorInitializer **initializer =
5202 new (Context) CXXCtorInitializer*[1];
5203 memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*));
5204 Constructor->setCtorInitializers(initializer);
5205
5206 if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) {
5207 MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor);
5208 DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation());
5209 }
5210
5211 DelegatingCtorDecls.push_back(Constructor);
5212
5213 DiagnoseUninitializedFields(*this, Constructor);
5214
5215 return false;
5216}
5217
5218bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
5219 ArrayRef<CXXCtorInitializer *> Initializers) {
5220 if (Constructor->isDependentContext()) {
5221 // Just store the initializers as written, they will be checked during
5222 // instantiation.
5223 if (!Initializers.empty()) {
5224 Constructor->setNumCtorInitializers(Initializers.size());
5225 CXXCtorInitializer **baseOrMemberInitializers =
5226 new (Context) CXXCtorInitializer*[Initializers.size()];
5227 memcpy(baseOrMemberInitializers, Initializers.data(),
5228 Initializers.size() * sizeof(CXXCtorInitializer*));
5229 Constructor->setCtorInitializers(baseOrMemberInitializers);
5230 }
5231
5232 // Let template instantiation know whether we had errors.
5233 if (AnyErrors)
5234 Constructor->setInvalidDecl();
5235
5236 return false;
5237 }
5238
5239 BaseAndFieldInfo Info(*this, Constructor, AnyErrors);
5240
5241 // We need to build the initializer AST according to order of construction
5242 // and not what user specified in the Initializers list.
5243 CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
5244 if (!ClassDecl)
5245 return true;
5246
5247 bool HadError = false;
5248
5249 for (unsigned i = 0; i < Initializers.size(); i++) {
5250 CXXCtorInitializer *Member = Initializers[i];
5251
5252 if (Member->isBaseInitializer())
5253 Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
5254 else {
5255 Info.AllBaseFields[Member->getAnyMember()->getCanonicalDecl()] = Member;
5256
5257 if (IndirectFieldDecl *F = Member->getIndirectMember()) {
5258 for (auto *C : F->chain()) {
5259 FieldDecl *FD = dyn_cast<FieldDecl>(C);
5260 if (FD && FD->getParent()->isUnion())
5261 Info.ActiveUnionMember.insert(std::make_pair(
5263 }
5264 } else if (FieldDecl *FD = Member->getMember()) {
5265 if (FD->getParent()->isUnion())
5266 Info.ActiveUnionMember.insert(std::make_pair(
5268 }
5269 }
5270 }
5271
5272 // Keep track of the direct virtual bases.
5274 for (auto &I : ClassDecl->bases()) {
5275 if (I.isVirtual())
5276 DirectVBases.insert(&I);
5277 }
5278
5279 // Push virtual bases before others.
5280 for (auto &VBase : ClassDecl->vbases()) {
5282 = Info.AllBaseFields.lookup(VBase.getType()->getAs<RecordType>())) {
5283 // [class.base.init]p7, per DR257:
5284 // A mem-initializer where the mem-initializer-id names a virtual base
5285 // class is ignored during execution of a constructor of any class that
5286 // is not the most derived class.
5287 if (ClassDecl->isAbstract()) {
5288 // FIXME: Provide a fixit to remove the base specifier. This requires
5289 // tracking the location of the associated comma for a base specifier.
5290 Diag(Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
5291 << VBase.getType() << ClassDecl;
5292 DiagnoseAbstractType(ClassDecl);
5293 }
5294
5295 Info.AllToInit.push_back(Value);
5296 } else if (!AnyErrors && !ClassDecl->isAbstract()) {
5297 // [class.base.init]p8, per DR257:
5298 // If a given [...] base class is not named by a mem-initializer-id
5299 // [...] and the entity is not a virtual base class of an abstract
5300 // class, then [...] the entity is default-initialized.
5301 bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
5302 CXXCtorInitializer *CXXBaseInit;
5303 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
5304 &VBase, IsInheritedVirtualBase,
5305 CXXBaseInit)) {
5306 HadError = true;
5307 continue;
5308 }
5309
5310 Info.AllToInit.push_back(CXXBaseInit);
5311 }
5312 }
5313
5314 // Non-virtual bases.
5315 for (auto &Base : ClassDecl->bases()) {
5316 // Virtuals are in the virtual base list and already constructed.
5317 if (Base.isVirtual())
5318 continue;
5319
5321 = Info.AllBaseFields.lookup(Base.getType()->getAs<RecordType>())) {
5322 Info.AllToInit.push_back(Value);
5323 } else if (!AnyErrors) {
5324 CXXCtorInitializer *CXXBaseInit;
5325 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
5326 &Base, /*IsInheritedVirtualBase=*/false,
5327 CXXBaseInit)) {
5328 HadError = true;
5329 continue;
5330 }
5331
5332 Info.AllToInit.push_back(CXXBaseInit);
5333 }
5334 }
5335
5336 // Fields.
5337 for (auto *Mem : ClassDecl->decls()) {
5338 if (auto *F = dyn_cast<FieldDecl>(Mem)) {
5339 // C++ [class.bit]p2:
5340 // A declaration for a bit-field that omits the identifier declares an
5341 // unnamed bit-field. Unnamed bit-fields are not members and cannot be
5342 // initialized.
5343 if (F->isUnnamedBitField())
5344 continue;
5345
5346 // If we're not generating the implicit copy/move constructor, then we'll
5347 // handle anonymous struct/union fields based on their individual
5348 // indirect fields.
5349 if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
5350 continue;
5351
5352 if (CollectFieldInitializer(*this, Info, F))
5353 HadError = true;
5354 continue;
5355 }
5356
5357 // Beyond this point, we only consider default initialization.
5358 if (Info.isImplicitCopyOrMove())
5359 continue;
5360
5361 if (auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
5362 if (F->getType()->isIncompleteArrayType()) {
5363 assert(ClassDecl->hasFlexibleArrayMember() &&
5364 "Incomplete array type is not valid");
5365 continue;
5366 }
5367
5368 // Initialize each field of an anonymous struct individually.
5369 if (CollectFieldInitializer(*this, Info, F->getAnonField(), F))
5370 HadError = true;
5371
5372 continue;
5373 }
5374 }
5375
5376 unsigned NumInitializers = Info.AllToInit.size();
5377 if (NumInitializers > 0) {
5378 Constructor->setNumCtorInitializers(NumInitializers);
5379 CXXCtorInitializer **baseOrMemberInitializers =
5380 new (Context) CXXCtorInitializer*[NumInitializers];
5381 memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
5382 NumInitializers * sizeof(CXXCtorInitializer*));
5383 Constructor->setCtorInitializers(baseOrMemberInitializers);
5384
5385 // Constructors implicitly reference the base and member
5386 // destructors.
5387 MarkBaseAndMemberDestructorsReferenced(Constructor->getLocation(),
5388 Constructor->getParent());
5389 }
5390
5391 return HadError;
5392}
5393
5395 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
5396 const RecordDecl *RD = RT->getDecl();
5397 if (RD->isAnonymousStructOrUnion()) {
5398 for (auto *Field : RD->fields())
5399 PopulateKeysForFields(Field, IdealInits);
5400 return;
5401 }
5402 }
5403 IdealInits.push_back(Field->getCanonicalDecl());
5404}
5405
5406static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
5407 return Context.getCanonicalType(BaseType).getTypePtr();
5408}
5409
5412 if (!Member->isAnyMemberInitializer())
5413 return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0));
5414
5415 return Member->getAnyMember()->getCanonicalDecl();
5416}
5417
5420 const CXXCtorInitializer *Current) {
5421 if (Previous->isAnyMemberInitializer())
5422 Diag << 0 << Previous->getAnyMember();
5423 else
5424 Diag << 1 << Previous->getTypeSourceInfo()->getType();
5425
5426 if (Current->isAnyMemberInitializer())
5427 Diag << 0 << Current->getAnyMember();
5428 else
5429 Diag << 1 << Current->getTypeSourceInfo()->getType();
5430}
5431
5433 Sema &SemaRef, const CXXConstructorDecl *Constructor,
5435 if (Constructor->getDeclContext()->isDependentContext())
5436 return;
5437
5438 // Don't check initializers order unless the warning is enabled at the
5439 // location of at least one initializer.
5440 bool ShouldCheckOrder = false;
5441 for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5442 CXXCtorInitializer *Init = Inits[InitIndex];
5443 if (!SemaRef.Diags.isIgnored(diag::warn_initializer_out_of_order,
5444 Init->getSourceLocation())) {
5445 ShouldCheckOrder = true;
5446 break;
5447 }
5448 }
5449 if (!ShouldCheckOrder)
5450 return;
5451
5452 // Build the list of bases and members in the order that they'll
5453 // actually be initialized. The explicit initializers should be in
5454 // this same order but may be missing things.
5455 SmallVector<const void*, 32> IdealInitKeys;
5456
5457 const CXXRecordDecl *ClassDecl = Constructor->getParent();
5458
5459 // 1. Virtual bases.
5460 for (const auto &VBase : ClassDecl->vbases())
5461 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase.getType()));
5462
5463 // 2. Non-virtual bases.
5464 for (const auto &Base : ClassDecl->bases()) {
5465 if (Base.isVirtual())
5466 continue;
5467 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base.getType()));
5468 }
5469
5470 // 3. Direct fields.
5471 for (auto *Field : ClassDecl->fields()) {
5472 if (Field->isUnnamedBitField())
5473 continue;
5474
5475 PopulateKeysForFields(Field, IdealInitKeys);
5476 }
5477
5478 unsigned NumIdealInits = IdealInitKeys.size();
5479 unsigned IdealIndex = 0;
5480
5481 // Track initializers that are in an incorrect order for either a warning or
5482 // note if multiple ones occur.
5483 SmallVector<unsigned> WarnIndexes;
5484 // Correlates the index of an initializer in the init-list to the index of
5485 // the field/base in the class.
5486 SmallVector<std::pair<unsigned, unsigned>, 32> CorrelatedInitOrder;
5487
5488 for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5489 const void *InitKey = GetKeyForMember(SemaRef.Context, Inits[InitIndex]);
5490
5491 // Scan forward to try to find this initializer in the idealized
5492 // initializers list.
5493 for (; IdealIndex != NumIdealInits; ++IdealIndex)
5494 if (InitKey == IdealInitKeys[IdealIndex])
5495 break;
5496
5497 // If we didn't find this initializer, it must be because we
5498 // scanned past it on a previous iteration. That can only
5499 // happen if we're out of order; emit a warning.
5500 if (IdealIndex == NumIdealInits && InitIndex) {
5501 WarnIndexes.push_back(InitIndex);
5502
5503 // Move back to the initializer's location in the ideal list.
5504 for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
5505 if (InitKey == IdealInitKeys[IdealIndex])
5506 break;
5507
5508 assert(IdealIndex < NumIdealInits &&
5509 "initializer not found in initializer list");
5510 }
5511 CorrelatedInitOrder.emplace_back(IdealIndex, InitIndex);
5512 }
5513
5514 if (WarnIndexes.empty())
5515 return;
5516
5517 // Sort based on the ideal order, first in the pair.
5518 llvm::sort(CorrelatedInitOrder, llvm::less_first());
5519
5520 // Introduce a new scope as SemaDiagnosticBuilder needs to be destroyed to
5521 // emit the diagnostic before we can try adding notes.
5522 {
5524 Inits[WarnIndexes.front() - 1]->getSourceLocation(),
5525 WarnIndexes.size() == 1 ? diag::warn_initializer_out_of_order
5526 : diag::warn_some_initializers_out_of_order);
5527
5528 for (unsigned I = 0; I < CorrelatedInitOrder.size(); ++I) {
5529 if (CorrelatedInitOrder[I].second == I)
5530 continue;
5531 // Ideally we would be using InsertFromRange here, but clang doesn't
5532 // appear to handle InsertFromRange correctly when the source range is
5533 // modified by another fix-it.
5535 Inits[I]->getSourceRange(),
5538 Inits[CorrelatedInitOrder[I].second]->getSourceRange()),
5540 }
5541
5542 // If there is only 1 item out of order, the warning expects the name and
5543 // type of each being added to it.
5544 if (WarnIndexes.size() == 1) {
5545 AddInitializerToDiag(D, Inits[WarnIndexes.front() - 1],
5546 Inits[WarnIndexes.front()]);
5547 return;
5548 }
5549 }
5550 // More than 1 item to warn, create notes letting the user know which ones
5551 // are bad.
5552 for (unsigned WarnIndex : WarnIndexes) {
5553 const clang::CXXCtorInitializer *PrevInit = Inits[WarnIndex - 1];
5554 auto D = SemaRef.Diag(PrevInit->getSourceLocation(),
5555 diag::note_initializer_out_of_order);
5556 AddInitializerToDiag(D, PrevInit, Inits[WarnIndex]);
5557 D << PrevInit->getSourceRange();
5558 }
5559}
5560
5561namespace {
5562bool CheckRedundantInit(Sema &S,
5564 CXXCtorInitializer *&PrevInit) {
5565 if (!PrevInit) {
5566 PrevInit = Init;
5567 return false;
5568 }
5569
5570 if (FieldDecl *Field = Init->getAnyMember())
5571 S.Diag(Init->getSourceLocation(),
5572 diag::err_multiple_mem_initialization)
5573 << Field->getDeclName()
5574 << Init->getSourceRange();
5575 else {
5576 const Type *BaseClass = Init->getBaseClass();
5577 assert(BaseClass && "neither field nor base");
5578 S.Diag(Init->getSourceLocation(),
5579 diag::err_multiple_base_initialization)
5580 << QualType(BaseClass, 0)
5581 << Init->getSourceRange();
5582 }
5583 S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer)
5584 << 0 << PrevInit->getSourceRange();
5585
5586 return true;
5587}
5588
5589typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
5590typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
5591
5592bool CheckRedundantUnionInit(Sema &S,
5594 RedundantUnionMap &Unions) {
5595 FieldDecl *Field = Init->getAnyMember();
5596 RecordDecl *Parent = Field->getParent();
5597 NamedDecl *Child = Field;
5598
5599 while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {
5600 if (Parent->isUnion()) {
5601 UnionEntry &En = Unions[Parent];
5602 if (En.first && En.first != Child) {
5603 S.Diag(Init->getSourceLocation(),
5604 diag::err_multiple_mem_union_initialization)
5605 << Field->getDeclName()
5606 << Init->getSourceRange();
5607 S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
5608 << 0 << En.second->getSourceRange();
5609 return true;
5610 }
5611 if (!En.first) {
5612 En.first = Child;
5613 En.second = Init;
5614 }
5615 if (!Parent->isAnonymousStructOrUnion())
5616 return false;
5617 }
5618
5619 Child = Parent;
5620 Parent = cast<RecordDecl>(Parent->getDeclContext());
5621 }
5622
5623 return false;
5624}
5625} // namespace
5626
5627void Sema::ActOnMemInitializers(Decl *ConstructorDecl,
5628 SourceLocation ColonLoc,
5630 bool AnyErrors) {
5631 if (!ConstructorDecl)
5632 return;
5633
5634 AdjustDeclIfTemplate(ConstructorDecl);
5635
5636 CXXConstructorDecl *Constructor
5637 = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
5638
5639 if (!Constructor) {
5640 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
5641 return;
5642 }
5643
5644 // Mapping for the duplicate initializers check.
5645 // For member initializers, this is keyed with a FieldDecl*.
5646 // For base initializers, this is keyed with a Type*.
5647 llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
5648
5649 // Mapping for the inconsistent anonymous-union initializers check.
5650 RedundantUnionMap MemberUnions;
5651
5652 bool HadError = false;
5653 for (unsigned i = 0; i < MemInits.size(); i++) {
5654 CXXCtorInitializer *Init = MemInits[i];
5655
5656 // Set the source order index.
5657 Init->setSourceOrder(i);
5658
5659 if (Init->isAnyMemberInitializer()) {
5660 const void *Key = GetKeyForMember(Context, Init);
5661 if (CheckRedundantInit(*this, Init, Members[Key]) ||
5662 CheckRedundantUnionInit(*this, Init, MemberUnions))
5663 HadError = true;
5664 } else if (Init->isBaseInitializer()) {
5665 const void *Key = GetKeyForMember(Context, Init);
5666 if (CheckRedundantInit(*this, Init, Members[Key]))
5667 HadError = true;
5668 } else {
5669 assert(Init->isDelegatingInitializer());
5670 // This must be the only initializer
5671 if (MemInits.size() != 1) {
5672 Diag(Init->getSourceLocation(),
5673 diag::err_delegating_initializer_alone)
5674 << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
5675 // We will treat this as being the only initializer.
5676 }
5677 SetDelegatingInitializer(Constructor, MemInits[i]);
5678 // Return immediately as the initializer is set.
5679 return;
5680 }
5681 }
5682
5683 if (HadError)
5684 return;
5685
5686 DiagnoseBaseOrMemInitializerOrder(*this, Constructor, MemInits);
5687
5688 SetCtorInitializers(Constructor, AnyErrors, MemInits);
5689
5690 DiagnoseUninitializedFields(*this, Constructor);
5691}
5692
5693void
5695 CXXRecordDecl *ClassDecl) {
5696 // Ignore dependent contexts. Also ignore unions, since their members never
5697 // have destructors implicitly called.
5698 if (ClassDecl->isDependentContext() || ClassDecl->isUnion())
5699 return;
5700
5701 // FIXME: all the access-control diagnostics are positioned on the
5702 // field/base declaration. That's probably good; that said, the
5703 // user might reasonably want to know why the destructor is being
5704 // emitted, and we currently don't say.
5705
5706 // Non-static data members.
5707 for (auto *Field : ClassDecl->fields()) {
5708 if (Field->isInvalidDecl())
5709 continue;
5710
5711 // Don't destroy incomplete or zero-length arrays.
5712 if (isIncompleteOrZeroLengthArrayType(Context, Field->getType()))
5713 continue;
5714
5715 QualType FieldType = Context.getBaseElementType(Field->getType());
5716
5717 const RecordType* RT = FieldType->getAs<RecordType>();
5718 if (!RT)
5719 continue;
5720
5721 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
5722 if (FieldClassDecl->isInvalidDecl())
5723 continue;
5724 if (FieldClassDecl->hasIrrelevantDestructor())
5725 continue;
5726 // The destructor for an implicit anonymous union member is never invoked.
5727 if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
5728 continue;
5729
5730 CXXDestructorDecl *Dtor = LookupDestructor(FieldClassDecl);
5731 // Dtor might still be missing, e.g because it's invalid.
5732 if (!Dtor)
5733 continue;
5734 CheckDestructorAccess(Field->getLocation(), Dtor,
5735 PDiag(diag::err_access_dtor_field)
5736 << Field->getDeclName()
5737 << FieldType);
5738
5739 MarkFunctionReferenced(Location, Dtor);
5740 DiagnoseUseOfDecl(Dtor, Location);
5741 }
5742
5743 // We only potentially invoke the destructors of potentially constructed
5744 // subobjects.
5745 bool VisitVirtualBases = !ClassDecl->isAbstract();
5746
5747 // If the destructor exists and has already been marked used in the MS ABI,
5748 // then virtual base destructors have already been checked and marked used.
5749 // Skip checking them again to avoid duplicate diagnostics.
5751 CXXDestructorDecl *Dtor = ClassDecl->getDestructor();
5752 if (Dtor && Dtor->isUsed())
5753 VisitVirtualBases = false;
5754 }
5755
5757
5758 // Bases.
5759 for (const auto &Base : ClassDecl->bases()) {
5760 const RecordType *RT = Base.getType()->getAs<RecordType>();
5761 if (!RT)
5762 continue;
5763
5764 // Remember direct virtual bases.
5765 if (Base.isVirtual()) {
5766 if (!VisitVirtualBases)
5767 continue;
5768 DirectVirtualBases.insert(RT);
5769 }
5770
5771 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
5772 // If our base class is invalid, we probably can't get its dtor anyway.
5773 if (BaseClassDecl->isInvalidDecl())
5774 continue;
5775 if (BaseClassDecl->hasIrrelevantDestructor())
5776 continue;
5777
5778 CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
5779 // Dtor might still be missing, e.g because it's invalid.
5780 if (!Dtor)
5781 continue;
5782
5783 // FIXME: caret should be on the start of the class name
5784 CheckDestructorAccess(Base.getBeginLoc(), Dtor,
5785 PDiag(diag::err_access_dtor_base)
5786 << Base.getType() << Base.getSourceRange(),
5787 Context.getTypeDeclType(ClassDecl));
5788
5789 MarkFunctionReferenced(Location, Dtor);
5790 DiagnoseUseOfDecl(Dtor, Location);
5791 }
5792
5793 if (VisitVirtualBases)
5794 MarkVirtualBaseDestructorsReferenced(Location, ClassDecl,
5795 &DirectVirtualBases);
5796}
5797
5799 SourceLocation Location, CXXRecordDecl *ClassDecl,
5800 llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases) {
5801 // Virtual bases.
5802 for (const auto &VBase : ClassDecl->vbases()) {
5803 // Bases are always records in a well-formed non-dependent class.
5804 const RecordType *RT = VBase.getType()->castAs<RecordType>();
5805
5806 // Ignore already visited direct virtual bases.
5807 if (DirectVirtualBases && DirectVirtualBases->count(RT))
5808 continue;
5809
5810 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
5811 // If our base class is invalid, we probably can't get its dtor anyway.
5812 if (BaseClassDecl->isInvalidDecl())
5813 continue;
5814 if (BaseClassDecl->hasIrrelevantDestructor())
5815 continue;
5816
5817 CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
5818 // Dtor might still be missing, e.g because it's invalid.
5819 if (!Dtor)
5820 continue;
5822 ClassDecl->getLocation(), Dtor,
5823 PDiag(diag::err_access_dtor_vbase)
5824 << Context.getTypeDeclType(ClassDecl) << VBase.getType(),
5825 Context.getTypeDeclType(ClassDecl)) ==
5826 AR_accessible) {
5828 Context.getTypeDeclType(ClassDecl), VBase.getType(),
5829 diag::err_access_dtor_vbase, 0, ClassDecl->getLocation(),
5830 SourceRange(), DeclarationName(), nullptr);
5831 }
5832
5833 MarkFunctionReferenced(Location, Dtor);
5834 DiagnoseUseOfDecl(Dtor, Location);
5835 }
5836}
5837
5839 if (!CDtorDecl)
5840 return;
5841
5842 if (CXXConstructorDecl *Constructor
5843 = dyn_cast<CXXConstructorDecl>(CDtorDecl)) {
5844 if (CXXRecordDecl *ClassDecl = Constructor->getParent();
5845 !ClassDecl || ClassDecl->isInvalidDecl()) {
5846 return;
5847 }
5848 SetCtorInitializers(Constructor, /*AnyErrors=*/false);
5849 DiagnoseUninitializedFields(*this, Constructor);
5850 }
5851}
5852
5854 if (!getLangOpts().CPlusPlus)
5855 return false;
5856
5857 const auto *RD = Context.getBaseElementType(T)->getAsCXXRecordDecl();
5858 if (!RD)
5859 return false;
5860
5861 // FIXME: Per [temp.inst]p1, we are supposed to trigger instantiation of a
5862 // class template specialization here, but doing so breaks a lot of code.
5863
5864 // We can't answer whether something is abstract until it has a
5865 // definition. If it's currently being defined, we'll walk back
5866 // over all the declarations when we have a full definition.
5867 const CXXRecordDecl *Def = RD->getDefinition();
5868 if (!Def || Def->isBeingDefined())
5869 return false;
5870
5871 return RD->isAbstract();
5872}
5873
5875 TypeDiagnoser &Diagnoser) {
5876 if (!isAbstractType(Loc, T))
5877 return false;
5878
5880 Diagnoser.diagnose(*this, Loc, T);
5882 return true;
5883}
5884
5886 // Check if we've already emitted the list of pure virtual functions
5887 // for this class.
5889 return;
5890
5891 // If the diagnostic is suppressed, don't emit the notes. We're only
5892 // going to emit them once, so try to attach them to a diagnostic we're
5893 // actually going to show.
5895 return;
5896
5897 CXXFinalOverriderMap FinalOverriders;
5898 RD->getFinalOverriders(FinalOverriders);
5899
5900 // Keep a set of seen pure methods so we won't diagnose the same method
5901 // more than once.
5903
5904 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
5905 MEnd = FinalOverriders.end();
5906 M != MEnd;
5907 ++M) {
5908 for (OverridingMethods::iterator SO = M->second.begin(),
5909 SOEnd = M->second.end();
5910 SO != SOEnd; ++SO) {
5911 // C++ [class.abstract]p4:
5912 // A class is abstract if it contains or inherits at least one
5913 // pure virtual function for which the final overrider is pure
5914 // virtual.
5915
5916 //
5917 if (SO->second.size() != 1)
5918 continue;
5919
5920 if (!SO->second.front().Method->isPureVirtual())
5921 continue;
5922
5923 if (!SeenPureMethods.insert(SO->second.front().Method).second)
5924 continue;
5925
5926 Diag(SO->second.front().Method->getLocation(),
5927 diag::note_pure_virtual_function)
5928 << SO->second.front().Method->getDeclName() << RD->getDeclName();
5929 }
5930 }
5931
5934 PureVirtualClassDiagSet->insert(RD);
5935}
5936
5937namespace {
5938struct AbstractUsageInfo {
5939 Sema &S;
5941 CanQualType AbstractType;
5942 bool Invalid;
5943
5944 AbstractUsageInfo(Sema &S, CXXRecordDecl *Record)
5945 : S(S), Record(Record),
5946 AbstractType(S.Context.getCanonicalType(
5947 S.Context.getTypeDeclType(Record))),
5948 Invalid(false) {}
5949
5950 void DiagnoseAbstractType() {
5951 if (Invalid) return;
5953 Invalid = true;
5954 }
5955
5956 void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
5957};
5958
5959struct CheckAbstractUsage {
5960 AbstractUsageInfo &Info;
5961 const NamedDecl *Ctx;
5962
5963 CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
5964 : Info(Info), Ctx(Ctx) {}
5965
5966 void Visit(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
5967 switch (TL.getTypeLocClass()) {
5968#define ABSTRACT_TYPELOC(CLASS, PARENT)
5969#define TYPELOC(CLASS, PARENT) \
5970 case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
5971#include "clang/AST/TypeLocNodes.def"
5972 }
5973 }
5974
5975 void Check(FunctionProtoTypeLoc TL, Sema::AbstractDiagSelID Sel) {
5977 for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {
5978 if (!TL.getParam(I))
5979 continue;
5980
5982 if (TSI) Visit(TSI->getTypeLoc(), Sema::AbstractParamType);
5983 }
5984 }
5985
5986 void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) {
5988 }
5989
5991 // Visit the type parameters from a permissive context.
5992 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
5993 TemplateArgumentLoc TAL = TL.getArgLoc(I);
5995 if (TypeSourceInfo *TSI = TAL.getTypeSourceInfo())
5996 Visit(TSI->getTypeLoc(), Sema::AbstractNone);
5997 // TODO: other template argument types?
5998 }
5999 }
6000
6001 // Visit pointee types from a permissive context.
6002#define CheckPolymorphic(Type) \
6003 void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
6004 Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
6005 }
6011
6012 /// Handle all the types we haven't given a more specific
6013 /// implementation for above.
6014 void Check(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
6015 // Every other kind of type that we haven't called out already
6016 // that has an inner type is either (1) sugar or (2) contains that
6017 // inner type in some way as a subobject.
6018 if (TypeLoc Next = TL.getNextTypeLoc())
6019 return Visit(Next, Sel);
6020
6021 // If there's no inner type and we're in a permissive context,
6022 // don't diagnose.
6023 if (Sel == Sema::AbstractNone) return;
6024
6025 // Check whether the type matches the abstract type.
6026 QualType T = TL.getType();
6027 if (T->isArrayType()) {
6029 T = Info.S.Context.getBaseElementType(T);
6030 }
6032 if (CT != Info.AbstractType) return;
6033
6034 // It matched; do some magic.
6035 // FIXME: These should be at most warnings. See P0929R2, CWG1640, CWG1646.
6036 if (Sel == Sema::AbstractArrayType) {
6037 Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type)
6038 << T << TL.getSourceRange();
6039 } else {
6040 Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl)
6041 << Sel << T << TL.getSourceRange();
6042 }
6043 Info.DiagnoseAbstractType();
6044 }
6045};
6046
6047void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
6049 CheckAbstractUsage(*this, D).Visit(TL, Sel);
6050}
6051
6052}
6053
6054/// Check for invalid uses of an abstract type in a function declaration.
6055static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
6056 FunctionDecl *FD) {
6057 // Only definitions are required to refer to complete and
6058 // non-abstract types.
6060 return;
6061
6062 // For safety's sake, just ignore it if we don't have type source
6063 // information. This should never happen for non-implicit methods,
6064 // but...
6065 if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
6066 Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractNone);
6067}
6068
6069/// Check for invalid uses of an abstract type in a variable0 declaration.
6070static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
6071 VarDecl *VD) {
6072 // No need to do the check on definitions, which require that
6073 // the type is complete.
6075 return;
6076
6077 Info.CheckType(VD, VD->getTypeSourceInfo()->getTypeLoc(),
6079}
6080
6081/// Check for invalid uses of an abstract type within a class definition.
6082static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
6083 CXXRecordDecl *RD) {
6084 for (auto *D : RD->decls()) {
6085 if (D->isImplicit()) continue;
6086
6087 // Step through friends to the befriended declaration.
6088 if (auto *FD = dyn_cast<FriendDecl>(D)) {
6089 D = FD->getFriendDecl();
6090 if (!D) continue;
6091 }
6092
6093 // Functions and function templates.
6094 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
6095 CheckAbstractClassUsage(Info, FD);
6096 } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(D)) {
6097 CheckAbstractClassUsage(Info, FTD->getTemplatedDecl());
6098
6099 // Fields and static variables.
6100 } else if (auto *FD = dyn_cast<FieldDecl>(D)) {
6101 if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
6102 Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractFieldType);
6103 } else if (auto *VD = dyn_cast<VarDecl>(D)) {
6104 CheckAbstractClassUsage(Info, VD);
6105 } else if (auto *VTD = dyn_cast<VarTemplateDecl>(D)) {
6106 CheckAbstractClassUsage(Info, VTD->getTemplatedDecl());
6107
6108 // Nested classes and class templates.
6109 } else if (auto *RD = dyn_cast<CXXRecordDecl>(D)) {
6110 CheckAbstractClassUsage(Info, RD);
6111 } else if (auto *CTD = dyn_cast<ClassTemplateDecl>(D)) {
6112 CheckAbstractClassUsage(Info, CTD->getTemplatedDecl());
6113 }
6114 }
6115}
6116
6118 Attr *ClassAttr = getDLLAttr(Class);
6119 if (!ClassAttr)
6120 return;
6121
6122 assert(ClassAttr->getKind() == attr::DLLExport);
6123
6124 TemplateSpecializationKind TSK = Class->getTemplateSpecializationKind();
6125
6127 // Don't go any further if this is just an explicit instantiation
6128 // declaration.
6129 return;
6130
6131 // Add a context note to explain how we got to any diagnostics produced below.
6132 struct MarkingClassDllexported {
6133 Sema &S;
6134 MarkingClassDllexported(Sema &S, CXXRecordDecl *Class,
6135 SourceLocation AttrLoc)
6136 : S(S) {
6139 Ctx.PointOfInstantiation = AttrLoc;
6140 Ctx.Entity = Class;
6142 }
6143 ~MarkingClassDllexported() {
6145 }
6146 } MarkingDllexportedContext(S, Class, ClassAttr->getLocation());
6147
6148 if (S.Context.getTargetInfo().getTriple().isWindowsGNUEnvironment())
6149 S.MarkVTableUsed(Class->getLocation(), Class, true);
6150
6151 for (Decl *Member : Class->decls()) {
6152 // Skip members that were not marked exported.
6153 if (!Member->hasAttr<DLLExportAttr>())
6154 continue;
6155
6156 // Defined static variables that are members of an exported base
6157 // class must be marked export too.
6158 auto *VD = dyn_cast<VarDecl>(Member);
6159 if (VD && VD->getStorageClass() == SC_Static &&
6161 S.MarkVariableReferenced(VD->getLocation(), VD);
6162
6163 auto *MD = dyn_cast<CXXMethodDecl>(Member);
6164 if (!MD)
6165 continue;
6166
6167 if (MD->isUserProvided()) {
6168 // Instantiate non-default class member functions ...
6169
6170 // .. except for certain kinds of template specializations.
6171 if (TSK == TSK_ImplicitInstantiation && !ClassAttr->isInherited())
6172 continue;
6173
6174 // If this is an MS ABI dllexport default constructor, instantiate any
6175 // default arguments.
6177 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
6178 if (CD && CD->isDefaultConstructor() && TSK == TSK_Undeclared) {
6180 }
6181 }
6182
6183 S.MarkFunctionReferenced(Class->getLocation(), MD);
6184
6185 // The function will be passed to the consumer when its definition is
6186 // encountered.
6187 } else if (MD->isExplicitlyDefaulted()) {
6188 // Synthesize and instantiate explicitly defaulted methods.
6189 S.MarkFunctionReferenced(Class->getLocation(), MD);
6190
6192 // Except for explicit instantiation defs, we will not see the
6193 // definition again later, so pass it to the consumer now.
6195 }
6196 } else if (!MD->isTrivial() ||
6197 MD->isCopyAssignmentOperator() ||
6198 MD->isMoveAssignmentOperator()) {
6199 // Synthesize and instantiate non-trivial implicit methods, and the copy
6200 // and move assignment operators. The latter are exported even if they
6201 // are trivial, because the address of an operator can be taken and
6202 // should compare equal across libraries.
6203 S.MarkFunctionReferenced(Class->getLocation(), MD);
6204
6205 // There is no later point when we will see the definition of this
6206 // function, so pass it to the consumer now.
6208 }
6209 }
6210}
6211
6214 // Only the MS ABI has default constructor closures, so we don't need to do
6215 // this semantic checking anywhere else.
6217 return;
6218
6219 CXXConstructorDecl *LastExportedDefaultCtor = nullptr;
6220 for (Decl *Member : Class->decls()) {
6221 // Look for exported default constructors.
6222 auto *CD = dyn_cast<CXXConstructorDecl>(Member);
6223 if (!CD || !CD->isDefaultConstructor())
6224 continue;
6225 auto *Attr = CD->getAttr<DLLExportAttr>();
6226 if (!Attr)
6227 continue;
6228
6229 // If the class is non-dependent, mark the default arguments as ODR-used so
6230 // that we can properly codegen the constructor closure.
6231 if (!Class->isDependentContext()) {
6232 for (ParmVarDecl *PD : CD->parameters()) {
6233 (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), CD, PD);
6235 }
6236 }
6237
6238 if (LastExportedDefaultCtor) {
6239 S.Diag(LastExportedDefaultCtor->getLocation(),
6240 diag::err_attribute_dll_ambiguous_default_ctor)
6241 << Class;
6242 S.Diag(CD->getLocation(), diag::note_entity_declared_at)
6243 << CD->getDeclName();
6244 return;
6245 }
6246 LastExportedDefaultCtor = CD;
6247 }
6248}
6249
6252 bool ErrorReported = false;
6253 auto reportIllegalClassTemplate = [&ErrorReported](Sema &S,
6254 ClassTemplateDecl *TD) {
6255 if (ErrorReported)
6256 return;
6257 S.Diag(TD->getLocation(),
6258 diag::err_cuda_device_builtin_surftex_cls_template)
6259 << /*surface*/ 0 << TD;
6260 ErrorReported = true;
6261 };
6262
6263 ClassTemplateDecl *TD = Class->getDescribedClassTemplate();
6264 if (!TD) {
6265 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(Class);
6266 if (!SD) {
6267 S.Diag(Class->getLocation(),
6268 diag::err_cuda_device_builtin_surftex_ref_decl)
6269 << /*surface*/ 0 << Class;
6270 S.Diag(Class->getLocation(),
6271 diag::note_cuda_device_builtin_surftex_should_be_template_class)
6272 << Class;
6273 return;
6274 }
6275 TD = SD->getSpecializedTemplate();
6276 }
6277
6279 unsigned N = Params->size();
6280
6281 if (N != 2) {
6282 reportIllegalClassTemplate(S, TD);
6283 S.Diag(TD->getLocation(),
6284 diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6285 << TD << 2;
6286 }
6287 if (N > 0 && !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
6288 reportIllegalClassTemplate(S, TD);
6289 S.Diag(TD->getLocation(),
6290 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6291 << TD << /*1st*/ 0 << /*type*/ 0;
6292 }
6293 if (N > 1) {
6294 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->getParam(1));
6295 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6296 reportIllegalClassTemplate(S, TD);
6297 S.Diag(TD->getLocation(),
6298 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6299 << TD << /*2nd*/ 1 << /*integer*/ 1;
6300 }
6301 }
6302}
6303
6306 bool ErrorReported = false;
6307 auto reportIllegalClassTemplate = [&ErrorReported](Sema &S,
6308 ClassTemplateDecl *TD) {
6309 if (ErrorReported)
6310 return;
6311 S.Diag(TD->getLocation(),
6312 diag::err_cuda_device_builtin_surftex_cls_template)
6313 << /*texture*/ 1 << TD;
6314 ErrorReported = true;
6315 };
6316
6317 ClassTemplateDecl *TD = Class->getDescribedClassTemplate();
6318 if (!TD) {
6319 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(Class);
6320 if (!SD) {
6321 S.Diag(Class->getLocation(),
6322 diag::err_cuda_device_builtin_surftex_ref_decl)
6323 << /*texture*/ 1 << Class;
6324 S.Diag(Class->getLocation(),
6325 diag::note_cuda_device_builtin_surftex_should_be_template_class)
6326 << Class;
6327 return;
6328 }
6329 TD = SD->getSpecializedTemplate();
6330 }
6331
6333 unsigned N = Params->size();
6334
6335 if (N != 3) {
6336 reportIllegalClassTemplate(S, TD);
6337 S.Diag(TD->getLocation(),
6338 diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6339 << TD << 3;
6340 }
6341 if (N > 0 && !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
6342 reportIllegalClassTemplate(S, TD);
6343 S.Diag(TD->getLocation(),
6344 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6345 << TD << /*1st*/ 0 << /*type*/ 0;
6346 }
6347 if (N > 1) {
6348 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->getParam(1));
6349 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6350 reportIllegalClassTemplate(S, TD);
6351 S.Diag(TD->getLocation(),
6352 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6353 << TD << /*2nd*/ 1 << /*integer*/ 1;
6354 }
6355 }
6356 if (N > 2) {
6357 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->getParam(2));
6358 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6359 reportIllegalClassTemplate(S, TD);
6360 S.Diag(TD->getLocation(),
6361 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6362 << TD << /*3rd*/ 2 << /*integer*/ 1;
6363 }
6364 }
6365}
6366
6368 // Mark any compiler-generated routines with the implicit code_seg attribute.
6369 for (auto *Method : Class->methods()) {
6370 if (Method->isUserProvided())
6371 continue;
6372 if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(Method, /*IsDefinition=*/true))
6373 Method->addAttr(A);
6374 }
6375}
6376
6378 Attr *ClassAttr = getDLLAttr(Class);
6379
6380 // MSVC inherits DLL attributes to partial class template specializations.
6381 if (Context.getTargetInfo().shouldDLLImportComdatSymbols() && !ClassAttr) {
6382 if (auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(Class)) {
6383 if (Attr *TemplateAttr =
6384 getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
6385 auto *A = cast<InheritableAttr>(TemplateAttr->clone(getASTContext()));
6386 A->setInherited(true);
6387 ClassAttr = A;
6388 }
6389 }
6390 }
6391
6392 if (!ClassAttr)
6393 return;
6394
6395 // MSVC allows imported or exported template classes that have UniqueExternal
6396 // linkage. This occurs when the template class has been instantiated with
6397 // a template parameter which itself has internal linkage.
6398 // We drop the attribute to avoid exporting or importing any members.
6400 Context.getTargetInfo().getTriple().isPS()) &&
6401 (!Class->isExternallyVisible() && Class->hasExternalFormalLinkage())) {
6402 Class->dropAttrs<DLLExportAttr, DLLImportAttr>();
6403 return;
6404 }
6405
6406 if (!Class->isExternallyVisible()) {
6407 Diag(Class->getLocation(), diag::err_attribute_dll_not_extern)
6408 << Class << ClassAttr;
6409 return;
6410 }
6411
6413 !ClassAttr->isInherited()) {
6414 // Diagnose dll attributes on members of class with dll attribute.
6415 for (Decl *Member : Class->decls()) {
6416 if (!isa<VarDecl>(Member) && !isa<CXXMethodDecl>(Member))
6417 continue;
6418 InheritableAttr *MemberAttr = getDLLAttr(Member);
6419 if (!MemberAttr || MemberAttr->isInherited() || Member->isInvalidDecl())
6420 continue;
6421
6422 Diag(MemberAttr->getLocation(),
6423 diag::err_attribute_dll_member_of_dll_class)
6424 << MemberAttr << ClassAttr;
6425 Diag(ClassAttr->getLocation(), diag::note_previous_attribute);
6426 Member->setInvalidDecl();
6427 }
6428 }
6429
6430 if (Class->getDescribedClassTemplate())
6431 // Don't inherit dll attribute until the template is instantiated.
6432 return;
6433
6434 // The class is either imported or exported.
6435 const bool ClassExported = ClassAttr->getKind() == attr::DLLExport;
6436
6437 // Check if this was a dllimport attribute propagated from a derived class to
6438 // a base class template specialization. We don't apply these attributes to
6439 // static data members.
6440 const bool PropagatedImport =
6441 !ClassExported &&
6442 cast<DLLImportAttr>(ClassAttr)->wasPropagatedToBaseTemplate();
6443
6444 TemplateSpecializationKind TSK = Class->getTemplateSpecializationKind();
6445
6446 // Ignore explicit dllexport on explicit class template instantiation
6447 // declarations, except in MinGW mode.
6448 if (ClassExported && !ClassAttr->isInherited() &&
6450 !Context.getTargetInfo().getTriple().isWindowsGNUEnvironment()) {
6451 Class->dropAttr<DLLExportAttr>();
6452 return;
6453 }
6454
6455 // Force declaration of implicit members so they can inherit the attribute.
6457
6458 // FIXME: MSVC's docs say all bases must be exportable, but this doesn't
6459 // seem to be true in practice?
6460
6461 for (Decl *Member : Class->decls()) {
6462 VarDecl *VD = dyn_cast<VarDecl>(Member);
6463 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Member);
6464
6465 // Only methods and static fields inherit the attributes.
6466 if (!VD && !MD)
6467 continue;
6468
6469 if (MD) {
6470 // Don't process deleted methods.
6471 if (MD->isDeleted())
6472 continue;
6473
6474 if (MD->isInlined()) {
6475 // MinGW does not import or export inline methods. But do it for
6476 // template instantiations.
6480 continue;
6481
6482 // MSVC versions before 2015 don't export the move assignment operators
6483 // and move constructor, so don't attempt to import/export them if
6484 // we have a definition.
6485 auto *Ctor = dyn_cast<CXXConstructorDecl>(MD);
6486 if ((MD->isMoveAssignmentOperator() ||
6487 (Ctor && Ctor->isMoveConstructor())) &&
6488 !getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015))
6489 continue;
6490
6491 // MSVC2015 doesn't export trivial defaulted x-tor but copy assign
6492 // operator is exported anyway.
6493 if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
6494 (Ctor || isa<CXXDestructorDecl>(MD)) && MD->isTrivial())
6495 continue;
6496 }
6497 }
6498
6499 // Don't apply dllimport attributes to static data members of class template
6500 // instantiations when the attribute is propagated from a derived class.
6501 if (VD && PropagatedImport)
6502 continue;
6503
6504 if (!cast<NamedDecl>(Member)->isExternallyVisible())
6505 continue;
6506
6507 if (!getDLLAttr(Member)) {
6508 InheritableAttr *NewAttr = nullptr;
6509
6510 // Do not export/import inline function when -fno-dllexport-inlines is
6511 // passed. But add attribute for later local static var check.
6512 if (!getLangOpts().DllExportInlines && MD && MD->isInlined() &&
6515 if (ClassExported) {
6516 NewAttr = ::new (getASTContext())
6517 DLLExportStaticLocalAttr(getASTContext(), *ClassAttr);
6518 } else {
6519 NewAttr = ::new (getASTContext())
6520 DLLImportStaticLocalAttr(getASTContext(), *ClassAttr);
6521 }
6522 } else {
6523 NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
6524 }
6525
6526 NewAttr->setInherited(true);
6527 Member->addAttr(NewAttr);
6528
6529 if (MD) {
6530 // Propagate DLLAttr to friend re-declarations of MD that have already
6531 // been constructed.
6532 for (FunctionDecl *FD = MD->getMostRecentDecl(); FD;
6533 FD = FD->getPreviousDecl()) {
6535 continue;
6536 assert(!getDLLAttr(FD) &&
6537 "friend re-decl should not already have a DLLAttr");
6538 NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
6539 NewAttr->setInherited(true);
6540 FD->addAttr(NewAttr);
6541 }
6542 }
6543 }
6544 }
6545
6546 if (ClassExported)
6547 DelayedDllExportClasses.push_back(Class);
6548}
6549
6551 CXXRecordDecl *Class, Attr *ClassAttr,
6552 ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc) {
6553 if (getDLLAttr(
6554 BaseTemplateSpec->getSpecializedTemplate()->getTemplatedDecl())) {
6555 // If the base class template has a DLL attribute, don't try to change it.
6556 return;
6557 }
6558
6559 auto TSK = BaseTemplateSpec->getSpecializationKind();
6560 if (!getDLLAttr(BaseTemplateSpec) &&
6562 TSK == TSK_ImplicitInstantiation)) {
6563 // The template hasn't been instantiated yet (or it has, but only as an
6564 // explicit instantiation declaration or implicit instantiation, which means
6565 // we haven't codegenned any members yet), so propagate the attribute.
6566 auto *NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
6567 NewAttr->setInherited(true);
6568 BaseTemplateSpec->addAttr(NewAttr);
6569
6570 // If this was an import, mark that we propagated it from a derived class to
6571 // a base class template specialization.
6572 if (auto *ImportAttr = dyn_cast<DLLImportAttr>(NewAttr))
6573 ImportAttr->setPropagatedToBaseTemplate();
6574
6575 // If the template is already instantiated, checkDLLAttributeRedeclaration()
6576 // needs to be run again to work see the new attribute. Otherwise this will
6577 // get run whenever the template is instantiated.
6578 if (TSK != TSK_Undeclared)
6579 checkClassLevelDLLAttribute(BaseTemplateSpec);
6580
6581 return;
6582 }
6583
6584 if (getDLLAttr(BaseTemplateSpec)) {
6585 // The template has already been specialized or instantiated with an
6586 // attribute, explicitly or through propagation. We should not try to change
6587 // it.
6588 return;
6589 }
6590
6591 // The template was previously instantiated or explicitly specialized without
6592 // a dll attribute, It's too late for us to add an attribute, so warn that
6593 // this is unsupported.
6594 Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)
6595 << BaseTemplateSpec->isExplicitSpecialization();
6596 Diag(ClassAttr->getLocation(), diag::note_attribute);
6597 if (BaseTemplateSpec->isExplicitSpecialization()) {
6598 Diag(BaseTemplateSpec->getLocation(),
6599 diag::note_template_class_explicit_specialization_was_here)
6600 << BaseTemplateSpec;
6601 } else {
6602 Diag(BaseTemplateSpec->getPointOfInstantiation(),
6603 diag::note_template_class_instantiation_was_here)
6604 << BaseTemplateSpec;
6605 }
6606}
6607
6610 if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
6611 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
6612 if (Ctor->isDefaultConstructor())
6614
6615 if (Ctor->isCopyConstructor())
6617
6618 if (Ctor->isMoveConstructor())
6620 }
6621
6622 if (MD->isCopyAssignmentOperator())
6624
6625 if (MD->isMoveAssignmentOperator())
6627
6628 if (isa<CXXDestructorDecl>(FD))
6630 }
6631
6632 switch (FD->getDeclName().getCXXOverloadedOperator()) {
6633 case OO_EqualEqual:
6635
6636 case OO_ExclaimEqual:
6638
6639 case OO_Spaceship:
6640 // No point allowing this if <=> doesn't exist in the current language mode.
6641 if (!getLangOpts().CPlusPlus20)
6642 break;
6644
6645 case OO_Less:
6646 case OO_LessEqual:
6647 case OO_Greater:
6648 case OO_GreaterEqual:
6649 // No point allowing this if <=> doesn't exist in the current language mode.
6650 if (!getLangOpts().CPlusPlus20)
6651 break;
6653
6654 default:
6655 break;
6656 }
6657
6658 // Not defaultable.
6659 return DefaultedFunctionKind();
6660}
6661
6663 SourceLocation DefaultLoc) {
6665 if (DFK.isComparison())
6666 return S.DefineDefaultedComparison(DefaultLoc, FD, DFK.asComparison());
6667
6668 switch (DFK.asSpecialMember()) {
6671 cast<CXXConstructorDecl>(FD));
6672 break;
6674 S.DefineImplicitCopyConstructor(DefaultLoc, cast<CXXConstructorDecl>(FD));
6675 break;
6677 S.DefineImplicitCopyAssignment(DefaultLoc, cast<CXXMethodDecl>(FD));
6678 break;
6680 S.DefineImplicitDestructor(DefaultLoc, cast<CXXDestructorDecl>(FD));
6681 break;
6683 S.DefineImplicitMoveConstructor(DefaultLoc, cast<CXXConstructorDecl>(FD));
6684 break;
6686 S.DefineImplicitMoveAssignment(DefaultLoc, cast<CXXMethodDecl>(FD));
6687 break;
6689 llvm_unreachable("Invalid special member.");
6690 }
6691}
6692
6693/// Determine whether a type is permitted to be passed or returned in
6694/// registers, per C++ [class.temporary]p3.
6697 if (D->isDependentType() || D->isInvalidDecl())
6698 return false;
6699
6700 // Clang <= 4 used the pre-C++11 rule, which ignores move operations.
6701 // The PS4 platform ABI follows the behavior of Clang 3.2.
6703 return !D->hasNonTrivialDestructorForCall() &&
6704 !D->hasNonTrivialCopyConstructorForCall();
6705
6706 if (CCK == TargetInfo::CCK_MicrosoftWin64) {
6707 bool CopyCtorIsTrivial = false, CopyCtorIsTrivialForCall = false;
6708 bool DtorIsTrivialForCall = false;
6709
6710 // If a class has at least one eligible, trivial copy constructor, it
6711 // is passed according to the C ABI. Otherwise, it is passed indirectly.
6712 //
6713 // Note: This permits classes with non-trivial copy or move ctors to be
6714 // passed in registers, so long as they *also* have a trivial copy ctor,
6715 // which is non-conforming.
6716 if (D->needsImplicitCopyConstructor()) {
6717 if (!D->defaultedCopyConstructorIsDeleted()) {
6718 if (D->hasTrivialCopyConstructor())
6719 CopyCtorIsTrivial = true;
6720 if (D->hasTrivialCopyConstructorForCall())
6721 CopyCtorIsTrivialForCall = true;
6722 }
6723 } else {
6724 for (const CXXConstructorDecl *CD : D->ctors()) {
6725 if (CD->isCopyConstructor() && !CD->isDeleted() &&
6726 !CD->isIneligibleOrNotSelected()) {
6727 if (CD->isTrivial())
6728 CopyCtorIsTrivial = true;
6729 if (CD->isTrivialForCall())
6730 CopyCtorIsTrivialForCall = true;
6731 }
6732 }
6733 }
6734
6735 if (D->needsImplicitDestructor()) {
6736 if (!D->defaultedDestructorIsDeleted() &&
6737 D->hasTrivialDestructorForCall())
6738 DtorIsTrivialForCall = true;
6739 } else if (const auto *DD = D->getDestructor()) {
6740 if (!DD->isDeleted() && DD->isTrivialForCall())
6741 DtorIsTrivialForCall = true;
6742 }
6743
6744 // If the copy ctor and dtor are both trivial-for-calls, pass direct.
6745 if (CopyCtorIsTrivialForCall && DtorIsTrivialForCall)
6746 return true;
6747
6748 // If a class has a destructor, we'd really like to pass it indirectly
6749 // because it allows us to elide copies. Unfortunately, MSVC makes that
6750 // impossible for small types, which it will pass in a single register or
6751 // stack slot. Most objects with dtors are large-ish, so handle that early.
6752 // We can't call out all large objects as being indirect because there are
6753 // multiple x64 calling conventions and the C++ ABI code shouldn't dictate
6754 // how we pass large POD types.
6755
6756 // Note: This permits small classes with nontrivial destructors to be
6757 // passed in registers, which is non-conforming.
6758 bool isAArch64 = S.Context.getTargetInfo().getTriple().isAArch64();
6759 uint64_t TypeSize = isAArch64 ? 128 : 64;
6760
6761 if (CopyCtorIsTrivial &&
6762 S.getASTContext().getTypeSize(D->getTypeForDecl()) <= TypeSize)
6763 return true;
6764 return false;
6765 }
6766
6767 // Per C++ [class.temporary]p3, the relevant condition is:
6768 // each copy constructor, move constructor, and destructor of X is
6769 // either trivial or deleted, and X has at least one non-deleted copy
6770 // or move constructor
6771 bool HasNonDeletedCopyOrMove = false;
6772
6773 if (D->needsImplicitCopyConstructor() &&
6774 !D->defaultedCopyConstructorIsDeleted()) {
6775 if (!D->hasTrivialCopyConstructorForCall())
6776 return false;
6777 HasNonDeletedCopyOrMove = true;
6778 }
6779
6780 if (S.getLangOpts().CPlusPlus11 && D->needsImplicitMoveConstructor() &&
6781 !D->defaultedMoveConstructorIsDeleted()) {
6782 if (!D->hasTrivialMoveConstructorForCall())
6783 return false;
6784 HasNonDeletedCopyOrMove = true;
6785 }
6786
6787 if (D->needsImplicitDestructor() && !D->defaultedDestructorIsDeleted() &&
6788 !D->hasTrivialDestructorForCall())
6789 return false;
6790
6791 for (const CXXMethodDecl *MD : D->methods()) {
6792 if (MD->isDeleted() || MD->isIneligibleOrNotSelected())
6793 continue;
6794
6795 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
6796 if (CD && CD->isCopyOrMoveConstructor())
6797 HasNonDeletedCopyOrMove = true;
6798 else if (!isa<CXXDestructorDecl>(MD))
6799 continue;
6800
6801 if (!MD->isTrivialForCall())
6802 return false;
6803 }
6804
6805 return HasNonDeletedCopyOrMove;
6806}
6807
6808/// Report an error regarding overriding, along with any relevant
6809/// overridden methods.
6810///
6811/// \param DiagID the primary error to report.
6812/// \param MD the overriding method.
6813static bool
6814ReportOverrides(Sema &S, unsigned DiagID, const CXXMethodDecl *MD,
6815 llvm::function_ref<bool(const CXXMethodDecl *)> Report) {
6816 bool IssuedDiagnostic = false;
6817 for (const CXXMethodDecl *O : MD->overridden_methods()) {
6818 if (Report(O)) {
6819 if (!IssuedDiagnostic) {
6820 S.Diag(MD->getLocation(), DiagID) << MD->getDeclName();
6821 IssuedDiagnostic = true;
6822 }
6823 S.Diag(O->getLocation(), diag::note_overridden_virtual_function);
6824 }
6825 }
6826 return IssuedDiagnostic;
6827}
6828
6830 if (!Record)
6831 return;
6832
6833 if (Record->isAbstract() && !Record->isInvalidDecl()) {
6834 AbstractUsageInfo Info(*this, Record);
6836 }
6837
6838 // If this is not an aggregate type and has no user-declared constructor,
6839 // complain about any non-static data members of reference or const scalar
6840 // type, since they will never get initializers.
6841 if (!Record->isInvalidDecl() && !Record->isDependentType() &&
6842 !Record->isAggregate() && !Record->hasUserDeclaredConstructor() &&
6843 !Record->isLambda()) {
6844 bool Complained = false;
6845 for (const auto *F : Record->fields()) {
6846 if (F->hasInClassInitializer() || F->isUnnamedBitField())
6847 continue;
6848
6849 if (F->getType()->isReferenceType() ||
6850 (F->getType().isConstQualified() && F->getType()->isScalarType())) {
6851 if (!Complained) {
6852 Diag(Record->getLocation(), diag::warn_no_constructor_for_refconst)
6853 << llvm::to_underlying(Record->getTagKind()) << Record;
6854 Complained = true;
6855 }
6856
6857 Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
6858 << F->getType()->isReferenceType()
6859 << F->getDeclName();
6860 }
6861 }
6862 }
6863
6864 if (Record->getIdentifier()) {
6865 // C++ [class.mem]p13:
6866 // If T is the name of a class, then each of the following shall have a
6867 // name different from T:
6868 // - every member of every anonymous union that is a member of class T.
6869 //
6870 // C++ [class.mem]p14:
6871 // In addition, if class T has a user-declared constructor (12.1), every
6872 // non-static data member of class T shall have a name different from T.
6873 DeclContext::lookup_result R = Record->lookup(Record->getDeclName());
6874 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
6875 ++I) {
6876 NamedDecl *D = (*I)->getUnderlyingDecl();
6877 if (((isa<FieldDecl>(D) || isa<UnresolvedUsingValueDecl>(D)) &&
6878 Record->hasUserDeclaredConstructor()) ||
6879 isa<IndirectFieldDecl>(D)) {
6880 Diag((*I)->getLocation(), diag::err_member_name_of_class)
6881 << D->getDeclName();
6882 break;
6883 }
6884 }
6885 }
6886
6887 // Warn if the class has virtual methods but non-virtual public destructor.
6888 if (Record->isPolymorphic() && !Record->isDependentType()) {
6889 CXXDestructorDecl *dtor = Record->getDestructor();
6890 if ((!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public)) &&
6891 !Record->hasAttr<FinalAttr>())
6892 Diag(dtor ? dtor->getLocation() : Record->getLocation(),
6893 diag::warn_non_virtual_dtor) << Context.getRecordType(Record);
6894 }
6895
6896 if (Record->isAbstract()) {
6897 if (FinalAttr *FA = Record->getAttr<FinalAttr>()) {
6898 Diag(Record->getLocation(), diag::warn_abstract_final_class)
6899 << FA->isSpelledAsSealed();
6901 }
6902 }
6903
6904 // Warn if the class has a final destructor but is not itself marked final.
6905 if (!Record->hasAttr<FinalAttr>()) {
6906 if (const CXXDestructorDecl *dtor = Record->getDestructor()) {
6907 if (const FinalAttr *FA = dtor->getAttr<FinalAttr>()) {
6908 Diag(FA->getLocation(), diag::warn_final_dtor_non_final_class)
6909 << FA->isSpelledAsSealed()
6911 getLocForEndOfToken(Record->getLocation()),
6912 (FA->isSpelledAsSealed() ? " sealed" : " final"));
6913 Diag(Record->getLocation(),
6914 diag::note_final_dtor_non_final_class_silence)
6915 << Context.getRecordType(Record) << FA->isSpelledAsSealed();
6916 }
6917 }
6918 }
6919
6920 // See if trivial_abi has to be dropped.
6921 if (Record->hasAttr<TrivialABIAttr>())
6923
6924 // Set HasTrivialSpecialMemberForCall if the record has attribute
6925 // "trivial_abi".
6926 bool HasTrivialABI = Record->hasAttr<TrivialABIAttr>();
6927
6928 if (HasTrivialABI)
6929 Record->setHasTrivialSpecialMemberForCall();
6930
6931 // Explicitly-defaulted secondary comparison functions (!=, <, <=, >, >=).
6932 // We check these last because they can depend on the properties of the
6933 // primary comparison functions (==, <=>).
6934 llvm::SmallVector<FunctionDecl*, 5> DefaultedSecondaryComparisons;
6935
6936 // Perform checks that can't be done until we know all the properties of a
6937 // member function (whether it's defaulted, deleted, virtual, overriding,
6938 // ...).
6939 auto CheckCompletedMemberFunction = [&](CXXMethodDecl *MD) {
6940 // A static function cannot override anything.
6941 if (MD->getStorageClass() == SC_Static) {
6942 if (ReportOverrides(*this, diag::err_static_overrides_virtual, MD,
6943 [](const CXXMethodDecl *) { return true; }))
6944 return;
6945 }
6946
6947 // A deleted function cannot override a non-deleted function and vice
6948 // versa.
6949 if (ReportOverrides(*this,
6950 MD->isDeleted() ? diag::err_deleted_override
6951 : diag::err_non_deleted_override,
6952 MD, [&](const CXXMethodDecl *V) {
6953 return MD->isDeleted() != V->isDeleted();
6954 })) {
6955 if (MD->isDefaulted() && MD->isDeleted())
6956 // Explain why this defaulted function was deleted.
6958 return;
6959 }
6960
6961 // A consteval function cannot override a non-consteval function and vice
6962 // versa.
6963 if (ReportOverrides(*this,
6964 MD->isConsteval() ? diag::err_consteval_override
6965 : diag::err_non_consteval_override,
6966 MD, [&](const CXXMethodDecl *V) {
6967 return MD->isConsteval() != V->isConsteval();
6968 })) {
6969 if (MD->isDefaulted() && MD->isDeleted())
6970 // Explain why this defaulted function was deleted.
6972 return;
6973 }
6974 };
6975
6976 auto CheckForDefaultedFunction = [&](FunctionDecl *FD) -> bool {
6977 if (!FD || FD->isInvalidDecl() || !FD->isExplicitlyDefaulted())
6978 return false;
6979
6983 DefaultedSecondaryComparisons.push_back(FD);
6984 return true;
6985 }
6986
6988 return false;
6989 };
6990
6991 if (!Record->isInvalidDecl() &&
6992 Record->hasAttr<VTablePointerAuthenticationAttr>())
6994
6995 auto CompleteMemberFunction = [&](CXXMethodDecl *M) {
6996 // Check whether the explicitly-defaulted members are valid.
6997 bool Incomplete = CheckForDefaultedFunction(M);
6998
6999 // Skip the rest of the checks for a member of a dependent class.
7000 if (Record->isDependentType())
7001 return;
7002
7003 // For an explicitly defaulted or deleted special member, we defer
7004 // determining triviality until the class is complete. That time is now!
7006 if (!M->isImplicit() && !M->isUserProvided()) {
7007 if (CSM != CXXSpecialMemberKind::Invalid) {
7008 M->setTrivial(SpecialMemberIsTrivial(M, CSM));
7009 // Inform the class that we've finished declaring this member.
7010 Record->finishedDefaultedOrDeletedMember(M);
7011 M->setTrivialForCall(
7012 HasTrivialABI ||
7014 Record->setTrivialForCallFlags(M);
7015 }
7016 }
7017
7018 // Set triviality for the purpose of calls if this is a user-provided
7019 // copy/move constructor or destructor.
7023 M->isUserProvided()) {
7024 M->setTrivialForCall(HasTrivialABI);
7025 Record->setTrivialForCallFlags(M);
7026 }
7027
7028 if (!M->isInvalidDecl() && M->isExplicitlyDefaulted() &&
7029 M->hasAttr<DLLExportAttr>()) {
7030 if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
7031 M->isTrivial() &&
7035 M->dropAttr<DLLExportAttr>();
7036
7037 if (M->hasAttr<DLLExportAttr>()) {
7038 // Define after any fields with in-class initializers have been parsed.
7040 }
7041 }
7042
7043 bool EffectivelyConstexprDestructor = true;
7044 // Avoid triggering vtable instantiation due to a dtor that is not
7045 // "effectively constexpr" for better compatibility.
7046 // See https://github.com/llvm/llvm-project/issues/102293 for more info.
7047 if (isa<CXXDestructorDecl>(M)) {
7048 auto Check = [](QualType T, auto &&Check) -> bool {
7049 const CXXRecordDecl *RD =
7051 if (!RD || !RD->isCompleteDefinition())
7052 return true;
7053
7054 if (!RD->hasConstexprDestructor())
7055 return false;
7056
7057 QualType CanUnqualT = T.getCanonicalType().getUnqualifiedType();
7058 for (const CXXBaseSpecifier &B : RD->bases())
7059 if (B.getType().getCanonicalType().getUnqualifiedType() !=
7060 CanUnqualT &&
7061 !Check(B.getType(), Check))
7062 return false;
7063 for (const FieldDecl *FD : RD->fields())
7065 CanUnqualT &&
7066 !Check(FD->getType(), Check))
7067 return false;
7068 return true;
7069 };
7070 EffectivelyConstexprDestructor =
7071 Check(QualType(Record->getTypeForDecl(), 0), Check);
7072 }
7073
7074 // Define defaulted constexpr virtual functions that override a base class
7075 // function right away.
7076 // FIXME: We can defer doing this until the vtable is marked as used.
7077 if (CSM != CXXSpecialMemberKind::Invalid && !M->isDeleted() &&
7078 M->isDefaulted() && M->isConstexpr() && M->size_overridden_methods() &&
7079 EffectivelyConstexprDestructor)
7080 DefineDefaultedFunction(*this, M, M->getLocation());
7081
7082 if (!Incomplete)
7083 CheckCompletedMemberFunction(M);
7084 };
7085
7086 // Check the destructor before any other member function. We need to
7087 // determine whether it's trivial in order to determine whether the claas
7088 // type is a literal type, which is a prerequisite for determining whether
7089 // other special member functions are valid and whether they're implicitly
7090 // 'constexpr'.
7091 if (CXXDestructorDecl *Dtor = Record->getDestructor())
7092 CompleteMemberFunction(Dtor);
7093
7094 bool HasMethodWithOverrideControl = false,
7095 HasOverridingMethodWithoutOverrideControl = false;
7096 for (auto *D : Record->decls()) {
7097 if (auto *M = dyn_cast<CXXMethodDecl>(D)) {
7098 // FIXME: We could do this check for dependent types with non-dependent
7099 // bases.
7100 if (!Record->isDependentType()) {
7101 // See if a method overloads virtual methods in a base
7102 // class without overriding any.
7103 if (!M->isStatic())
7105 if (M->hasAttr<OverrideAttr>())
7106 HasMethodWithOverrideControl = true;
7107 else if (M->size_overridden_methods() > 0)
7108 HasOverridingMethodWithoutOverrideControl = true;
7109 }
7110
7111 if (!isa<CXXDestructorDecl>(M))
7112 CompleteMemberFunction(M);
7113 } else if (auto *F = dyn_cast<FriendDecl>(D)) {
7114 CheckForDefaultedFunction(
7115 dyn_cast_or_null<FunctionDecl>(F->getFriendDecl()));
7116 }
7117 }
7118
7119 if (HasOverridingMethodWithoutOverrideControl) {
7120 bool HasInconsistentOverrideControl = HasMethodWithOverrideControl;
7121 for (auto *M : Record->methods())
7122 DiagnoseAbsenceOfOverrideControl(M, HasInconsistentOverrideControl);
7123 }
7124
7125 // Check the defaulted secondary comparisons after any other member functions.
7126 for (FunctionDecl *FD : DefaultedSecondaryComparisons) {
7128
7129 // If this is a member function, we deferred checking it until now.
7130 if (auto *MD = dyn_cast<CXXMethodDecl>(FD))
7131 CheckCompletedMemberFunction(MD);
7132 }
7133
7134 // ms_struct is a request to use the same ABI rules as MSVC. Check
7135 // whether this class uses any C++ features that are implemented
7136 // completely differently in MSVC, and if so, emit a diagnostic.
7137 // That diagnostic defaults to an error, but we allow projects to
7138 // map it down to a warning (or ignore it). It's a fairly common
7139 // practice among users of the ms_struct pragma to mass-annotate
7140 // headers, sweeping up a bunch of types that the project doesn't
7141 // really rely on MSVC-compatible layout for. We must therefore
7142 // support "ms_struct except for C++ stuff" as a secondary ABI.
7143 // Don't emit this diagnostic if the feature was enabled as a
7144 // language option (as opposed to via a pragma or attribute), as
7145 // the option -mms-bitfields otherwise essentially makes it impossible
7146 // to build C++ code, unless this diagnostic is turned off.
7147 if (Record->isMsStruct(Context) && !Context.getLangOpts().MSBitfields &&
7148 (Record->isPolymorphic() || Record->getNumBases())) {
7149 Diag(Record->getLocation(), diag::warn_cxx_ms_struct);
7150 }
7151
7154
7155 bool ClangABICompat4 =
7156 Context.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver4;
7158 Context.getTargetInfo().getCallingConvKind(ClangABICompat4);
7159 bool CanPass = canPassInRegisters(*this, Record, CCK);
7160
7161 // Do not change ArgPassingRestrictions if it has already been set to
7162 // RecordArgPassingKind::CanNeverPassInRegs.
7163 if (Record->getArgPassingRestrictions() !=
7165 Record->setArgPassingRestrictions(
7168
7169 // If canPassInRegisters returns true despite the record having a non-trivial
7170 // destructor, the record is destructed in the callee. This happens only when
7171 // the record or one of its subobjects has a field annotated with trivial_abi
7172 // or a field qualified with ObjC __strong/__weak.
7174 Record->setParamDestroyedInCallee(true);
7175 else if (Record->hasNonTrivialDestructor())
7176 Record->setParamDestroyedInCallee(CanPass);
7177
7178 if (getLangOpts().ForceEmitVTables) {
7179 // If we want to emit all the vtables, we need to mark it as used. This
7180 // is especially required for cases like vtable assumption loads.
7181 MarkVTableUsed(Record->getInnerLocStart(), Record);
7182 }
7183
7184 if (getLangOpts().CUDA) {
7185 if (Record->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>())
7187 else if (Record->hasAttr<CUDADeviceBuiltinTextureTypeAttr>())
7189 }
7190}
7191
7192/// Look up the special member function that would be called by a special
7193/// member function for a subobject of class type.
7194///
7195/// \param Class The class type of the subobject.
7196/// \param CSM The kind of special member function.
7197/// \param FieldQuals If the subobject is a field, its cv-qualifiers.
7198/// \param ConstRHS True if this is a copy operation with a const object
7199/// on its RHS, that is, if the argument to the outer special member
7200/// function is 'const' and this is not a field marked 'mutable'.
7203 CXXSpecialMemberKind CSM, unsigned FieldQuals,
7204 bool ConstRHS) {
7205 unsigned LHSQuals = 0;
7208 LHSQuals = FieldQuals;
7209
7210 unsigned RHSQuals = FieldQuals;
7213 RHSQuals = 0;
7214 else if (ConstRHS)
7215 RHSQuals |= Qualifiers::Const;
7216
7217 return S.LookupSpecialMember(Class, CSM,
7218 RHSQuals & Qualifiers::Const,
7219 RHSQuals & Qualifiers::Volatile,
7220 false,
7221 LHSQuals & Qualifiers::Const,
7222 LHSQuals & Qualifiers::Volatile);
7223}
7224
7226 Sema &S;
7227 SourceLocation UseLoc;
7228
7229 /// A mapping from the base classes through which the constructor was
7230 /// inherited to the using shadow declaration in that base class (or a null
7231 /// pointer if the constructor was declared in that base class).
7232 llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
7233 InheritedFromBases;
7234
7235public:
7238 : S(S), UseLoc(UseLoc) {
7239 bool DiagnosedMultipleConstructedBases = false;
7240 CXXRecordDecl *ConstructedBase = nullptr;
7241 BaseUsingDecl *ConstructedBaseIntroducer = nullptr;
7242
7243 // Find the set of such base class subobjects and check that there's a
7244 // unique constructed subobject.
7245 for (auto *D : Shadow->redecls()) {
7246 auto *DShadow = cast<ConstructorUsingShadowDecl>(D);
7247 auto *DNominatedBase = DShadow->getNominatedBaseClass();
7248 auto *DConstructedBase = DShadow->getConstructedBaseClass();
7249
7250 InheritedFromBases.insert(
7251 std::make_pair(DNominatedBase->getCanonicalDecl(),
7252 DShadow->getNominatedBaseClassShadowDecl()));
7253 if (DShadow->constructsVirtualBase())
7254 InheritedFromBases.insert(
7255 std::make_pair(DConstructedBase->getCanonicalDecl(),
7256 DShadow->getConstructedBaseClassShadowDecl()));
7257 else
7258 assert(DNominatedBase == DConstructedBase);
7259
7260 // [class.inhctor.init]p2:
7261 // If the constructor was inherited from multiple base class subobjects
7262 // of type B, the program is ill-formed.
7263 if (!ConstructedBase) {
7264 ConstructedBase = DConstructedBase;
7265 ConstructedBaseIntroducer = D->getIntroducer();
7266 } else if (ConstructedBase != DConstructedBase &&
7267 !Shadow->isInvalidDecl()) {
7268 if (!DiagnosedMultipleConstructedBases) {
7269 S.Diag(UseLoc, diag::err_ambiguous_inherited_constructor)
7270 << Shadow->getTargetDecl();
7271 S.Diag(ConstructedBaseIntroducer->getLocation(),
7272 diag::note_ambiguous_inherited_constructor_using)
7273 << ConstructedBase;
7274 DiagnosedMultipleConstructedBases = true;
7275 }
7276 S.Diag(D->getIntroducer()->getLocation(),
7277 diag::note_ambiguous_inherited_constructor_using)
7278 << DConstructedBase;
7279 }
7280 }
7281
7282 if (DiagnosedMultipleConstructedBases)
7283 Shadow->setInvalidDecl();
7284 }
7285
7286 /// Find the constructor to use for inherited construction of a base class,
7287 /// and whether that base class constructor inherits the constructor from a
7288 /// virtual base class (in which case it won't actually invoke it).
7289 std::pair<CXXConstructorDecl *, bool>
7291 auto It = InheritedFromBases.find(Base->getCanonicalDecl());
7292 if (It == InheritedFromBases.end())
7293 return std::make_pair(nullptr, false);
7294
7295 // This is an intermediary class.
7296 if (It->second)
7297 return std::make_pair(
7298 S.findInheritingConstructor(UseLoc, Ctor, It->second),
7299 It->second->constructsVirtualBase());
7300
7301 // This is the base class from which the constructor was inherited.
7302 return std::make_pair(Ctor, false);
7303 }
7304};
7305
7306/// Is the special member function which would be selected to perform the
7307/// specified operation on the specified class type a constexpr constructor?
7309 Sema &S, CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, unsigned Quals,
7310 bool ConstRHS, CXXConstructorDecl *InheritedCtor = nullptr,
7311 Sema::InheritedConstructorInfo *Inherited = nullptr) {
7312 // Suppress duplicate constraint checking here, in case a constraint check
7313 // caused us to decide to do this. Any truely recursive checks will get
7314 // caught during these checks anyway.
7316
7317 // If we're inheriting a constructor, see if we need to call it for this base
7318 // class.
7319 if (InheritedCtor) {
7321 auto BaseCtor =
7322 Inherited->findConstructorForBase(ClassDecl, InheritedCtor).first;
7323 if (BaseCtor)
7324 return BaseCtor->isConstexpr();
7325 }
7326
7328 return ClassDecl->hasConstexprDefaultConstructor();
7330 return ClassDecl->hasConstexprDestructor();
7331
7333 lookupCallFromSpecialMember(S, ClassDecl, CSM, Quals, ConstRHS);
7334 if (!SMOR.getMethod())
7335 // A constructor we wouldn't select can't be "involved in initializing"
7336 // anything.
7337 return true;
7338 return SMOR.getMethod()->isConstexpr();
7339}
7340
7341/// Determine whether the specified special member function would be constexpr
7342/// if it were implicitly defined.
7344 Sema &S, CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, bool ConstArg,
7345 CXXConstructorDecl *InheritedCtor = nullptr,
7346 Sema::InheritedConstructorInfo *Inherited = nullptr) {
7347 if (!S.getLangOpts().CPlusPlus11)
7348 return false;
7349
7350 // C++11 [dcl.constexpr]p4:
7351 // In the definition of a constexpr constructor [...]
7352 bool Ctor = true;
7353 switch (CSM) {
7355 if (Inherited)
7356 break;
7357 // Since default constructor lookup is essentially trivial (and cannot
7358 // involve, for instance, template instantiation), we compute whether a
7359 // defaulted default constructor is constexpr directly within CXXRecordDecl.
7360 //
7361 // This is important for performance; we need to know whether the default
7362 // constructor is constexpr to determine whether the type is a literal type.
7363 return ClassDecl->defaultedDefaultConstructorIsConstexpr();
7364
7367 // For copy or move constructors, we need to perform overload resolution.
7368 break;
7369
7372 if (!S.getLangOpts().CPlusPlus14)
7373 return false;
7374 // In C++1y, we need to perform overload resolution.
7375 Ctor = false;
7376 break;
7377
7379 return ClassDecl->defaultedDestructorIsConstexpr();
7380
7382 return false;
7383 }
7384
7385 // -- if the class is a non-empty union, or for each non-empty anonymous
7386 // union member of a non-union class, exactly one non-static data member
7387 // shall be initialized; [DR1359]
7388 //
7389 // If we squint, this is guaranteed, since exactly one non-static data member
7390 // will be initialized (if the constructor isn't deleted), we just don't know
7391 // which one.
7392 if (Ctor && ClassDecl->isUnion())
7394 ? ClassDecl->hasInClassInitializer() ||
7395 !ClassDecl->hasVariantMembers()
7396 : true;
7397
7398 // -- the class shall not have any virtual base classes;
7399 if (Ctor && ClassDecl->getNumVBases())
7400 return false;
7401
7402 // C++1y [class.copy]p26:
7403 // -- [the class] is a literal type, and
7404 if (!Ctor && !ClassDecl->isLiteral() && !S.getLangOpts().CPlusPlus23)
7405 return false;
7406
7407 // -- every constructor involved in initializing [...] base class
7408 // sub-objects shall be a constexpr constructor;
7409 // -- the assignment operator selected to copy/move each direct base
7410 // class is a constexpr function, and
7411 if (!S.getLangOpts().CPlusPlus23) {
7412 for (const auto &B : ClassDecl->bases()) {
7413 const RecordType *BaseType = B.getType()->getAs<RecordType>();
7414 if (!BaseType)
7415 continue;
7416 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
7417 if (!specialMemberIsConstexpr(S, BaseClassDecl, CSM, 0, ConstArg,
7418 InheritedCtor, Inherited))
7419 return false;
7420 }
7421 }
7422
7423 // -- every constructor involved in initializing non-static data members
7424 // [...] shall be a constexpr constructor;
7425 // -- every non-static data member and base class sub-object shall be
7426 // initialized
7427 // -- for each non-static data member of X that is of class type (or array
7428 // thereof), the assignment operator selected to copy/move that member is
7429 // a constexpr function
7430 if (!S.getLangOpts().CPlusPlus23) {
7431 for (const auto *F : ClassDecl->fields()) {
7432 if (F->isInvalidDecl())
7433 continue;
7435 F->hasInClassInitializer())
7436 continue;
7437 QualType BaseType = S.Context.getBaseElementType(F->getType());
7438 if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
7439 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
7440 if (!specialMemberIsConstexpr(S, FieldRecDecl, CSM,
7441 BaseType.getCVRQualifiers(),
7442 ConstArg && !F->isMutable()))
7443 return false;
7444 } else if (CSM == CXXSpecialMemberKind::DefaultConstructor) {
7445 return false;
7446 }
7447 }
7448 }
7449
7450 // All OK, it's constexpr!
7451 return true;
7452}
7453
7454namespace {
7455/// RAII object to register a defaulted function as having its exception
7456/// specification computed.
7457struct ComputingExceptionSpec {
7458 Sema &S;
7459
7460 ComputingExceptionSpec(Sema &S, FunctionDecl *FD, SourceLocation Loc)
7461 : S(S) {
7465 Ctx.Entity = FD;
7467 }
7468 ~ComputingExceptionSpec() {
7470 }
7471};
7472}
7473
7476 CXXMethodDecl *MD,
7479
7482 FunctionDecl *FD,
7484
7487 auto DFK = S.getDefaultedFunctionKind(FD);
7488 if (DFK.isSpecialMember())
7490 S, Loc, cast<CXXMethodDecl>(FD), DFK.asSpecialMember(), nullptr);
7491 if (DFK.isComparison())
7493 DFK.asComparison());
7494
7495 auto *CD = cast<CXXConstructorDecl>(FD);
7496 assert(CD->getInheritedConstructor() &&
7497 "only defaulted functions and inherited constructors have implicit "
7498 "exception specs");
7500 S, Loc, CD->getInheritedConstructor().getShadowDecl());
7503}
7504
7506 CXXMethodDecl *MD) {
7508
7509 // Build an exception specification pointing back at this member.
7511 EPI.ExceptionSpec.SourceDecl = MD;
7512
7513 // Set the calling convention to the default for C++ instance methods.
7515 S.Context.getDefaultCallingConvention(/*IsVariadic=*/false,
7516 /*IsCXXMethod=*/true));
7517 return EPI;
7518}
7519
7521 const FunctionProtoType *FPT = FD->getType()->castAs<FunctionProtoType>();
7523 return;
7524
7525 // Evaluate the exception specification.
7526 auto IES = computeImplicitExceptionSpec(*this, Loc, FD);
7527 auto ESI = IES.getExceptionSpec();
7528
7529 // Update the type of the special member to use it.
7530 UpdateExceptionSpec(FD, ESI);
7531}
7532
7534 assert(FD->isExplicitlyDefaulted() && "not explicitly-defaulted");
7535
7537 if (!DefKind) {
7538 assert(FD->getDeclContext()->isDependentContext());
7539 return;
7540 }
7541
7542 if (DefKind.isComparison()) {
7543 auto PT = FD->getParamDecl(0)->getType();
7544 if (const CXXRecordDecl *RD =
7545 PT.getNonReferenceType()->getAsCXXRecordDecl()) {
7546 for (FieldDecl *Field : RD->fields()) {
7547 UnusedPrivateFields.remove(Field);
7548 }
7549 }
7550 }
7551
7552 if (DefKind.isSpecialMember()
7553 ? CheckExplicitlyDefaultedSpecialMember(cast<CXXMethodDecl>(FD),
7554 DefKind.asSpecialMember(),
7555 FD->getDefaultLoc())
7557 FD->setInvalidDecl();
7558}
7559
7562 SourceLocation DefaultLoc) {
7563 CXXRecordDecl *RD = MD->getParent();
7564
7566 "not an explicitly-defaulted special member");
7567
7568 // Defer all checking for special members of a dependent type.
7569 if (RD->isDependentType())
7570 return false;
7571
7572 // Whether this was the first-declared instance of the constructor.
7573 // This affects whether we implicitly add an exception spec and constexpr.
7574 bool First = MD == MD->getCanonicalDecl();
7575
7576 bool HadError = false;
7577
7578 // C++11 [dcl.fct.def.default]p1:
7579 // A function that is explicitly defaulted shall
7580 // -- be a special member function [...] (checked elsewhere),
7581 // -- have the same type (except for ref-qualifiers, and except that a
7582 // copy operation can take a non-const reference) as an implicit
7583 // declaration, and
7584 // -- not have default arguments.
7585 // C++2a changes the second bullet to instead delete the function if it's
7586 // defaulted on its first declaration, unless it's "an assignment operator,
7587 // and its return type differs or its parameter type is not a reference".
7588 bool DeleteOnTypeMismatch = getLangOpts().CPlusPlus20 && First;
7589 bool ShouldDeleteForTypeMismatch = false;
7590 unsigned ExpectedParams = 1;
7593 ExpectedParams = 0;
7594 if (MD->getNumExplicitParams() != ExpectedParams) {
7595 // This checks for default arguments: a copy or move constructor with a
7596 // default argument is classified as a default constructor, and assignment
7597 // operations and destructors can't have default arguments.
7598 Diag(MD->getLocation(), diag::err_defaulted_special_member_params)
7599 << llvm::to_underlying(CSM) << MD->getSourceRange();
7600 HadError = true;
7601 } else if (MD->isVariadic()) {
7602 if (DeleteOnTypeMismatch)
7603 ShouldDeleteForTypeMismatch = true;
7604 else {
7605 Diag(MD->getLocation(), diag::err_defaulted_special_member_variadic)
7606 << llvm::to_underlying(CSM) << MD->getSourceRange();
7607 HadError = true;
7608 }
7609 }
7610
7612
7613 bool CanHaveConstParam = false;
7615 CanHaveConstParam = RD->implicitCopyConstructorHasConstParam();
7617 CanHaveConstParam = RD->implicitCopyAssignmentHasConstParam();
7618
7619 QualType ReturnType = Context.VoidTy;
7622 // Check for return type matching.
7623 ReturnType = Type->getReturnType();
7625
7626 QualType DeclType = Context.getTypeDeclType(RD);
7628 DeclType, nullptr);
7629 DeclType = Context.getAddrSpaceQualType(
7630 DeclType, ThisType.getQualifiers().getAddressSpace());
7631 QualType ExpectedReturnType = Context.getLValueReferenceType(DeclType);
7632
7633 if (!Context.hasSameType(ReturnType, ExpectedReturnType)) {
7634 Diag(MD->getLocation(), diag::err_defaulted_special_member_return_type)
7636 << ExpectedReturnType;
7637 HadError = true;
7638 }
7639
7640 // A defaulted special member cannot have cv-qualifiers.
7641 if (ThisType.isConstQualified() || ThisType.isVolatileQualified()) {
7642 if (DeleteOnTypeMismatch)
7643 ShouldDeleteForTypeMismatch = true;
7644 else {
7645 Diag(MD->getLocation(), diag::err_defaulted_special_member_quals)
7647 << getLangOpts().CPlusPlus14;
7648 HadError = true;
7649 }
7650 }
7651 // [C++23][dcl.fct.def.default]/p2.2
7652 // if F2 has an implicit object parameter of type “reference to C”,
7653 // F1 may be an explicit object member function whose explicit object
7654 // parameter is of (possibly different) type “reference to C”,
7655 // in which case the type of F1 would differ from the type of F2
7656 // in that the type of F1 has an additional parameter;
7657 QualType ExplicitObjectParameter = MD->isExplicitObjectMemberFunction()
7658 ? MD->getParamDecl(0)->getType()
7659 : QualType();
7660 if (!ExplicitObjectParameter.isNull() &&
7661 (!ExplicitObjectParameter->isReferenceType() ||
7662 !Context.hasSameType(ExplicitObjectParameter.getNonReferenceType(),
7663 Context.getRecordType(RD)))) {
7664 if (DeleteOnTypeMismatch)
7665 ShouldDeleteForTypeMismatch = true;
7666 else {
7667 Diag(MD->getLocation(),
7668 diag::err_defaulted_special_member_explicit_object_mismatch)
7669 << (CSM == CXXSpecialMemberKind::MoveAssignment) << RD
7670 << MD->getSourceRange();
7671 HadError = true;
7672 }
7673 }
7674 }
7675
7676 // Check for parameter type matching.
7677 QualType ArgType =
7678 ExpectedParams
7679 ? Type->getParamType(MD->isExplicitObjectMemberFunction() ? 1 : 0)
7680 : QualType();
7681 bool HasConstParam = false;
7682 if (ExpectedParams && ArgType->isReferenceType()) {
7683 // Argument must be reference to possibly-const T.
7684 QualType ReferentType = ArgType->getPointeeType();
7685 HasConstParam = ReferentType.isConstQualified();
7686
7687 if (ReferentType.isVolatileQualified()) {
7688 if (DeleteOnTypeMismatch)
7689 ShouldDeleteForTypeMismatch = true;
7690 else {
7691 Diag(MD->getLocation(),
7692 diag::err_defaulted_special_member_volatile_param)
7693 << llvm::to_underlying(CSM);
7694 HadError = true;
7695 }
7696 }
7697
7698 if (HasConstParam && !CanHaveConstParam) {
7699 if (DeleteOnTypeMismatch)
7700 ShouldDeleteForTypeMismatch = true;
7701 else if (CSM == CXXSpecialMemberKind::CopyConstructor ||
7703 Diag(MD->getLocation(),
7704 diag::err_defaulted_special_member_copy_const_param)
7706 // FIXME: Explain why this special member can't be const.
7707 HadError = true;
7708 } else {
7709 Diag(MD->getLocation(),
7710 diag::err_defaulted_special_member_move_const_param)
7712 HadError = true;
7713 }
7714 }
7715 } else if (ExpectedParams) {
7716 // A copy assignment operator can take its argument by value, but a
7717 // defaulted one cannot.
7719 "unexpected non-ref argument");
7720 Diag(MD->getLocation(), diag::err_defaulted_copy_assign_not_ref);
7721 HadError = true;
7722 }
7723
7724 // C++11 [dcl.fct.def.default]p2:
7725 // An explicitly-defaulted function may be declared constexpr only if it
7726 // would have been implicitly declared as constexpr,
7727 // Do not apply this rule to members of class templates, since core issue 1358
7728 // makes such functions always instantiate to constexpr functions. For
7729 // functions which cannot be constexpr (for non-constructors in C++11 and for
7730 // destructors in C++14 and C++17), this is checked elsewhere.
7731 //
7732 // FIXME: This should not apply if the member is deleted.
7733 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
7734 HasConstParam);
7735
7736 // C++14 [dcl.constexpr]p6 (CWG DR647/CWG DR1358):
7737 // If the instantiated template specialization of a constexpr function
7738 // template or member function of a class template would fail to satisfy
7739 // the requirements for a constexpr function or constexpr constructor, that
7740 // specialization is still a constexpr function or constexpr constructor,
7741 // even though a call to such a function cannot appear in a constant
7742 // expression.
7743 if (MD->isTemplateInstantiation() && MD->isConstexpr())
7744 Constexpr = true;
7745
7746 if ((getLangOpts().CPlusPlus20 ||
7747 (getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD)
7748 : isa<CXXConstructorDecl>(MD))) &&
7749 MD->isConstexpr() && !Constexpr &&
7751 if (!MD->isConsteval() && RD->getNumVBases()) {
7752 Diag(MD->getBeginLoc(),
7753 diag::err_incorrect_defaulted_constexpr_with_vb)
7754 << llvm::to_underlying(CSM);
7755 for (const auto &I : RD->vbases())
7756 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here);
7757 } else {
7758 Diag(MD->getBeginLoc(), diag::err_incorrect_defaulted_constexpr)
7759 << llvm::to_underlying(CSM) << MD->isConsteval();
7760 }
7761 HadError = true;
7762 // FIXME: Explain why the special member can't be constexpr.
7763 }
7764
7765 if (First) {
7766 // C++2a [dcl.fct.def.default]p3:
7767 // If a function is explicitly defaulted on its first declaration, it is
7768 // implicitly considered to be constexpr if the implicit declaration
7769 // would be.
7774
7775 if (!Type->hasExceptionSpec()) {
7776 // C++2a [except.spec]p3:
7777 // If a declaration of a function does not have a noexcept-specifier
7778 // [and] is defaulted on its first declaration, [...] the exception
7779 // specification is as specified below
7780 FunctionProtoType::ExtProtoInfo EPI = Type->getExtProtoInfo();
7782 EPI.ExceptionSpec.SourceDecl = MD;
7783 MD->setType(
7784 Context.getFunctionType(ReturnType, Type->getParamTypes(), EPI));
7785 }
7786 }
7787
7788 if (ShouldDeleteForTypeMismatch || ShouldDeleteSpecialMember(MD, CSM)) {
7789 if (First) {
7790 SetDeclDeleted(MD, MD->getLocation());
7791 if (!inTemplateInstantiation() && !HadError) {
7792 Diag(MD->getLocation(), diag::warn_defaulted_method_deleted)
7793 << llvm::to_underlying(CSM);
7794 if (ShouldDeleteForTypeMismatch) {
7795 Diag(MD->getLocation(), diag::note_deleted_type_mismatch)
7796 << llvm::to_underlying(CSM);
7797 } else if (ShouldDeleteSpecialMember(MD, CSM, nullptr,
7798 /*Diagnose*/ true) &&
7799 DefaultLoc.isValid()) {
7800 Diag(DefaultLoc, diag::note_replace_equals_default_to_delete)
7801 << FixItHint::CreateReplacement(DefaultLoc, "delete");
7802 }
7803 }
7804 if (ShouldDeleteForTypeMismatch && !HadError) {
7805 Diag(MD->getLocation(),
7806 diag::warn_cxx17_compat_defaulted_method_type_mismatch)
7807 << llvm::to_underlying(CSM);
7808 }
7809 } else {
7810 // C++11 [dcl.fct.def.default]p4:
7811 // [For a] user-provided explicitly-defaulted function [...] if such a
7812 // function is implicitly defined as deleted, the program is ill-formed.
7813 Diag(MD->getLocation(), diag::err_out_of_line_default_deletes)
7814 << llvm::to_underlying(CSM);
7815 assert(!ShouldDeleteForTypeMismatch && "deleted non-first decl");
7816 ShouldDeleteSpecialMember(MD, CSM, nullptr, /*Diagnose*/true);
7817 HadError = true;
7818 }
7819 }
7820
7821 return HadError;
7822}
7823
7824namespace {
7825/// Helper class for building and checking a defaulted comparison.
7826///
7827/// Defaulted functions are built in two phases:
7828///
7829/// * First, the set of operations that the function will perform are
7830/// identified, and some of them are checked. If any of the checked
7831/// operations is invalid in certain ways, the comparison function is
7832/// defined as deleted and no body is built.
7833/// * Then, if the function is not defined as deleted, the body is built.
7834///
7835/// This is accomplished by performing two visitation steps over the eventual
7836/// body of the function.
7837template<typename Derived, typename ResultList, typename Result,
7838 typename Subobject>
7839class DefaultedComparisonVisitor {
7840public:
7841 using DefaultedComparisonKind = Sema::DefaultedComparisonKind;
7842
7843 DefaultedComparisonVisitor(Sema &S, CXXRecordDecl *RD, FunctionDecl *FD,
7844 DefaultedComparisonKind DCK)
7845 : S(S), RD(RD), FD(FD), DCK(DCK) {
7846 if (auto *Info = FD->getDefalutedOrDeletedInfo()) {
7847 // FIXME: Change CreateOverloadedBinOp to take an ArrayRef instead of an
7848 // UnresolvedSet to avoid this copy.
7849 Fns.assign(Info->getUnqualifiedLookups().begin(),
7850 Info->getUnqualifiedLookups().end());
7851 }
7852 }
7853
7854 ResultList visit() {
7855 // The type of an lvalue naming a parameter of this function.
7856 QualType ParamLvalType =
7858
7859 ResultList Results;
7860
7861 switch (DCK) {
7862 case DefaultedComparisonKind::None:
7863 llvm_unreachable("not a defaulted comparison");
7864
7865 case DefaultedComparisonKind::Equal:
7866 case DefaultedComparisonKind::ThreeWay:
7867 getDerived().visitSubobjects(Results, RD, ParamLvalType.getQualifiers());
7868 return Results;
7869
7870 case DefaultedComparisonKind::NotEqual:
7871 case DefaultedComparisonKind::Relational:
7872 Results.add(getDerived().visitExpandedSubobject(
7873 ParamLvalType, getDerived().getCompleteObject()));
7874 return Results;
7875 }
7876 llvm_unreachable("");
7877 }
7878
7879protected:
7880 Derived &getDerived() { return static_cast<Derived&>(*this); }
7881
7882 /// Visit the expanded list of subobjects of the given type, as specified in
7883 /// C++2a [class.compare.default].
7884 ///
7885 /// \return \c true if the ResultList object said we're done, \c false if not.
7886 bool visitSubobjects(ResultList &Results, CXXRecordDecl *Record,
7887 Qualifiers Quals) {
7888 // C++2a [class.compare.default]p4:
7889 // The direct base class subobjects of C
7890 for (CXXBaseSpecifier &Base : Record->bases())
7891 if (Results.add(getDerived().visitSubobject(
7892 S.Context.getQualifiedType(Base.getType(), Quals),
7893 getDerived().getBase(&Base))))
7894 return true;
7895
7896 // followed by the non-static data members of C
7897 for (FieldDecl *Field : Record->fields()) {
7898 // C++23 [class.bit]p2:
7899 // Unnamed bit-fields are not members ...
7900 if (Field->isUnnamedBitField())
7901 continue;
7902 // Recursively expand anonymous structs.
7903 if (Field->isAnonymousStructOrUnion()) {
7904 if (visitSubobjects(Results, Field->getType()->getAsCXXRecordDecl(),
7905 Quals))
7906 return true;
7907 continue;
7908 }
7909
7910 // Figure out the type of an lvalue denoting this field.
7911 Qualifiers FieldQuals = Quals;
7912 if (Field->isMutable())
7913 FieldQuals.removeConst();
7914 QualType FieldType =
7915 S.Context.getQualifiedType(Field->getType(), FieldQuals);
7916
7917 if (Results.add(getDerived().visitSubobject(
7918 FieldType, getDerived().getField(Field))))
7919 return true;
7920 }
7921
7922 // form a list of subobjects.
7923 return false;
7924 }
7925
7926 Result visitSubobject(QualType Type, Subobject Subobj) {
7927 // In that list, any subobject of array type is recursively expanded
7928 const ArrayType *AT = S.Context.getAsArrayType(Type);
7929 if (auto *CAT = dyn_cast_or_null<ConstantArrayType>(AT))
7930 return getDerived().visitSubobjectArray(CAT->getElementType(),
7931 CAT->getSize(), Subobj);
7932 return getDerived().visitExpandedSubobject(Type, Subobj);
7933 }
7934
7935 Result visitSubobjectArray(QualType Type, const llvm::APInt &Size,
7936 Subobject Subobj) {
7937 return getDerived().visitSubobject(Type, Subobj);
7938 }
7939
7940protected:
7941 Sema &S;
7942 CXXRecordDecl *RD;
7943 FunctionDecl *FD;
7944 DefaultedComparisonKind DCK;
7946};
7947
7948/// Information about a defaulted comparison, as determined by
7949/// DefaultedComparisonAnalyzer.
7950struct DefaultedComparisonInfo {
7951 bool Deleted = false;
7952 bool Constexpr = true;
7953 ComparisonCategoryType Category = ComparisonCategoryType::StrongOrdering;
7954
7955 static DefaultedComparisonInfo deleted() {
7956 DefaultedComparisonInfo Deleted;
7957 Deleted.Deleted = true;
7958 return Deleted;
7959 }
7960
7961 bool add(const DefaultedComparisonInfo &R) {
7962 Deleted |= R.Deleted;
7963 Constexpr &= R.Constexpr;
7964 Category = commonComparisonType(Category, R.Category);
7965 return Deleted;
7966 }
7967};
7968
7969/// An element in the expanded list of subobjects of a defaulted comparison, as
7970/// specified in C++2a [class.compare.default]p4.
7971struct DefaultedComparisonSubobject {
7972 enum { CompleteObject, Member, Base } Kind;
7973 NamedDecl *Decl;
7975};
7976
7977/// A visitor over the notional body of a defaulted comparison that determines
7978/// whether that body would be deleted or constexpr.
7979class DefaultedComparisonAnalyzer
7980 : public DefaultedComparisonVisitor<DefaultedComparisonAnalyzer,
7981 DefaultedComparisonInfo,
7982 DefaultedComparisonInfo,
7983 DefaultedComparisonSubobject> {
7984public:
7985 enum DiagnosticKind { NoDiagnostics, ExplainDeleted, ExplainConstexpr };
7986
7987private:
7988 DiagnosticKind Diagnose;
7989
7990public:
7991 using Base = DefaultedComparisonVisitor;
7992 using Result = DefaultedComparisonInfo;
7993 using Subobject = DefaultedComparisonSubobject;
7994
7995 friend Base;
7996
7997 DefaultedComparisonAnalyzer(Sema &S, CXXRecordDecl *RD, FunctionDecl *FD,
7998 DefaultedComparisonKind DCK,
7999 DiagnosticKind Diagnose = NoDiagnostics)
8000 : Base(S, RD, FD, DCK), Diagnose(Diagnose) {}
8001
8002 Result visit() {
8003 if ((DCK == DefaultedComparisonKind::Equal ||
8004 DCK == DefaultedComparisonKind::ThreeWay) &&
8005 RD->hasVariantMembers()) {
8006 // C++2a [class.compare.default]p2 [P2002R0]:
8007 // A defaulted comparison operator function for class C is defined as
8008 // deleted if [...] C has variant members.
8009 if (Diagnose == ExplainDeleted) {
8010 S.Diag(FD->getLocation(), diag::note_defaulted_comparison_union)
8011 << FD << RD->isUnion() << RD;
8012 }
8013 return Result::deleted();
8014 }
8015
8016 return Base::visit();
8017 }
8018
8019private:
8020 Subobject getCompleteObject() {
8021 return Subobject{Subobject::CompleteObject, RD, FD->getLocation()};
8022 }
8023
8024 Subobject getBase(CXXBaseSpecifier *Base) {
8025 return Subobject{Subobject::Base, Base->getType()->getAsCXXRecordDecl(),
8026 Base->getBaseTypeLoc()};
8027 }
8028
8029 Subobject getField(FieldDecl *Field) {
8030 return Subobject{Subobject::Member, Field, Field->getLocation()};
8031 }
8032
8033 Result visitExpandedSubobject(QualType Type, Subobject Subobj) {
8034 // C++2a [class.compare.default]p2 [P2002R0]:
8035 // A defaulted <=> or == operator function for class C is defined as
8036 // deleted if any non-static data member of C is of reference type
8037 if (Type->isReferenceType()) {
8038 if (Diagnose == ExplainDeleted) {
8039 S.Diag(Subobj.Loc, diag::note_defaulted_comparison_reference_member)
8040 << FD << RD;
8041 }
8042 return Result::deleted();
8043 }
8044
8045 // [...] Let xi be an lvalue denoting the ith element [...]
8047 Expr *Args[] = {&Xi, &Xi};
8048
8049 // All operators start by trying to apply that same operator recursively.
8051 assert(OO != OO_None && "not an overloaded operator!");
8052 return visitBinaryOperator(OO, Args, Subobj);
8053 }
8054
8055 Result
8056 visitBinaryOperator(OverloadedOperatorKind OO, ArrayRef<Expr *> Args,
8057 Subobject Subobj,
8058 OverloadCandidateSet *SpaceshipCandidates = nullptr) {
8059 // Note that there is no need to consider rewritten candidates here if
8060 // we've already found there is no viable 'operator<=>' candidate (and are
8061 // considering synthesizing a '<=>' from '==' and '<').
8062 OverloadCandidateSet CandidateSet(
8065 OO, FD->getLocation(),
8066 /*AllowRewrittenCandidates=*/!SpaceshipCandidates));
8067
8068 /// C++2a [class.compare.default]p1 [P2002R0]:
8069 /// [...] the defaulted function itself is never a candidate for overload
8070 /// resolution [...]
8071 CandidateSet.exclude(FD);
8072
8073 if (Args[0]->getType()->isOverloadableType())
8074 S.LookupOverloadedBinOp(CandidateSet, OO, Fns, Args);
8075 else
8076 // FIXME: We determine whether this is a valid expression by checking to
8077 // see if there's a viable builtin operator candidate for it. That isn't
8078 // really what the rules ask us to do, but should give the right results.
8079 S.AddBuiltinOperatorCandidates(OO, FD->getLocation(), Args, CandidateSet);
8080
8081 Result R;
8082
8084 switch (CandidateSet.BestViableFunction(S, FD->getLocation(), Best)) {
8085 case OR_Success: {
8086 // C++2a [class.compare.secondary]p2 [P2002R0]:
8087 // The operator function [...] is defined as deleted if [...] the
8088 // candidate selected by overload resolution is not a rewritten
8089 // candidate.
8090 if ((DCK == DefaultedComparisonKind::NotEqual ||
8091 DCK == DefaultedComparisonKind::Relational) &&
8092 !Best->RewriteKind) {
8093 if (Diagnose == ExplainDeleted) {
8094 if (Best->Function) {
8095 S.Diag(Best->Function->getLocation(),
8096 diag::note_defaulted_comparison_not_rewritten_callee)
8097 << FD;
8098 } else {
8099 assert(Best->Conversions.size() == 2 &&
8100 Best->Conversions[0].isUserDefined() &&
8101 "non-user-defined conversion from class to built-in "
8102 "comparison");
8103 S.Diag(Best->Conversions[0]
8104 .UserDefined.FoundConversionFunction.getDecl()
8105 ->getLocation(),
8106 diag::note_defaulted_comparison_not_rewritten_conversion)
8107 << FD;
8108 }
8109 }
8110 return Result::deleted();
8111 }
8112
8113 // Throughout C++2a [class.compare]: if overload resolution does not
8114 // result in a usable function, the candidate function is defined as
8115 // deleted. This requires that we selected an accessible function.
8116 //
8117 // Note that this only considers the access of the function when named
8118 // within the type of the subobject, and not the access path for any
8119 // derived-to-base conversion.
8120 CXXRecordDecl *ArgClass = Args[0]->getType()->getAsCXXRecordDecl();
8121 if (ArgClass && Best->FoundDecl.getDecl() &&
8122 Best->FoundDecl.getDecl()->isCXXClassMember()) {
8123 QualType ObjectType = Subobj.Kind == Subobject::Member
8124 ? Args[0]->getType()
8125 : S.Context.getRecordType(RD);
8127 ArgClass, Best->FoundDecl, ObjectType, Subobj.Loc,
8128 Diagnose == ExplainDeleted
8129 ? S.PDiag(diag::note_defaulted_comparison_inaccessible)
8130 << FD << Subobj.Kind << Subobj.Decl
8131 : S.PDiag()))
8132 return Result::deleted();
8133 }
8134
8135 bool NeedsDeducing =
8136 OO == OO_Spaceship && FD->getReturnType()->isUndeducedAutoType();
8137
8138 if (FunctionDecl *BestFD = Best->Function) {
8139 // C++2a [class.compare.default]p3 [P2002R0]:
8140 // A defaulted comparison function is constexpr-compatible if
8141 // [...] no overlod resolution performed [...] results in a
8142 // non-constexpr function.
8143 assert(!BestFD->isDeleted() && "wrong overload resolution result");
8144 // If it's not constexpr, explain why not.
8145 if (Diagnose == ExplainConstexpr && !BestFD->isConstexpr()) {
8146 if (Subobj.Kind != Subobject::CompleteObject)
8147 S.Diag(Subobj.Loc, diag::note_defaulted_comparison_not_constexpr)
8148 << Subobj.Kind << Subobj.Decl;
8149 S.Diag(BestFD->getLocation(),
8150 diag::note_defaulted_comparison_not_constexpr_here);
8151 // Bail out after explaining; we don't want any more notes.
8152 return Result::deleted();
8153 }
8154 R.Constexpr &= BestFD->isConstexpr();
8155
8156 if (NeedsDeducing) {
8157 // If any callee has an undeduced return type, deduce it now.
8158 // FIXME: It's not clear how a failure here should be handled. For
8159 // now, we produce an eager diagnostic, because that is forward
8160 // compatible with most (all?) other reasonable options.
8161 if (BestFD->getReturnType()->isUndeducedType() &&
8162 S.DeduceReturnType(BestFD, FD->getLocation(),
8163 /*Diagnose=*/false)) {
8164 // Don't produce a duplicate error when asked to explain why the
8165 // comparison is deleted: we diagnosed that when initially checking
8166 // the defaulted operator.
8167 if (Diagnose == NoDiagnostics) {
8168 S.Diag(
8169 FD->getLocation(),
8170 diag::err_defaulted_comparison_cannot_deduce_undeduced_auto)
8171 << Subobj.Kind << Subobj.Decl;
8172 S.Diag(
8173 Subobj.Loc,
8174 diag::note_defaulted_comparison_cannot_deduce_undeduced_auto)
8175 << Subobj.Kind << Subobj.Decl;
8176 S.Diag(BestFD->getLocation(),
8177 diag::note_defaulted_comparison_cannot_deduce_callee)
8178 << Subobj.Kind << Subobj.Decl;
8179 }
8180 return Result::deleted();
8181 }
8183 BestFD->getCallResultType());
8184 if (!Info) {
8185 if (Diagnose == ExplainDeleted) {
8186 S.Diag(Subobj.Loc, diag::note_defaulted_comparison_cannot_deduce)
8187 << Subobj.Kind << Subobj.Decl
8188 << BestFD->getCallResultType().withoutLocalFastQualifiers();
8189 S.Diag(BestFD->getLocation(),
8190 diag::note_defaulted_comparison_cannot_deduce_callee)
8191 << Subobj.Kind << Subobj.Decl;
8192 }
8193 return Result::deleted();
8194 }
8195 R.Category = Info->Kind;
8196 }
8197 } else {
8198 QualType T = Best->BuiltinParamTypes[0];
8199 assert(T == Best->BuiltinParamTypes[1] &&
8200 "builtin comparison for different types?");
8201 assert(Best->BuiltinParamTypes[2].isNull() &&
8202 "invalid builtin comparison");
8203
8204 if (NeedsDeducing) {
8205 std::optional<ComparisonCategoryType> Cat =
8207 assert(Cat && "no category for builtin comparison?");
8208 R.Category = *Cat;
8209 }
8210 }
8211
8212 // Note that we might be rewriting to a different operator. That call is
8213 // not considered until we come to actually build the comparison function.
8214 break;
8215 }
8216
8217 case OR_Ambiguous:
8218 if (Diagnose == ExplainDeleted) {
8219 unsigned Kind = 0;
8220 if (FD->getOverloadedOperator() == OO_Spaceship && OO != OO_Spaceship)
8221 Kind = OO == OO_EqualEqual ? 1 : 2;
8222 CandidateSet.NoteCandidates(
8224 Subobj.Loc, S.PDiag(diag::note_defaulted_comparison_ambiguous)
8225 << FD << Kind << Subobj.Kind << Subobj.Decl),
8226 S, OCD_AmbiguousCandidates, Args);
8227 }
8228 R = Result::deleted();
8229 break;
8230
8231 case OR_Deleted:
8232 if (Diagnose == ExplainDeleted) {
8233 if ((DCK == DefaultedComparisonKind::NotEqual ||
8234 DCK == DefaultedComparisonKind::Relational) &&
8235 !Best->RewriteKind) {
8236 S.Diag(Best->Function->getLocation(),
8237 diag::note_defaulted_comparison_not_rewritten_callee)
8238 << FD;
8239 } else {
8240 S.Diag(Subobj.Loc,
8241 diag::note_defaulted_comparison_calls_deleted)
8242 << FD << Subobj.Kind << Subobj.Decl;
8243 S.NoteDeletedFunction(Best->Function);
8244 }
8245 }
8246 R = Result::deleted();
8247 break;
8248
8250 // If there's no usable candidate, we're done unless we can rewrite a
8251 // '<=>' in terms of '==' and '<'.
8252 if (OO == OO_Spaceship &&
8254 // For any kind of comparison category return type, we need a usable
8255 // '==' and a usable '<'.
8256 if (!R.add(visitBinaryOperator(OO_EqualEqual, Args, Subobj,
8257 &CandidateSet)))
8258 R.add(visitBinaryOperator(OO_Less, Args, Subobj, &CandidateSet));
8259 break;
8260 }
8261
8262 if (Diagnose == ExplainDeleted) {
8263 S.Diag(Subobj.Loc, diag::note_defaulted_comparison_no_viable_function)
8264 << FD << (OO == OO_EqualEqual || OO == OO_ExclaimEqual)
8265 << Subobj.Kind << Subobj.Decl;
8266
8267 // For a three-way comparison, list both the candidates for the
8268 // original operator and the candidates for the synthesized operator.
8269 if (SpaceshipCandidates) {
8270 SpaceshipCandidates->NoteCandidates(
8271 S, Args,
8272 SpaceshipCandidates->CompleteCandidates(S, OCD_AllCandidates,
8273 Args, FD->getLocation()));
8274 S.Diag(Subobj.Loc,
8275 diag::note_defaulted_comparison_no_viable_function_synthesized)
8276 << (OO == OO_EqualEqual ? 0 : 1);
8277 }
8278
8279 CandidateSet.NoteCandidates(
8280 S, Args,
8281 CandidateSet.CompleteCandidates(S, OCD_AllCandidates, Args,
8282 FD->getLocation()));
8283 }
8284 R = Result::deleted();
8285 break;
8286 }
8287
8288 return R;
8289 }
8290};
8291
8292/// A list of statements.
8293struct StmtListResult {
8294 bool IsInvalid = false;
8296
8297 bool add(const StmtResult &S) {
8298 IsInvalid |= S.isInvalid();
8299 if (IsInvalid)
8300 return true;
8301 Stmts.push_back(S.get());
8302 return false;
8303 }
8304};
8305
8306/// A visitor over the notional body of a defaulted comparison that synthesizes
8307/// the actual body.
8308class DefaultedComparisonSynthesizer
8309 : public DefaultedComparisonVisitor<DefaultedComparisonSynthesizer,
8310 StmtListResult, StmtResult,
8311 std::pair<ExprResult, ExprResult>> {
8313 unsigned ArrayDepth = 0;
8314
8315public:
8316 using Base = DefaultedComparisonVisitor;
8317 using ExprPair = std::pair<ExprResult, ExprResult>;
8318
8319 friend Base;
8320
8321 DefaultedComparisonSynthesizer(Sema &S, CXXRecordDecl *RD, FunctionDecl *FD,
8322 DefaultedComparisonKind DCK,
8323 SourceLocation BodyLoc)
8324 : Base(S, RD, FD, DCK), Loc(BodyLoc) {}
8325
8326 /// Build a suitable function body for this defaulted comparison operator.
8327 StmtResult build() {
8328 Sema::CompoundScopeRAII CompoundScope(S);
8329
8330 StmtListResult Stmts = visit();
8331 if (Stmts.IsInvalid)
8332 return StmtError();
8333
8334 ExprResult RetVal;
8335 switch (DCK) {
8336 case DefaultedComparisonKind::None:
8337 llvm_unreachable("not a defaulted comparison");
8338
8339 case DefaultedComparisonKind::Equal: {
8340 // C++2a [class.eq]p3:
8341 // [...] compar[e] the corresponding elements [...] until the first
8342 // index i where xi == yi yields [...] false. If no such index exists,
8343 // V is true. Otherwise, V is false.
8344 //
8345 // Join the comparisons with '&&'s and return the result. Use a right
8346 // fold (traversing the conditions right-to-left), because that
8347 // short-circuits more naturally.
8348 auto OldStmts = std::move(Stmts.Stmts);
8349 Stmts.Stmts.clear();
8350 ExprResult CmpSoFar;
8351 // Finish a particular comparison chain.
8352 auto FinishCmp = [&] {
8353 if (Expr *Prior = CmpSoFar.get()) {
8354 // Convert the last expression to 'return ...;'
8355 if (RetVal.isUnset() && Stmts.Stmts.empty())
8356 RetVal = CmpSoFar;
8357 // Convert any prior comparison to 'if (!(...)) return false;'
8358 else if (Stmts.add(buildIfNotCondReturnFalse(Prior)))
8359 return true;
8360 CmpSoFar = ExprResult();
8361 }
8362 return false;
8363 };
8364 for (Stmt *EAsStmt : llvm::reverse(OldStmts)) {
8365 Expr *E = dyn_cast<Expr>(EAsStmt);
8366 if (!E) {
8367 // Found an array comparison.
8368 if (FinishCmp() || Stmts.add(EAsStmt))
8369 return StmtError();
8370 continue;
8371 }
8372
8373 if (CmpSoFar.isUnset()) {
8374 CmpSoFar = E;
8375 continue;
8376 }
8377 CmpSoFar = S.CreateBuiltinBinOp(Loc, BO_LAnd, E, CmpSoFar.get());
8378 if (CmpSoFar.isInvalid())
8379 return StmtError();
8380 }
8381 if (FinishCmp())
8382 return StmtError();
8383 std::reverse(Stmts.Stmts.begin(), Stmts.Stmts.end());
8384 // If no such index exists, V is true.
8385 if (RetVal.isUnset())
8386 RetVal = S.ActOnCXXBoolLiteral(Loc, tok::kw_true);
8387 break;
8388 }
8389
8390 case DefaultedComparisonKind::ThreeWay: {
8391 // Per C++2a [class.spaceship]p3, as a fallback add:
8392 // return static_cast<R>(std::strong_ordering::equal);
8394 ComparisonCategoryType::StrongOrdering, Loc,
8395 Sema::ComparisonCategoryUsage::DefaultedOperator);
8396 if (StrongOrdering.isNull())
8397 return StmtError();
8399 .getValueInfo(ComparisonCategoryResult::Equal)
8400 ->VD;
8401 RetVal = getDecl(EqualVD);
8402 if (RetVal.isInvalid())
8403 return StmtError();
8404 RetVal = buildStaticCastToR(RetVal.get());
8405 break;
8406 }
8407
8408 case DefaultedComparisonKind::NotEqual:
8409 case DefaultedComparisonKind::Relational:
8410 RetVal = cast<Expr>(Stmts.Stmts.pop_back_val());
8411 break;
8412 }
8413
8414 // Build the final return statement.
8415 if (RetVal.isInvalid())
8416 return StmtError();
8418 if (ReturnStmt.isInvalid())
8419 return StmtError();
8420 Stmts.Stmts.push_back(ReturnStmt.get());
8421
8422 return S.ActOnCompoundStmt(Loc, Loc, Stmts.Stmts, /*IsStmtExpr=*/false);
8423 }
8424
8425private:
8426 ExprResult getDecl(ValueDecl *VD) {
8427 return S.BuildDeclarationNameExpr(
8429 }
8430
8431 ExprResult getParam(unsigned I) {
8432 ParmVarDecl *PD = FD->getParamDecl(I);
8433 return getDecl(PD);
8434 }
8435
8436 ExprPair getCompleteObject() {
8437 unsigned Param = 0;
8438 ExprResult LHS;
8439 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD);
8440 MD && MD->isImplicitObjectMemberFunction()) {
8441 // LHS is '*this'.
8442 LHS = S.ActOnCXXThis(Loc);
8443 if (!LHS.isInvalid())
8444 LHS = S.CreateBuiltinUnaryOp(Loc, UO_Deref, LHS.get());
8445 } else {
8446 LHS = getParam(Param++);
8447 }
8448 ExprResult RHS = getParam(Param++);
8449 assert(Param == FD->getNumParams());
8450 return {LHS, RHS};
8451 }
8452
8453 ExprPair getBase(CXXBaseSpecifier *Base) {
8454 ExprPair Obj = getCompleteObject();
8455 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8456 return {ExprError(), ExprError()};
8457 CXXCastPath Path = {Base};
8458 const auto CastToBase = [&](Expr *E) {
8460 Base->getType(), E->getType().getQualifiers());
8461 return S.ImpCastExprToType(E, ToType, CK_DerivedToBase, VK_LValue, &Path);
8462 };
8463 return {CastToBase(Obj.first.get()), CastToBase(Obj.second.get())};
8464 }
8465
8466 ExprPair getField(FieldDecl *Field) {
8467 ExprPair Obj = getCompleteObject();
8468 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8469 return {ExprError(), ExprError()};
8470
8471 DeclAccessPair Found = DeclAccessPair::make(Field, Field->getAccess());
8472 DeclarationNameInfo NameInfo(Field->getDeclName(), Loc);
8473 return {S.BuildFieldReferenceExpr(Obj.first.get(), /*IsArrow=*/false, Loc,
8474 CXXScopeSpec(), Field, Found, NameInfo),
8475 S.BuildFieldReferenceExpr(Obj.second.get(), /*IsArrow=*/false, Loc,
8476 CXXScopeSpec(), Field, Found, NameInfo)};
8477 }
8478
8479 // FIXME: When expanding a subobject, register a note in the code synthesis
8480 // stack to say which subobject we're comparing.
8481
8482 StmtResult buildIfNotCondReturnFalse(ExprResult Cond) {
8483 if (Cond.isInvalid())
8484 return StmtError();
8485
8486 ExprResult NotCond = S.CreateBuiltinUnaryOp(Loc, UO_LNot, Cond.get());
8487 if (NotCond.isInvalid())
8488 return StmtError();
8489
8490 ExprResult False = S.ActOnCXXBoolLiteral(Loc, tok::kw_false);
8491 assert(!False.isInvalid() && "should never fail");
8492 StmtResult ReturnFalse = S.BuildReturnStmt(Loc, False.get());
8493 if (ReturnFalse.isInvalid())
8494 return StmtError();
8495
8496 return S.ActOnIfStmt(Loc, IfStatementKind::Ordinary, Loc, nullptr,
8497 S.ActOnCondition(nullptr, Loc, NotCond.get(),
8498 Sema::ConditionKind::Boolean),
8499 Loc, ReturnFalse.get(), SourceLocation(), nullptr);
8500 }
8501
8502 StmtResult visitSubobjectArray(QualType Type, llvm::APInt Size,
8503 ExprPair Subobj) {
8504 QualType SizeType = S.Context.getSizeType();
8505 Size = Size.zextOrTrunc(S.Context.getTypeSize(SizeType));
8506
8507 // Build 'size_t i$n = 0'.
8508 IdentifierInfo *IterationVarName = nullptr;
8509 {
8510 SmallString<8> Str;
8511 llvm::raw_svector_ostream OS(Str);
8512 OS << "i" << ArrayDepth;
8513 IterationVarName = &S.Context.Idents.get(OS.str());
8514 }
8515 VarDecl *IterationVar = VarDecl::Create(
8516 S.Context, S.CurContext, Loc, Loc, IterationVarName, SizeType,
8518 llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
8519 IterationVar->setInit(
8520 IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
8521 Stmt *Init = new (S.Context) DeclStmt(DeclGroupRef(IterationVar), Loc, Loc);
8522
8523 auto IterRef = [&] {
8525 CXXScopeSpec(), DeclarationNameInfo(IterationVarName, Loc),
8526 IterationVar);
8527 assert(!Ref.isInvalid() && "can't reference our own variable?");
8528 return Ref.get();
8529 };
8530
8531 // Build 'i$n != Size'.
8533 Loc, BO_NE, IterRef(),
8534 IntegerLiteral::Create(S.Context, Size, SizeType, Loc));
8535 assert(!Cond.isInvalid() && "should never fail");
8536
8537 // Build '++i$n'.
8538 ExprResult Inc = S.CreateBuiltinUnaryOp(Loc, UO_PreInc, IterRef());
8539 assert(!Inc.isInvalid() && "should never fail");
8540
8541 // Build 'a[i$n]' and 'b[i$n]'.
8542 auto Index = [&](ExprResult E) {
8543 if (E.isInvalid())
8544 return ExprError();
8545 return S.CreateBuiltinArraySubscriptExpr(E.get(), Loc, IterRef(), Loc);
8546 };
8547 Subobj.first = Index(Subobj.first);
8548 Subobj.second = Index(Subobj.second);
8549
8550 // Compare the array elements.
8551 ++ArrayDepth;
8552 StmtResult Substmt = visitSubobject(Type, Subobj);
8553 --ArrayDepth;
8554
8555 if (Substmt.isInvalid())
8556 return StmtError();
8557
8558 // For the inner level of an 'operator==', build 'if (!cmp) return false;'.
8559 // For outer levels or for an 'operator<=>' we already have a suitable
8560 // statement that returns as necessary.
8561 if (Expr *ElemCmp = dyn_cast<Expr>(Substmt.get())) {
8562 assert(DCK == DefaultedComparisonKind::Equal &&
8563 "should have non-expression statement");
8564 Substmt = buildIfNotCondReturnFalse(ElemCmp);
8565 if (Substmt.isInvalid())
8566 return StmtError();
8567 }
8568
8569 // Build 'for (...) ...'
8570 return S.ActOnForStmt(Loc, Loc, Init,
8571 S.ActOnCondition(nullptr, Loc, Cond.get(),
8572 Sema::ConditionKind::Boolean),
8574 Substmt.get());
8575 }
8576
8577 StmtResult visitExpandedSubobject(QualType Type, ExprPair Obj) {
8578 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8579 return StmtError();
8580
8583 ExprResult Op;
8584 if (Type->isOverloadableType())
8585 Op = S.CreateOverloadedBinOp(Loc, Opc, Fns, Obj.first.get(),
8586 Obj.second.get(), /*PerformADL=*/true,
8587 /*AllowRewrittenCandidates=*/true, FD);
8588 else
8589 Op = S.CreateBuiltinBinOp(Loc, Opc, Obj.first.get(), Obj.second.get());
8590 if (Op.isInvalid())
8591 return StmtError();
8592
8593 switch (DCK) {
8594 case DefaultedComparisonKind::None:
8595 llvm_unreachable("not a defaulted comparison");
8596
8597 case DefaultedComparisonKind::Equal:
8598 // Per C++2a [class.eq]p2, each comparison is individually contextually
8599 // converted to bool.
8601 if (Op.isInvalid())
8602 return StmtError();
8603 return Op.get();
8604
8605 case DefaultedComparisonKind::ThreeWay: {
8606 // Per C++2a [class.spaceship]p3, form:
8607 // if (R cmp = static_cast<R>(op); cmp != 0)
8608 // return cmp;
8609 QualType R = FD->getReturnType();
8610 Op = buildStaticCastToR(Op.get());
8611 if (Op.isInvalid())
8612 return StmtError();
8613
8614 // R cmp = ...;
8615 IdentifierInfo *Name = &S.Context.Idents.get("cmp");
8616 VarDecl *VD =
8617 VarDecl::Create(S.Context, S.CurContext, Loc, Loc, Name, R,
8619 S.AddInitializerToDecl(VD, Op.get(), /*DirectInit=*/false);
8620 Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(VD), Loc, Loc);
8621
8622 // cmp != 0
8623 ExprResult VDRef = getDecl(VD);
8624 if (VDRef.isInvalid())
8625 return StmtError();
8626 llvm::APInt ZeroVal(S.Context.getIntWidth(S.Context.IntTy), 0);
8627 Expr *Zero =
8630 if (VDRef.get()->getType()->isOverloadableType())
8631 Comp = S.CreateOverloadedBinOp(Loc, BO_NE, Fns, VDRef.get(), Zero, true,
8632 true, FD);
8633 else
8634 Comp = S.CreateBuiltinBinOp(Loc, BO_NE, VDRef.get(), Zero);
8635 if (Comp.isInvalid())
8636 return StmtError();
8638 nullptr, Loc, Comp.get(), Sema::ConditionKind::Boolean);
8639 if (Cond.isInvalid())
8640 return StmtError();
8641
8642 // return cmp;
8643 VDRef = getDecl(VD);
8644 if (VDRef.isInvalid())
8645 return StmtError();
8647 if (ReturnStmt.isInvalid())
8648 return StmtError();
8649
8650 // if (...)
8651 return S.ActOnIfStmt(Loc, IfStatementKind::Ordinary, Loc, InitStmt, Cond,
8652 Loc, ReturnStmt.get(),
8653 /*ElseLoc=*/SourceLocation(), /*Else=*/nullptr);
8654 }
8655
8656 case DefaultedComparisonKind::NotEqual:
8657 case DefaultedComparisonKind::Relational:
8658 // C++2a [class.compare.secondary]p2:
8659 // Otherwise, the operator function yields x @ y.
8660 return Op.get();
8661 }
8662 llvm_unreachable("");
8663 }
8664
8665 /// Build "static_cast<R>(E)".
8666 ExprResult buildStaticCastToR(Expr *E) {
8667 QualType R = FD->getReturnType();
8668 assert(!R->isUndeducedType() && "type should have been deduced already");
8669
8670 // Don't bother forming a no-op cast in the common case.
8671 if (E->isPRValue() && S.Context.hasSameType(E->getType(), R))
8672 return E;
8673 return S.BuildCXXNamedCast(Loc, tok::kw_static_cast,
8676 }
8677};
8678}
8679
8680/// Perform the unqualified lookups that might be needed to form a defaulted
8681/// comparison function for the given operator.
8683 UnresolvedSetImpl &Operators,
8685 auto Lookup = [&](OverloadedOperatorKind OO) {
8686 Self.LookupOverloadedOperatorName(OO, S, Operators);
8687 };
8688
8689 // Every defaulted operator looks up itself.
8690 Lookup(Op);
8691 // ... and the rewritten form of itself, if any.
8693 Lookup(ExtraOp);
8694
8695 // For 'operator<=>', we also form a 'cmp != 0' expression, and might
8696 // synthesize a three-way comparison from '<' and '=='. In a dependent
8697 // context, we also need to look up '==' in case we implicitly declare a
8698 // defaulted 'operator=='.
8699 if (Op == OO_Spaceship) {
8700 Lookup(OO_ExclaimEqual);
8701 Lookup(OO_Less);
8702 Lookup(OO_EqualEqual);
8703 }
8704}
8705
8708 assert(DCK != DefaultedComparisonKind::None && "not a defaulted comparison");
8709
8710 // Perform any unqualified lookups we're going to need to default this
8711 // function.
8712 if (S) {
8713 UnresolvedSet<32> Operators;
8714 lookupOperatorsForDefaultedComparison(*this, S, Operators,
8715 FD->getOverloadedOperator());
8718 Context, Operators.pairs()));
8719 }
8720
8721 // C++2a [class.compare.default]p1:
8722 // A defaulted comparison operator function for some class C shall be a
8723 // non-template function declared in the member-specification of C that is
8724 // -- a non-static const non-volatile member of C having one parameter of
8725 // type const C& and either no ref-qualifier or the ref-qualifier &, or
8726 // -- a friend of C having two parameters of type const C& or two
8727 // parameters of type C.
8728
8729 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalDeclContext());
8730 bool IsMethod = isa<CXXMethodDecl>(FD);
8731 if (IsMethod) {
8732 auto *MD = cast<CXXMethodDecl>(FD);
8733 assert(!MD->isStatic() && "comparison function cannot be a static member");
8734
8735 if (MD->getRefQualifier() == RQ_RValue) {
8736 Diag(MD->getLocation(), diag::err_ref_qualifier_comparison_operator);
8737
8738 // Remove the ref qualifier to recover.
8739 const auto *FPT = MD->getType()->castAs<FunctionProtoType>();
8740 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8741 EPI.RefQualifier = RQ_None;
8742 MD->setType(Context.getFunctionType(FPT->getReturnType(),
8743 FPT->getParamTypes(), EPI));
8744 }
8745
8746 // If we're out-of-class, this is the class we're comparing.
8747 if (!RD)
8748 RD = MD->getParent();
8750 if (!T.getNonReferenceType().isConstQualified() &&
8752 SourceLocation Loc, InsertLoc;
8754 Loc = MD->getParamDecl(0)->getBeginLoc();
8755 InsertLoc = getLocForEndOfToken(
8757 } else {
8758 Loc = MD->getLocation();
8760 InsertLoc = Loc.getRParenLoc();
8761 }
8762 // Don't diagnose an implicit 'operator=='; we will have diagnosed the
8763 // corresponding defaulted 'operator<=>' already.
8764 if (!MD->isImplicit()) {
8765 Diag(Loc, diag::err_defaulted_comparison_non_const)
8766 << (int)DCK << FixItHint::CreateInsertion(InsertLoc, " const");
8767 }
8768
8769 // Add the 'const' to the type to recover.
8771 assert(T->isLValueReferenceType());
8773 T.getNonReferenceType().withConst()));
8774 } else {
8775 const auto *FPT = MD->getType()->castAs<FunctionProtoType>();
8776 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8777 EPI.TypeQuals.addConst();
8778 MD->setType(Context.getFunctionType(FPT->getReturnType(),
8779 FPT->getParamTypes(), EPI));
8780 }
8781 }
8782
8783 if (MD->isVolatile()) {
8784 Diag(MD->getLocation(), diag::err_volatile_comparison_operator);
8785
8786 // Remove the 'volatile' from the type to recover.
8787 const auto *FPT = MD->getType()->castAs<FunctionProtoType>();
8788 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8790 MD->setType(Context.getFunctionType(FPT->getReturnType(),
8791 FPT->getParamTypes(), EPI));
8792 }
8793 }
8794
8795 if ((FD->getNumParams() -
8796 (unsigned)FD->hasCXXExplicitFunctionObjectParameter()) !=
8797 (IsMethod ? 1 : 2)) {
8798 // Let's not worry about using a variadic template pack here -- who would do
8799 // such a thing?
8800 Diag(FD->getLocation(), diag::err_defaulted_comparison_num_args)
8801 << int(IsMethod) << int(DCK);
8802 return true;
8803 }
8804
8805 const ParmVarDecl *KnownParm = nullptr;
8806 for (const ParmVarDecl *Param : FD->parameters()) {
8807 QualType ParmTy = Param->getType();
8808 if (!KnownParm) {
8809 auto CTy = ParmTy;
8810 // Is it `T const &`?
8811 bool Ok = !IsMethod || FD->hasCXXExplicitFunctionObjectParameter();
8812 QualType ExpectedTy;
8813 if (RD)
8814 ExpectedTy = Context.getRecordType(RD);
8815 if (auto *Ref = CTy->getAs<LValueReferenceType>()) {
8816 CTy = Ref->getPointeeType();
8817 if (RD)
8818 ExpectedTy.addConst();
8819 Ok = true;
8820 }
8821
8822 // Is T a class?
8823 if (RD) {
8824 Ok &= RD->isDependentType() || Context.hasSameType(CTy, ExpectedTy);
8825 } else {
8826 RD = CTy->getAsCXXRecordDecl();
8827 Ok &= RD != nullptr;
8828 }
8829
8830 if (Ok) {
8831 KnownParm = Param;
8832 } else {
8833 // Don't diagnose an implicit 'operator=='; we will have diagnosed the
8834 // corresponding defaulted 'operator<=>' already.
8835 if (!FD->isImplicit()) {
8836 if (RD) {
8837 QualType PlainTy = Context.getRecordType(RD);
8838 QualType RefTy =
8840 Diag(FD->getLocation(), diag::err_defaulted_comparison_param)
8841 << int(DCK) << ParmTy << RefTy << int(!IsMethod) << PlainTy
8842 << Param->getSourceRange();
8843 } else {
8844 assert(!IsMethod && "should know expected type for method");
8845 Diag(FD->getLocation(),
8846 diag::err_defaulted_comparison_param_unknown)
8847 << int(DCK) << ParmTy << Param->getSourceRange();
8848 }
8849 }
8850 return true;
8851 }
8852 } else if (!Context.hasSameType(KnownParm->getType(), ParmTy)) {
8853 Diag(FD->getLocation(), diag::err_defaulted_comparison_param_mismatch)
8854 << int(DCK) << KnownParm->getType() << KnownParm->getSourceRange()
8855 << ParmTy << Param->getSourceRange();
8856 return true;
8857 }
8858 }
8859
8860 assert(RD && "must have determined class");
8861 if (IsMethod) {
8862 } else if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
8863 // In-class, must be a friend decl.
8864 assert(FD->getFriendObjectKind() && "expected a friend declaration");
8865 } else {
8866 // Out of class, require the defaulted comparison to be a friend (of a
8867 // complete type, per CWG2547).
8869 diag::err_defaulted_comparison_not_friend, int(DCK),
8870 int(1)))
8871 return true;
8872
8873 if (llvm::none_of(RD->friends(), [&](const FriendDecl *F) {
8874 return FD->getCanonicalDecl() ==
8875 F->getFriendDecl()->getCanonicalDecl();
8876 })) {
8877 Diag(FD->getLocation(), diag::err_defaulted_comparison_not_friend)
8878 << int(DCK) << int(0) << RD;
8879 Diag(RD->getCanonicalDecl()->getLocation(), diag::note_declared_at);
8880 return true;
8881 }
8882 }
8883
8884 // C++2a [class.eq]p1, [class.rel]p1:
8885 // A [defaulted comparison other than <=>] shall have a declared return
8886 // type bool.
8890 Diag(FD->getLocation(), diag::err_defaulted_comparison_return_type_not_bool)
8891 << (int)DCK << FD->getDeclaredReturnType() << Context.BoolTy
8892 << FD->getReturnTypeSourceRange();
8893 return true;
8894 }
8895 // C++2a [class.spaceship]p2 [P2002R0]:
8896 // Let R be the declared return type [...]. If R is auto, [...]. Otherwise,
8897 // R shall not contain a placeholder type.
8898 if (QualType RT = FD->getDeclaredReturnType();
8900 RT->getContainedDeducedType() &&
8902 RT->getContainedAutoType()->isConstrained())) {
8903 Diag(FD->getLocation(),
8904 diag::err_defaulted_comparison_deduced_return_type_not_auto)
8905 << (int)DCK << FD->getDeclaredReturnType() << Context.AutoDeductTy
8906 << FD->getReturnTypeSourceRange();
8907 return true;
8908 }
8909
8910 // For a defaulted function in a dependent class, defer all remaining checks
8911 // until instantiation.
8912 if (RD->isDependentType())
8913 return false;
8914
8915 // Determine whether the function should be defined as deleted.
8916 DefaultedComparisonInfo Info =
8917 DefaultedComparisonAnalyzer(*this, RD, FD, DCK).visit();
8918
8919 bool First = FD == FD->getCanonicalDecl();
8920
8921 if (!First) {
8922 if (Info.Deleted) {
8923 // C++11 [dcl.fct.def.default]p4:
8924 // [For a] user-provided explicitly-defaulted function [...] if such a
8925 // function is implicitly defined as deleted, the program is ill-formed.
8926 //
8927 // This is really just a consequence of the general rule that you can
8928 // only delete a function on its first declaration.
8929 Diag(FD->getLocation(), diag::err_non_first_default_compare_deletes)
8930 << FD->isImplicit() << (int)DCK;
8931 DefaultedComparisonAnalyzer(*this, RD, FD, DCK,
8932 DefaultedComparisonAnalyzer::ExplainDeleted)
8933 .visit();
8934 return true;
8935 }
8936 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
8937 // C++20 [class.compare.default]p1:
8938 // [...] A definition of a comparison operator as defaulted that appears
8939 // in a class shall be the first declaration of that function.
8940 Diag(FD->getLocation(), diag::err_non_first_default_compare_in_class)
8941 << (int)DCK;
8943 diag::note_previous_declaration);
8944 return true;
8945 }
8946 }
8947
8948 // If we want to delete the function, then do so; there's nothing else to
8949 // check in that case.
8950 if (Info.Deleted) {
8951 SetDeclDeleted(FD, FD->getLocation());
8952 if (!inTemplateInstantiation() && !FD->isImplicit()) {
8953 Diag(FD->getLocation(), diag::warn_defaulted_comparison_deleted)
8954 << (int)DCK;
8955 DefaultedComparisonAnalyzer(*this, RD, FD, DCK,
8956 DefaultedComparisonAnalyzer::ExplainDeleted)
8957 .visit();
8958 if (FD->getDefaultLoc().isValid())
8959 Diag(FD->getDefaultLoc(), diag::note_replace_equals_default_to_delete)
8960 << FixItHint::CreateReplacement(FD->getDefaultLoc(), "delete");
8961 }
8962 return false;
8963 }
8964
8965 // C++2a [class.spaceship]p2:
8966 // The return type is deduced as the common comparison type of R0, R1, ...
8970 if (RetLoc.isInvalid())
8971 RetLoc = FD->getBeginLoc();
8972 // FIXME: Should we really care whether we have the complete type and the
8973 // 'enumerator' constants here? A forward declaration seems sufficient.
8975 Info.Category, RetLoc, ComparisonCategoryUsage::DefaultedOperator);
8976 if (Cat.isNull())
8977 return true;
8979 FD, SubstAutoType(FD->getDeclaredReturnType(), Cat));
8980 }
8981
8982 // C++2a [dcl.fct.def.default]p3 [P2002R0]:
8983 // An explicitly-defaulted function that is not defined as deleted may be
8984 // declared constexpr or consteval only if it is constexpr-compatible.
8985 // C++2a [class.compare.default]p3 [P2002R0]:
8986 // A defaulted comparison function is constexpr-compatible if it satisfies
8987 // the requirements for a constexpr function [...]
8988 // The only relevant requirements are that the parameter and return types are
8989 // literal types. The remaining conditions are checked by the analyzer.
8990 //
8991 // We support P2448R2 in language modes earlier than C++23 as an extension.
8992 // The concept of constexpr-compatible was removed.
8993 // C++23 [dcl.fct.def.default]p3 [P2448R2]
8994 // A function explicitly defaulted on its first declaration is implicitly
8995 // inline, and is implicitly constexpr if it is constexpr-suitable.
8996 // C++23 [dcl.constexpr]p3
8997 // A function is constexpr-suitable if
8998 // - it is not a coroutine, and
8999 // - if the function is a constructor or destructor, its class does not
9000 // have any virtual base classes.
9001 if (FD->isConstexpr()) {
9002 if (!getLangOpts().CPlusPlus23 &&
9005 !Info.Constexpr) {
9006 Diag(FD->getBeginLoc(), diag::err_defaulted_comparison_constexpr_mismatch)
9007 << FD->isImplicit() << (int)DCK << FD->isConsteval();
9008 DefaultedComparisonAnalyzer(*this, RD, FD, DCK,
9009 DefaultedComparisonAnalyzer::ExplainConstexpr)
9010 .visit();
9011 }
9012 }
9013
9014 // C++2a [dcl.fct.def.default]p3 [P2002R0]:
9015 // If a constexpr-compatible function is explicitly defaulted on its first
9016 // declaration, it is implicitly considered to be constexpr.
9017 // FIXME: Only applying this to the first declaration seems problematic, as
9018 // simple reorderings can affect the meaning of the program.
9019 if (First && !FD->isConstexpr() && Info.Constexpr)
9021
9022 // C++2a [except.spec]p3:
9023 // If a declaration of a function does not have a noexcept-specifier
9024 // [and] is defaulted on its first declaration, [...] the exception
9025 // specification is as specified below
9026 if (FD->getExceptionSpecType() == EST_None) {
9027 auto *FPT = FD->getType()->castAs<FunctionProtoType>();
9028 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
9030 EPI.ExceptionSpec.SourceDecl = FD;
9031 FD->setType(Context.getFunctionType(FPT->getReturnType(),
9032 FPT->getParamTypes(), EPI));
9033 }
9034
9035 return false;
9036}
9037
9039 FunctionDecl *Spaceship) {
9042 Ctx.PointOfInstantiation = Spaceship->getEndLoc();
9043 Ctx.Entity = Spaceship;
9045
9046 if (FunctionDecl *EqualEqual = SubstSpaceshipAsEqualEqual(RD, Spaceship))
9047 EqualEqual->setImplicit();
9048
9050}
9051
9054 assert(FD->isDefaulted() && !FD->isDeleted() &&
9056 if (FD->willHaveBody() || FD->isInvalidDecl())
9057 return;
9058
9060
9061 // Add a context note for diagnostics produced after this point.
9062 Scope.addContextNote(UseLoc);
9063
9064 {
9065 // Build and set up the function body.
9066 // The first parameter has type maybe-ref-to maybe-const T, use that to get
9067 // the type of the class being compared.
9068 auto PT = FD->getParamDecl(0)->getType();
9069 CXXRecordDecl *RD = PT.getNonReferenceType()->getAsCXXRecordDecl();
9070 SourceLocation BodyLoc =
9071 FD->getEndLoc().isValid() ? FD->getEndLoc() : FD->getLocation();
9072 StmtResult Body =
9073 DefaultedComparisonSynthesizer(*this, RD, FD, DCK, BodyLoc).build();
9074 if (Body.isInvalid()) {
9075 FD->setInvalidDecl();
9076 return;
9077 }
9078 FD->setBody(Body.get());
9079 FD->markUsed(Context);
9080 }
9081
9082 // The exception specification is needed because we are defining the
9083 // function. Note that this will reuse the body we just built.
9085
9087 L->CompletedImplicitDefinition(FD);
9088}
9089
9092 FunctionDecl *FD,
9094 ComputingExceptionSpec CES(S, FD, Loc);
9096
9097 if (FD->isInvalidDecl())
9098 return ExceptSpec;
9099
9100 // The common case is that we just defined the comparison function. In that
9101 // case, just look at whether the body can throw.
9102 if (FD->hasBody()) {
9103 ExceptSpec.CalledStmt(FD->getBody());
9104 } else {
9105 // Otherwise, build a body so we can check it. This should ideally only
9106 // happen when we're not actually marking the function referenced. (This is
9107 // only really important for efficiency: we don't want to build and throw
9108 // away bodies for comparison functions more than we strictly need to.)
9109
9110 // Pretend to synthesize the function body in an unevaluated context.
9111 // Note that we can't actually just go ahead and define the function here:
9112 // we are not permitted to mark its callees as referenced.
9116
9117 CXXRecordDecl *RD =
9118 cast<CXXRecordDecl>(FD->getFriendObjectKind() == Decl::FOK_None
9119 ? FD->getDeclContext()
9120 : FD->getLexicalDeclContext());
9121 SourceLocation BodyLoc =
9122 FD->getEndLoc().isValid() ? FD->getEndLoc() : FD->getLocation();
9123 StmtResult Body =
9124 DefaultedComparisonSynthesizer(S, RD, FD, DCK, BodyLoc).build();
9125 if (!Body.isInvalid())
9126 ExceptSpec.CalledStmt(Body.get());
9127
9128 // FIXME: Can we hold onto this body and just transform it to potentially
9129 // evaluated when we're asked to define the function rather than rebuilding
9130 // it? Either that, or we should only build the bits of the body that we
9131 // need (the expressions, not the statements).
9132 }
9133
9134 return ExceptSpec;
9135}
9136
9138 decltype(DelayedOverridingExceptionSpecChecks) Overriding;
9140
9141 std::swap(Overriding, DelayedOverridingExceptionSpecChecks);
9143
9144 // Perform any deferred checking of exception specifications for virtual
9145 // destructors.
9146 for (auto &Check : Overriding)
9147 CheckOverridingFunctionExceptionSpec(Check.first, Check.second);
9148
9149 // Perform any deferred checking of exception specifications for befriended
9150 // special members.
9151 for (auto &Check : Equivalent)
9152 CheckEquivalentExceptionSpec(Check.second, Check.first);
9153}
9154
9155namespace {
9156/// CRTP base class for visiting operations performed by a special member
9157/// function (or inherited constructor).
9158template<typename Derived>
9159struct SpecialMemberVisitor {
9160 Sema &S;
9161 CXXMethodDecl *MD;
9164
9165 // Properties of the special member, computed for convenience.
9166 bool IsConstructor = false, IsAssignment = false, ConstArg = false;
9167
9168 SpecialMemberVisitor(Sema &S, CXXMethodDecl *MD, CXXSpecialMemberKind CSM,
9170 : S(S), MD(MD), CSM(CSM), ICI(ICI) {
9171 switch (CSM) {
9172 case CXXSpecialMemberKind::DefaultConstructor:
9173 case CXXSpecialMemberKind::CopyConstructor:
9174 case CXXSpecialMemberKind::MoveConstructor:
9175 IsConstructor = true;
9176 break;
9177 case CXXSpecialMemberKind::CopyAssignment:
9178 case CXXSpecialMemberKind::MoveAssignment:
9179 IsAssignment = true;
9180 break;
9181 case CXXSpecialMemberKind::Destructor:
9182 break;
9183 case CXXSpecialMemberKind::Invalid:
9184 llvm_unreachable("invalid special member kind");
9185 }
9186
9187 if (MD->getNumExplicitParams()) {
9188 if (const ReferenceType *RT =
9190 ConstArg = RT->getPointeeType().isConstQualified();
9191 }
9192 }
9193
9194 Derived &getDerived() { return static_cast<Derived&>(*this); }
9195
9196 /// Is this a "move" special member?
9197 bool isMove() const {
9198 return CSM == CXXSpecialMemberKind::MoveConstructor ||
9199 CSM == CXXSpecialMemberKind::MoveAssignment;
9200 }
9201
9202 /// Look up the corresponding special member in the given class.
9204 unsigned Quals, bool IsMutable) {
9205 return lookupCallFromSpecialMember(S, Class, CSM, Quals,
9206 ConstArg && !IsMutable);
9207 }
9208
9209 /// Look up the constructor for the specified base class to see if it's
9210 /// overridden due to this being an inherited constructor.
9211 Sema::SpecialMemberOverloadResult lookupInheritedCtor(CXXRecordDecl *Class) {
9212 if (!ICI)
9213 return {};
9214 assert(CSM == CXXSpecialMemberKind::DefaultConstructor);
9215 auto *BaseCtor =
9216 cast<CXXConstructorDecl>(MD)->getInheritedConstructor().getConstructor();
9217 if (auto *MD = ICI->findConstructorForBase(Class, BaseCtor).first)
9218 return MD;
9219 return {};
9220 }
9221
9222 /// A base or member subobject.
9223 typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
9224
9225 /// Get the location to use for a subobject in diagnostics.
9226 static SourceLocation getSubobjectLoc(Subobject Subobj) {
9227 // FIXME: For an indirect virtual base, the direct base leading to
9228 // the indirect virtual base would be a more useful choice.
9229 if (auto *B = Subobj.dyn_cast<CXXBaseSpecifier*>())
9230 return B->getBaseTypeLoc();
9231 else
9232 return cast<FieldDecl *>(Subobj)->getLocation();
9233 }
9234
9235 enum BasesToVisit {
9236 /// Visit all non-virtual (direct) bases.
9237 VisitNonVirtualBases,
9238 /// Visit all direct bases, virtual or not.
9239 VisitDirectBases,
9240 /// Visit all non-virtual bases, and all virtual bases if the class
9241 /// is not abstract.
9242 VisitPotentiallyConstructedBases,
9243 /// Visit all direct or virtual bases.
9244 VisitAllBases
9245 };
9246
9247 // Visit the bases and members of the class.
9248 bool visit(BasesToVisit Bases) {
9249 CXXRecordDecl *RD = MD->getParent();
9250
9251 if (Bases == VisitPotentiallyConstructedBases)
9252 Bases = RD->isAbstract() ? VisitNonVirtualBases : VisitAllBases;
9253
9254 for (auto &B : RD->bases())
9255 if ((Bases == VisitDirectBases || !B.isVirtual()) &&
9256 getDerived().visitBase(&B))
9257 return true;
9258
9259 if (Bases == VisitAllBases)
9260 for (auto &B : RD->vbases())
9261 if (getDerived().visitBase(&B))
9262 return true;
9263
9264 for (auto *F : RD->fields())
9265 if (!F->isInvalidDecl() && !F->isUnnamedBitField() &&
9266 getDerived().visitField(F))
9267 return true;
9268
9269 return false;
9270 }
9271};
9272}
9273
9274namespace {
9275struct SpecialMemberDeletionInfo
9276 : SpecialMemberVisitor<SpecialMemberDeletionInfo> {
9277 bool Diagnose;
9278
9280
9281 bool AllFieldsAreConst;
9282
9283 SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD,
9285 Sema::InheritedConstructorInfo *ICI, bool Diagnose)
9286 : SpecialMemberVisitor(S, MD, CSM, ICI), Diagnose(Diagnose),
9287 Loc(MD->getLocation()), AllFieldsAreConst(true) {}
9288
9289 bool inUnion() const { return MD->getParent()->isUnion(); }
9290
9291 CXXSpecialMemberKind getEffectiveCSM() {
9292 return ICI ? CXXSpecialMemberKind::Invalid : CSM;
9293 }
9294
9295 bool shouldDeleteForVariantObjCPtrMember(FieldDecl *FD, QualType FieldType);
9296
9297 bool visitBase(CXXBaseSpecifier *Base) { return shouldDeleteForBase(Base); }
9298 bool visitField(FieldDecl *Field) { return shouldDeleteForField(Field); }
9299
9300 bool shouldDeleteForBase(CXXBaseSpecifier *Base);
9301 bool shouldDeleteForField(FieldDecl *FD);
9302 bool shouldDeleteForAllConstMembers();
9303
9304 bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
9305 unsigned Quals);
9306 bool shouldDeleteForSubobjectCall(Subobject Subobj,
9308 bool IsDtorCallInCtor);
9309
9310 bool isAccessible(Subobject Subobj, CXXMethodDecl *D);
9311};
9312}
9313
9314/// Is the given special member inaccessible when used on the given
9315/// sub-object.
9316bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
9317 CXXMethodDecl *target) {
9318 /// If we're operating on a base class, the object type is the
9319 /// type of this special member.
9320 QualType objectTy;
9321 AccessSpecifier access = target->getAccess();
9322 if (CXXBaseSpecifier *base = Subobj.dyn_cast<CXXBaseSpecifier*>()) {
9323 objectTy = S.Context.getTypeDeclType(MD->getParent());
9324 access = CXXRecordDecl::MergeAccess(base->getAccessSpecifier(), access);
9325
9326 // If we're operating on a field, the object type is the type of the field.
9327 } else {
9328 objectTy = S.Context.getTypeDeclType(target->getParent());
9329 }
9330
9332 target->getParent(), DeclAccessPair::make(target, access), objectTy);
9333}
9334
9335/// Check whether we should delete a special member due to the implicit
9336/// definition containing a call to a special member of a subobject.
9337bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
9338 Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR,
9339 bool IsDtorCallInCtor) {
9340 CXXMethodDecl *Decl = SMOR.getMethod();
9341 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
9342
9343 int DiagKind = -1;
9344
9346 DiagKind = !Decl ? 0 : 1;
9348 DiagKind = 2;
9349 else if (!isAccessible(Subobj, Decl))
9350 DiagKind = 3;
9351 else if (!IsDtorCallInCtor && Field && Field->getParent()->isUnion() &&
9352 !Decl->isTrivial()) {
9353 // A member of a union must have a trivial corresponding special member.
9354 // As a weird special case, a destructor call from a union's constructor
9355 // must be accessible and non-deleted, but need not be trivial. Such a
9356 // destructor is never actually called, but is semantically checked as
9357 // if it were.
9359 // [class.default.ctor]p2:
9360 // A defaulted default constructor for class X is defined as deleted if
9361 // - X is a union that has a variant member with a non-trivial default
9362 // constructor and no variant member of X has a default member
9363 // initializer
9364 const auto *RD = cast<CXXRecordDecl>(Field->getParent());
9365 if (!RD->hasInClassInitializer())
9366 DiagKind = 4;
9367 } else {
9368 DiagKind = 4;
9369 }
9370 }
9371
9372 if (DiagKind == -1)
9373 return false;
9374
9375 if (Diagnose) {
9376 if (Field) {
9377 S.Diag(Field->getLocation(),
9378 diag::note_deleted_special_member_class_subobject)
9379 << llvm::to_underlying(getEffectiveCSM()) << MD->getParent()
9380 << /*IsField*/ true << Field << DiagKind << IsDtorCallInCtor
9381 << /*IsObjCPtr*/ false;
9382 } else {
9383 CXXBaseSpecifier *Base = cast<CXXBaseSpecifier *>(Subobj);
9384 S.Diag(Base->getBeginLoc(),
9385 diag::note_deleted_special_member_class_subobject)
9386 << llvm::to_underlying(getEffectiveCSM()) << MD->getParent()
9387 << /*IsField*/ false << Base->getType() << DiagKind
9388 << IsDtorCallInCtor << /*IsObjCPtr*/ false;
9389 }
9390
9391 if (DiagKind == 1)
9393 // FIXME: Explain inaccessibility if DiagKind == 3.
9394 }
9395
9396 return true;
9397}
9398
9399/// Check whether we should delete a special member function due to having a
9400/// direct or virtual base class or non-static data member of class type M.
9401bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
9402 CXXRecordDecl *Class, Subobject Subobj, unsigned Quals) {
9403 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
9404 bool IsMutable = Field && Field->isMutable();
9405
9406 // C++11 [class.ctor]p5:
9407 // -- any direct or virtual base class, or non-static data member with no
9408 // brace-or-equal-initializer, has class type M (or array thereof) and
9409 // either M has no default constructor or overload resolution as applied
9410 // to M's default constructor results in an ambiguity or in a function
9411 // that is deleted or inaccessible
9412 // C++11 [class.copy]p11, C++11 [class.copy]p23:
9413 // -- a direct or virtual base class B that cannot be copied/moved because
9414 // overload resolution, as applied to B's corresponding special member,
9415 // results in an ambiguity or a function that is deleted or inaccessible
9416 // from the defaulted special member
9417 // C++11 [class.dtor]p5:
9418 // -- any direct or virtual base class [...] has a type with a destructor
9419 // that is deleted or inaccessible
9420 if (!(CSM == CXXSpecialMemberKind::DefaultConstructor && Field &&
9421 Field->hasInClassInitializer()) &&
9422 shouldDeleteForSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable),
9423 false))
9424 return true;
9425
9426 // C++11 [class.ctor]p5, C++11 [class.copy]p11:
9427 // -- any direct or virtual base class or non-static data member has a
9428 // type with a destructor that is deleted or inaccessible
9429 if (IsConstructor) {
9432 false, false, false, false);
9433 if (shouldDeleteForSubobjectCall(Subobj, SMOR, true))
9434 return true;
9435 }
9436
9437 return false;
9438}
9439
9440bool SpecialMemberDeletionInfo::shouldDeleteForVariantObjCPtrMember(
9441 FieldDecl *FD, QualType FieldType) {
9442 // The defaulted special functions are defined as deleted if this is a variant
9443 // member with a non-trivial ownership type, e.g., ObjC __strong or __weak
9444 // type under ARC.
9445 if (!FieldType.hasNonTrivialObjCLifetime())
9446 return false;
9447
9448 // Don't make the defaulted default constructor defined as deleted if the
9449 // member has an in-class initializer.
9452 return false;
9453
9454 if (Diagnose) {
9455 auto *ParentClass = cast<CXXRecordDecl>(FD->getParent());
9456 S.Diag(FD->getLocation(), diag::note_deleted_special_member_class_subobject)
9457 << llvm::to_underlying(getEffectiveCSM()) << ParentClass
9458 << /*IsField*/ true << FD << 4 << /*IsDtorCallInCtor*/ false
9459 << /*IsObjCPtr*/ true;
9460 }
9461
9462 return true;
9463}
9464
9465/// Check whether we should delete a special member function due to the class
9466/// having a particular direct or virtual base class.
9467bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
9468 CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
9469 // If program is correct, BaseClass cannot be null, but if it is, the error
9470 // must be reported elsewhere.
9471 if (!BaseClass)
9472 return false;
9473 // If we have an inheriting constructor, check whether we're calling an
9474 // inherited constructor instead of a default constructor.
9475 Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
9476 if (auto *BaseCtor = SMOR.getMethod()) {
9477 // Note that we do not check access along this path; other than that,
9478 // this is the same as shouldDeleteForSubobjectCall(Base, BaseCtor, false);
9479 // FIXME: Check that the base has a usable destructor! Sink this into
9480 // shouldDeleteForClassSubobject.
9481 if (BaseCtor->isDeleted() && Diagnose) {
9482 S.Diag(Base->getBeginLoc(),
9483 diag::note_deleted_special_member_class_subobject)
9484 << llvm::to_underlying(getEffectiveCSM()) << MD->getParent()
9485 << /*IsField*/ false << Base->getType() << /*Deleted*/ 1
9486 << /*IsDtorCallInCtor*/ false << /*IsObjCPtr*/ false;
9487 S.NoteDeletedFunction(BaseCtor);
9488 }
9489 return BaseCtor->isDeleted();
9490 }
9491 return shouldDeleteForClassSubobject(BaseClass, Base, 0);
9492}
9493
9494/// Check whether we should delete a special member function due to the class
9495/// having a particular non-static data member.
9496bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) {
9497 QualType FieldType = S.Context.getBaseElementType(FD->getType());
9498 CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl();
9499
9500 if (inUnion() && shouldDeleteForVariantObjCPtrMember(FD, FieldType))
9501 return true;
9502
9504 // For a default constructor, all references must be initialized in-class
9505 // and, if a union, it must have a non-const member.
9506 if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) {
9507 if (Diagnose)
9508 S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
9509 << !!ICI << MD->getParent() << FD << FieldType << /*Reference*/0;
9510 return true;
9511 }
9512 // C++11 [class.ctor]p5 (modified by DR2394): any non-variant non-static
9513 // data member of const-qualified type (or array thereof) with no
9514 // brace-or-equal-initializer is not const-default-constructible.
9515 if (!inUnion() && FieldType.isConstQualified() &&
9516 !FD->hasInClassInitializer() &&
9517 (!FieldRecord || !FieldRecord->allowConstDefaultInit())) {
9518 if (Diagnose)
9519 S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
9520 << !!ICI << MD->getParent() << FD << FD->getType() << /*Const*/1;
9521 return true;
9522 }
9523
9524 if (inUnion() && !FieldType.isConstQualified())
9525 AllFieldsAreConst = false;
9526 } else if (CSM == CXXSpecialMemberKind::CopyConstructor) {
9527 // For a copy constructor, data members must not be of rvalue reference
9528 // type.
9529 if (FieldType->isRValueReferenceType()) {
9530 if (Diagnose)
9531 S.Diag(FD->getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
9532 << MD->getParent() << FD << FieldType;
9533 return true;
9534 }
9535 } else if (IsAssignment) {
9536 // For an assignment operator, data members must not be of reference type.
9537 if (FieldType->isReferenceType()) {
9538 if (Diagnose)
9539 S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
9540 << isMove() << MD->getParent() << FD << FieldType << /*Reference*/0;
9541 return true;
9542 }
9543 if (!FieldRecord && FieldType.isConstQualified()) {
9544 // C++11 [class.copy]p23:
9545 // -- a non-static data member of const non-class type (or array thereof)
9546 if (Diagnose)
9547 S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
9548 << isMove() << MD->getParent() << FD << FD->getType() << /*Const*/1;
9549 return true;
9550 }
9551 }
9552
9553 if (FieldRecord) {
9554 // Some additional restrictions exist on the variant members.
9555 if (!inUnion() && FieldRecord->isUnion() &&
9556 FieldRecord->isAnonymousStructOrUnion()) {
9557 bool AllVariantFieldsAreConst = true;
9558
9559 // FIXME: Handle anonymous unions declared within anonymous unions.
9560 for (auto *UI : FieldRecord->fields()) {
9561 QualType UnionFieldType = S.Context.getBaseElementType(UI->getType());
9562
9563 if (shouldDeleteForVariantObjCPtrMember(&*UI, UnionFieldType))
9564 return true;
9565
9566 if (!UnionFieldType.isConstQualified())
9567 AllVariantFieldsAreConst = false;
9568
9569 CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl();
9570 if (UnionFieldRecord &&
9571 shouldDeleteForClassSubobject(UnionFieldRecord, UI,
9572 UnionFieldType.getCVRQualifiers()))
9573 return true;
9574 }
9575
9576 // At least one member in each anonymous union must be non-const
9578 AllVariantFieldsAreConst && !FieldRecord->field_empty()) {
9579 if (Diagnose)
9580 S.Diag(FieldRecord->getLocation(),
9581 diag::note_deleted_default_ctor_all_const)
9582 << !!ICI << MD->getParent() << /*anonymous union*/1;
9583 return true;
9584 }
9585
9586 // Don't check the implicit member of the anonymous union type.
9587 // This is technically non-conformant but supported, and we have a
9588 // diagnostic for this elsewhere.
9589 return false;
9590 }
9591
9592 if (shouldDeleteForClassSubobject(FieldRecord, FD,
9593 FieldType.getCVRQualifiers()))
9594 return true;
9595 }
9596
9597 return false;
9598}
9599
9600/// C++11 [class.ctor] p5:
9601/// A defaulted default constructor for a class X is defined as deleted if
9602/// X is a union and all of its variant members are of const-qualified type.
9603bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
9604 // This is a silly definition, because it gives an empty union a deleted
9605 // default constructor. Don't do that.
9606 if (CSM == CXXSpecialMemberKind::DefaultConstructor && inUnion() &&
9607 AllFieldsAreConst) {
9608 bool AnyFields = false;
9609 for (auto *F : MD->getParent()->fields())
9610 if ((AnyFields = !F->isUnnamedBitField()))
9611 break;
9612 if (!AnyFields)
9613 return false;
9614 if (Diagnose)
9615 S.Diag(MD->getParent()->getLocation(),
9616 diag::note_deleted_default_ctor_all_const)
9617 << !!ICI << MD->getParent() << /*not anonymous union*/0;
9618 return true;
9619 }
9620 return false;
9621}
9622
9623/// Determine whether a defaulted special member function should be defined as
9624/// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11,
9625/// C++11 [class.copy]p23, and C++11 [class.dtor]p5.
9629 bool Diagnose) {
9630 if (MD->isInvalidDecl())
9631 return false;
9632 CXXRecordDecl *RD = MD->getParent();
9633 assert(!RD->isDependentType() && "do deletion after instantiation");
9634 if (!LangOpts.CPlusPlus || (!LangOpts.CPlusPlus11 && !RD->isLambda()) ||
9635 RD->isInvalidDecl())
9636 return false;
9637
9638 // C++11 [expr.lambda.prim]p19:
9639 // The closure type associated with a lambda-expression has a
9640 // deleted (8.4.3) default constructor and a deleted copy
9641 // assignment operator.
9642 // C++2a adds back these operators if the lambda has no lambda-capture.
9646 if (Diagnose)
9647 Diag(RD->getLocation(), diag::note_lambda_decl);
9648 return true;
9649 }
9650
9651 // For an anonymous struct or union, the copy and assignment special members
9652 // will never be used, so skip the check. For an anonymous union declared at
9653 // namespace scope, the constructor and destructor are used.
9656 return false;
9657
9658 // C++11 [class.copy]p7, p18:
9659 // If the class definition declares a move constructor or move assignment
9660 // operator, an implicitly declared copy constructor or copy assignment
9661 // operator is defined as deleted.
9664 CXXMethodDecl *UserDeclaredMove = nullptr;
9665
9666 // In Microsoft mode up to MSVC 2013, a user-declared move only causes the
9667 // deletion of the corresponding copy operation, not both copy operations.
9668 // MSVC 2015 has adopted the standards conforming behavior.
9669 bool DeletesOnlyMatchingCopy =
9670 getLangOpts().MSVCCompat &&
9672
9674 (!DeletesOnlyMatchingCopy ||
9676 if (!Diagnose) return true;
9677
9678 // Find any user-declared move constructor.
9679 for (auto *I : RD->ctors()) {
9680 if (I->isMoveConstructor()) {
9681 UserDeclaredMove = I;
9682 break;
9683 }
9684 }
9685 assert(UserDeclaredMove);
9686 } else if (RD->hasUserDeclaredMoveAssignment() &&
9687 (!DeletesOnlyMatchingCopy ||
9689 if (!Diagnose) return true;
9690
9691 // Find any user-declared move assignment operator.
9692 for (auto *I : RD->methods()) {
9693 if (I->isMoveAssignmentOperator()) {
9694 UserDeclaredMove = I;
9695 break;
9696 }
9697 }
9698 assert(UserDeclaredMove);
9699 }
9700
9701 if (UserDeclaredMove) {
9702 Diag(UserDeclaredMove->getLocation(),
9703 diag::note_deleted_copy_user_declared_move)
9704 << (CSM == CXXSpecialMemberKind::CopyAssignment) << RD
9705 << UserDeclaredMove->isMoveAssignmentOperator();
9706 return true;
9707 }
9708 }
9709
9710 // Do access control from the special member function
9711 ContextRAII MethodContext(*this, MD);
9712
9713 // C++11 [class.dtor]p5:
9714 // -- for a virtual destructor, lookup of the non-array deallocation function
9715 // results in an ambiguity or in a function that is deleted or inaccessible
9716 if (CSM == CXXSpecialMemberKind::Destructor && MD->isVirtual()) {
9717 FunctionDecl *OperatorDelete = nullptr;
9718 DeclarationName Name =
9720 if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name,
9721 OperatorDelete, /*Diagnose*/false)) {
9722 if (Diagnose)
9723 Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete);
9724 return true;
9725 }
9726 }
9727
9728 SpecialMemberDeletionInfo SMI(*this, MD, CSM, ICI, Diagnose);
9729
9730 // Per DR1611, do not consider virtual bases of constructors of abstract
9731 // classes, since we are not going to construct them.
9732 // Per DR1658, do not consider virtual bases of destructors of abstract
9733 // classes either.
9734 // Per DR2180, for assignment operators we only assign (and thus only
9735 // consider) direct bases.
9736 if (SMI.visit(SMI.IsAssignment ? SMI.VisitDirectBases
9737 : SMI.VisitPotentiallyConstructedBases))
9738 return true;
9739
9740 if (SMI.shouldDeleteForAllConstMembers())
9741 return true;
9742
9743 if (getLangOpts().CUDA) {
9744 // We should delete the special member in CUDA mode if target inference
9745 // failed.
9746 // For inherited constructors (non-null ICI), CSM may be passed so that MD
9747 // is treated as certain special member, which may not reflect what special
9748 // member MD really is. However inferTargetForImplicitSpecialMember
9749 // expects CSM to match MD, therefore recalculate CSM.
9750 assert(ICI || CSM == getSpecialMember(MD));
9751 auto RealCSM = CSM;
9752 if (ICI)
9753 RealCSM = getSpecialMember(MD);
9754
9755 return CUDA().inferTargetForImplicitSpecialMember(RD, RealCSM, MD,
9756 SMI.ConstArg, Diagnose);
9757 }
9758
9759 return false;
9760}
9761
9764 assert(DFK && "not a defaultable function");
9765 assert(FD->isDefaulted() && FD->isDeleted() && "not defaulted and deleted");
9766
9767 if (DFK.isSpecialMember()) {
9768 ShouldDeleteSpecialMember(cast<CXXMethodDecl>(FD), DFK.asSpecialMember(),
9769 nullptr, /*Diagnose=*/true);
9770 } else {
9771 DefaultedComparisonAnalyzer(
9772 *this, cast<CXXRecordDecl>(FD->getLexicalDeclContext()), FD,
9773 DFK.asComparison(), DefaultedComparisonAnalyzer::ExplainDeleted)
9774 .visit();
9775 }
9776}
9777
9778/// Perform lookup for a special member of the specified kind, and determine
9779/// whether it is trivial. If the triviality can be determined without the
9780/// lookup, skip it. This is intended for use when determining whether a
9781/// special member of a containing object is trivial, and thus does not ever
9782/// perform overload resolution for default constructors.
9783///
9784/// If \p Selected is not \c NULL, \c *Selected will be filled in with the
9785/// member that was most likely to be intended to be trivial, if any.
9786///
9787/// If \p ForCall is true, look at CXXRecord::HasTrivialSpecialMembersForCall to
9788/// determine whether the special member is trivial.
9790 CXXSpecialMemberKind CSM, unsigned Quals,
9791 bool ConstRHS,
9793 CXXMethodDecl **Selected) {
9794 if (Selected)
9795 *Selected = nullptr;
9796
9797 switch (CSM) {
9799 llvm_unreachable("not a special member");
9800
9802 // C++11 [class.ctor]p5:
9803 // A default constructor is trivial if:
9804 // - all the [direct subobjects] have trivial default constructors
9805 //
9806 // Note, no overload resolution is performed in this case.
9808 return true;
9809
9810 if (Selected) {
9811 // If there's a default constructor which could have been trivial, dig it
9812 // out. Otherwise, if there's any user-provided default constructor, point
9813 // to that as an example of why there's not a trivial one.
9814 CXXConstructorDecl *DefCtor = nullptr;
9817 for (auto *CI : RD->ctors()) {
9818 if (!CI->isDefaultConstructor())
9819 continue;
9820 DefCtor = CI;
9821 if (!DefCtor->isUserProvided())
9822 break;
9823 }
9824
9825 *Selected = DefCtor;
9826 }
9827
9828 return false;
9829
9831 // C++11 [class.dtor]p5:
9832 // A destructor is trivial if:
9833 // - all the direct [subobjects] have trivial destructors
9834 if (RD->hasTrivialDestructor() ||
9837 return true;
9838
9839 if (Selected) {
9840 if (RD->needsImplicitDestructor())
9842 *Selected = RD->getDestructor();
9843 }
9844
9845 return false;
9846
9848 // C++11 [class.copy]p12:
9849 // A copy constructor is trivial if:
9850 // - the constructor selected to copy each direct [subobject] is trivial
9851 if (RD->hasTrivialCopyConstructor() ||
9854 if (Quals == Qualifiers::Const)
9855 // We must either select the trivial copy constructor or reach an
9856 // ambiguity; no need to actually perform overload resolution.
9857 return true;
9858 } else if (!Selected) {
9859 return false;
9860 }
9861 // In C++98, we are not supposed to perform overload resolution here, but we
9862 // treat that as a language defect, as suggested on cxx-abi-dev, to treat
9863 // cases like B as having a non-trivial copy constructor:
9864 // struct A { template<typename T> A(T&); };
9865 // struct B { mutable A a; };
9866 goto NeedOverloadResolution;
9867
9869 // C++11 [class.copy]p25:
9870 // A copy assignment operator is trivial if:
9871 // - the assignment operator selected to copy each direct [subobject] is
9872 // trivial
9873 if (RD->hasTrivialCopyAssignment()) {
9874 if (Quals == Qualifiers::Const)
9875 return true;
9876 } else if (!Selected) {
9877 return false;
9878 }
9879 // In C++98, we are not supposed to perform overload resolution here, but we
9880 // treat that as a language defect.
9881 goto NeedOverloadResolution;
9882
9885 NeedOverloadResolution:
9887 lookupCallFromSpecialMember(S, RD, CSM, Quals, ConstRHS);
9888
9889 // The standard doesn't describe how to behave if the lookup is ambiguous.
9890 // We treat it as not making the member non-trivial, just like the standard
9891 // mandates for the default constructor. This should rarely matter, because
9892 // the member will also be deleted.
9894 return true;
9895
9896 if (!SMOR.getMethod()) {
9897 assert(SMOR.getKind() ==
9899 return false;
9900 }
9901
9902 // We deliberately don't check if we found a deleted special member. We're
9903 // not supposed to!
9904 if (Selected)
9905 *Selected = SMOR.getMethod();
9906
9907 if (TAH == Sema::TAH_ConsiderTrivialABI &&
9910 return SMOR.getMethod()->isTrivialForCall();
9911 return SMOR.getMethod()->isTrivial();
9912 }
9913
9914 llvm_unreachable("unknown special method kind");
9915}
9916
9918 for (auto *CI : RD->ctors())
9919 if (!CI->isImplicit())
9920 return CI;
9921
9922 // Look for constructor templates.
9924 for (tmpl_iter TI(RD->decls_begin()), TE(RD->decls_end()); TI != TE; ++TI) {
9925 if (CXXConstructorDecl *CD =
9926 dyn_cast<CXXConstructorDecl>(TI->getTemplatedDecl()))
9927 return CD;
9928 }
9929
9930 return nullptr;
9931}
9932
9933/// The kind of subobject we are checking for triviality. The values of this
9934/// enumeration are used in diagnostics.
9936 /// The subobject is a base class.
9938 /// The subobject is a non-static data member.
9940 /// The object is actually the complete object.
9943
9944/// Check whether the special member selected for a given type would be trivial.
9946 QualType SubType, bool ConstRHS,
9950 bool Diagnose) {
9951 CXXRecordDecl *SubRD = SubType->getAsCXXRecordDecl();
9952 if (!SubRD)
9953 return true;
9954
9955 CXXMethodDecl *Selected;
9956 if (findTrivialSpecialMember(S, SubRD, CSM, SubType.getCVRQualifiers(),
9957 ConstRHS, TAH, Diagnose ? &Selected : nullptr))
9958 return true;
9959
9960 if (Diagnose) {
9961 if (ConstRHS)
9962 SubType.addConst();
9963
9964 if (!Selected && CSM == CXXSpecialMemberKind::DefaultConstructor) {
9965 S.Diag(SubobjLoc, diag::note_nontrivial_no_def_ctor)
9966 << Kind << SubType.getUnqualifiedType();
9968 S.Diag(CD->getLocation(), diag::note_user_declared_ctor);
9969 } else if (!Selected)
9970 S.Diag(SubobjLoc, diag::note_nontrivial_no_copy)
9971 << Kind << SubType.getUnqualifiedType() << llvm::to_underlying(CSM)
9972 << SubType;
9973 else if (Selected->isUserProvided()) {
9974 if (Kind == TSK_CompleteObject)
9975 S.Diag(Selected->getLocation(), diag::note_nontrivial_user_provided)
9976 << Kind << SubType.getUnqualifiedType() << llvm::to_underlying(CSM);
9977 else {
9978 S.Diag(SubobjLoc, diag::note_nontrivial_user_provided)
9979 << Kind << SubType.getUnqualifiedType() << llvm::to_underlying(CSM);
9980 S.Diag(Selected->getLocation(), diag::note_declared_at);
9981 }
9982 } else {
9983 if (Kind != TSK_CompleteObject)
9984 S.Diag(SubobjLoc, diag::note_nontrivial_subobject)
9985 << Kind << SubType.getUnqualifiedType() << llvm::to_underlying(CSM);
9986
9987 // Explain why the defaulted or deleted special member isn't trivial.
9989 Diagnose);
9990 }
9991 }
9992
9993 return false;
9994}
9995
9996/// Check whether the members of a class type allow a special member to be
9997/// trivial.
9999 CXXSpecialMemberKind CSM, bool ConstArg,
10001 bool Diagnose) {
10002 for (const auto *FI : RD->fields()) {
10003 if (FI->isInvalidDecl() || FI->isUnnamedBitField())
10004 continue;
10005
10006 QualType FieldType = S.Context.getBaseElementType(FI->getType());
10007
10008 // Pretend anonymous struct or union members are members of this class.
10009 if (FI->isAnonymousStructOrUnion()) {
10010 if (!checkTrivialClassMembers(S, FieldType->getAsCXXRecordDecl(),
10011 CSM, ConstArg, TAH, Diagnose))
10012 return false;
10013 continue;
10014 }
10015
10016 // C++11 [class.ctor]p5:
10017 // A default constructor is trivial if [...]
10018 // -- no non-static data member of its class has a
10019 // brace-or-equal-initializer
10021 FI->hasInClassInitializer()) {
10022 if (Diagnose)
10023 S.Diag(FI->getLocation(), diag::note_nontrivial_default_member_init)
10024 << FI;
10025 return false;
10026 }
10027
10028 // Objective C ARC 4.3.5:
10029 // [...] nontrivally ownership-qualified types are [...] not trivially
10030 // default constructible, copy constructible, move constructible, copy
10031 // assignable, move assignable, or destructible [...]
10032 if (FieldType.hasNonTrivialObjCLifetime()) {
10033 if (Diagnose)
10034 S.Diag(FI->getLocation(), diag::note_nontrivial_objc_ownership)
10035 << RD << FieldType.getObjCLifetime();
10036 return false;
10037 }
10038
10039 bool ConstRHS = ConstArg && !FI->isMutable();
10040 if (!checkTrivialSubobjectCall(S, FI->getLocation(), FieldType, ConstRHS,
10041 CSM, TSK_Field, TAH, Diagnose))
10042 return false;
10043 }
10044
10045 return true;
10046}
10047
10051
10052 bool ConstArg = (CSM == CXXSpecialMemberKind::CopyConstructor ||
10054 checkTrivialSubobjectCall(*this, RD->getLocation(), Ty, ConstArg, CSM,
10056 /*Diagnose*/true);
10057}
10058
10060 TrivialABIHandling TAH, bool Diagnose) {
10061 assert(!MD->isUserProvided() && CSM != CXXSpecialMemberKind::Invalid &&
10062 "not special enough");
10063
10064 CXXRecordDecl *RD = MD->getParent();
10065
10066 bool ConstArg = false;
10067
10068 // C++11 [class.copy]p12, p25: [DR1593]
10069 // A [special member] is trivial if [...] its parameter-type-list is
10070 // equivalent to the parameter-type-list of an implicit declaration [...]
10071 switch (CSM) {
10074 // Trivial default constructors and destructors cannot have parameters.
10075 break;
10076
10079 const ParmVarDecl *Param0 = MD->getNonObjectParameter(0);
10080 const ReferenceType *RT = Param0->getType()->getAs<ReferenceType>();
10081
10082 // When ClangABICompat14 is true, CXX copy constructors will only be trivial
10083 // if they are not user-provided and their parameter-type-list is equivalent
10084 // to the parameter-type-list of an implicit declaration. This maintains the
10085 // behavior before dr2171 was implemented.
10086 //
10087 // Otherwise, if ClangABICompat14 is false, All copy constructors can be
10088 // trivial, if they are not user-provided, regardless of the qualifiers on
10089 // the reference type.
10090 const bool ClangABICompat14 = Context.getLangOpts().getClangABICompat() <=
10092 if (!RT ||
10094 ClangABICompat14)) {
10095 if (Diagnose)
10096 Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
10097 << Param0->getSourceRange() << Param0->getType()
10100 return false;
10101 }
10102
10103 ConstArg = RT->getPointeeType().isConstQualified();
10104 break;
10105 }
10106
10109 // Trivial move operations always have non-cv-qualified parameters.
10110 const ParmVarDecl *Param0 = MD->getNonObjectParameter(0);
10111 const RValueReferenceType *RT =
10112 Param0->getType()->getAs<RValueReferenceType>();
10113 if (!RT || RT->getPointeeType().getCVRQualifiers()) {
10114 if (Diagnose)
10115 Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
10116 << Param0->getSourceRange() << Param0->getType()
10118 return false;
10119 }
10120 break;
10121 }
10122
10124 llvm_unreachable("not a special member");
10125 }
10126
10127 if (MD->getMinRequiredArguments() < MD->getNumParams()) {
10128 if (Diagnose)
10130 diag::note_nontrivial_default_arg)
10132 return false;
10133 }
10134 if (MD->isVariadic()) {
10135 if (Diagnose)
10136 Diag(MD->getLocation(), diag::note_nontrivial_variadic);
10137 return false;
10138 }
10139
10140 // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
10141 // A copy/move [constructor or assignment operator] is trivial if
10142 // -- the [member] selected to copy/move each direct base class subobject
10143 // is trivial
10144 //
10145 // C++11 [class.copy]p12, C++11 [class.copy]p25:
10146 // A [default constructor or destructor] is trivial if
10147 // -- all the direct base classes have trivial [default constructors or
10148 // destructors]
10149 for (const auto &BI : RD->bases())
10150 if (!checkTrivialSubobjectCall(*this, BI.getBeginLoc(), BI.getType(),
10151 ConstArg, CSM, TSK_BaseClass, TAH, Diagnose))
10152 return false;
10153
10154 // C++11 [class.ctor]p5, C++11 [class.dtor]p5:
10155 // A copy/move [constructor or assignment operator] for a class X is
10156 // trivial if
10157 // -- for each non-static data member of X that is of class type (or array
10158 // thereof), the constructor selected to copy/move that member is
10159 // trivial
10160 //
10161 // C++11 [class.copy]p12, C++11 [class.copy]p25:
10162 // A [default constructor or destructor] is trivial if
10163 // -- for all of the non-static data members of its class that are of class
10164 // type (or array thereof), each such class has a trivial [default
10165 // constructor or destructor]
10166 if (!checkTrivialClassMembers(*this, RD, CSM, ConstArg, TAH, Diagnose))
10167 return false;
10168
10169 // C++11 [class.dtor]p5:
10170 // A destructor is trivial if [...]
10171 // -- the destructor is not virtual
10172 if (CSM == CXXSpecialMemberKind::Destructor && MD->isVirtual()) {
10173 if (Diagnose)
10174 Diag(MD->getLocation(), diag::note_nontrivial_virtual_dtor) << RD;
10175 return false;
10176 }
10177
10178 // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
10179 // A [special member] for class X is trivial if [...]
10180 // -- class X has no virtual functions and no virtual base classes
10182 MD->getParent()->isDynamicClass()) {
10183 if (!Diagnose)
10184 return false;
10185
10186 if (RD->getNumVBases()) {
10187 // Check for virtual bases. We already know that the corresponding
10188 // member in all bases is trivial, so vbases must all be direct.
10189 CXXBaseSpecifier &BS = *RD->vbases_begin();
10190 assert(BS.isVirtual());
10191 Diag(BS.getBeginLoc(), diag::note_nontrivial_has_virtual) << RD << 1;
10192 return false;
10193 }
10194
10195 // Must have a virtual method.
10196 for (const auto *MI : RD->methods()) {
10197 if (MI->isVirtual()) {
10198 SourceLocation MLoc = MI->getBeginLoc();
10199 Diag(MLoc, diag::note_nontrivial_has_virtual) << RD << 0;
10200 return false;
10201 }
10202 }
10203
10204 llvm_unreachable("dynamic class with no vbases and no virtual functions");
10205 }
10206
10207 // Looks like it's trivial!
10208 return true;
10209}
10210
10211namespace {
10212struct FindHiddenVirtualMethod {
10213 Sema *S;
10214 CXXMethodDecl *Method;
10215 llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
10216 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
10217
10218private:
10219 /// Check whether any most overridden method from MD in Methods
10220 static bool CheckMostOverridenMethods(
10221 const CXXMethodDecl *MD,
10222 const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
10223 if (MD->size_overridden_methods() == 0)
10224 return Methods.count(MD->getCanonicalDecl());
10225 for (const CXXMethodDecl *O : MD->overridden_methods())
10226 if (CheckMostOverridenMethods(O, Methods))
10227 return true;
10228 return false;
10229 }
10230
10231public:
10232 /// Member lookup function that determines whether a given C++
10233 /// method overloads virtual methods in a base class without overriding any,
10234 /// to be used with CXXRecordDecl::lookupInBases().
10235 bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
10236 RecordDecl *BaseRecord =
10237 Specifier->getType()->castAs<RecordType>()->getDecl();
10238
10239 DeclarationName Name = Method->getDeclName();
10240 assert(Name.getNameKind() == DeclarationName::Identifier);
10241
10242 bool foundSameNameMethod = false;
10243 SmallVector<CXXMethodDecl *, 8> overloadedMethods;
10244 for (Path.Decls = BaseRecord->lookup(Name).begin();
10245 Path.Decls != DeclContext::lookup_iterator(); ++Path.Decls) {
10246 NamedDecl *D = *Path.Decls;
10247 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
10248 MD = MD->getCanonicalDecl();
10249 foundSameNameMethod = true;
10250 // Interested only in hidden virtual methods.
10251 if (!MD->isVirtual())
10252 continue;
10253 // If the method we are checking overrides a method from its base
10254 // don't warn about the other overloaded methods. Clang deviates from
10255 // GCC by only diagnosing overloads of inherited virtual functions that
10256 // do not override any other virtual functions in the base. GCC's
10257 // -Woverloaded-virtual diagnoses any derived function hiding a virtual
10258 // function from a base class. These cases may be better served by a
10259 // warning (not specific to virtual functions) on call sites when the
10260 // call would select a different function from the base class, were it
10261 // visible.
10262 // See FIXME in test/SemaCXX/warn-overload-virtual.cpp for an example.
10263 if (!S->IsOverload(Method, MD, false))
10264 return true;
10265 // Collect the overload only if its hidden.
10266 if (!CheckMostOverridenMethods(MD, OverridenAndUsingBaseMethods))
10267 overloadedMethods.push_back(MD);
10268 }
10269 }
10270
10271 if (foundSameNameMethod)
10272 OverloadedMethods.append(overloadedMethods.begin(),
10273 overloadedMethods.end());
10274 return foundSameNameMethod;
10275 }
10276};
10277} // end anonymous namespace
10278
10279/// Add the most overridden methods from MD to Methods
10281 llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
10282 if (MD->size_overridden_methods() == 0)
10283 Methods.insert(MD->getCanonicalDecl());
10284 else
10285 for (const CXXMethodDecl *O : MD->overridden_methods())
10286 AddMostOverridenMethods(O, Methods);
10287}
10288
10290 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
10291 if (!MD->getDeclName().isIdentifier())
10292 return;
10293
10294 CXXBasePaths Paths(/*FindAmbiguities=*/true, // true to look in all bases.
10295 /*bool RecordPaths=*/false,
10296 /*bool DetectVirtual=*/false);
10297 FindHiddenVirtualMethod FHVM;
10298 FHVM.Method = MD;
10299 FHVM.S = this;
10300
10301 // Keep the base methods that were overridden or introduced in the subclass
10302 // by 'using' in a set. A base method not in this set is hidden.
10303 CXXRecordDecl *DC = MD->getParent();
10305 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
10306 NamedDecl *ND = *I;
10307 if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*I))
10308 ND = shad->getTargetDecl();
10309 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND))
10310 AddMostOverridenMethods(MD, FHVM.OverridenAndUsingBaseMethods);
10311 }
10312
10313 if (DC->lookupInBases(FHVM, Paths))
10314 OverloadedMethods = FHVM.OverloadedMethods;
10315}
10316
10318 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
10319 for (unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) {
10320 CXXMethodDecl *overloadedMD = OverloadedMethods[i];
10322 diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
10323 HandleFunctionTypeMismatch(PD, MD->getType(), overloadedMD->getType());
10324 Diag(overloadedMD->getLocation(), PD);
10325 }
10326}
10327
10329 if (MD->isInvalidDecl())
10330 return;
10331
10332 if (Diags.isIgnored(diag::warn_overloaded_virtual, MD->getLocation()))
10333 return;
10334
10335 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
10336 FindHiddenVirtualMethods(MD, OverloadedMethods);
10337 if (!OverloadedMethods.empty()) {
10338 Diag(MD->getLocation(), diag::warn_overloaded_virtual)
10339 << MD << (OverloadedMethods.size() > 1);
10340
10341 NoteHiddenVirtualMethods(MD, OverloadedMethods);
10342 }
10343}
10344
10346 auto PrintDiagAndRemoveAttr = [&](unsigned N) {
10347 // No diagnostics if this is a template instantiation.
10349 Diag(RD.getAttr<TrivialABIAttr>()->getLocation(),
10350 diag::ext_cannot_use_trivial_abi) << &RD;
10351 Diag(RD.getAttr<TrivialABIAttr>()->getLocation(),
10352 diag::note_cannot_use_trivial_abi_reason) << &RD << N;
10353 }
10354 RD.dropAttr<TrivialABIAttr>();
10355 };
10356
10357 // Ill-formed if the copy and move constructors are deleted.
10358 auto HasNonDeletedCopyOrMoveConstructor = [&]() {
10359 // If the type is dependent, then assume it might have
10360 // implicit copy or move ctor because we won't know yet at this point.
10361 if (RD.isDependentType())
10362 return true;
10365 return true;
10368 return true;
10369 for (const CXXConstructorDecl *CD : RD.ctors())
10370 if (CD->isCopyOrMoveConstructor() && !CD->isDeleted())
10371 return true;
10372 return false;
10373 };
10374
10375 if (!HasNonDeletedCopyOrMoveConstructor()) {
10376 PrintDiagAndRemoveAttr(0);
10377 return;
10378 }
10379
10380 // Ill-formed if the struct has virtual functions.
10381 if (RD.isPolymorphic()) {
10382 PrintDiagAndRemoveAttr(1);
10383 return;
10384 }
10385
10386 for (const auto &B : RD.bases()) {
10387 // Ill-formed if the base class is non-trivial for the purpose of calls or a
10388 // virtual base.
10389 if (!B.getType()->isDependentType() &&
10390 !B.getType()->getAsCXXRecordDecl()->canPassInRegisters()) {
10391 PrintDiagAndRemoveAttr(2);
10392 return;
10393 }
10394
10395 if (B.isVirtual()) {
10396 PrintDiagAndRemoveAttr(3);
10397 return;
10398 }
10399 }
10400
10401 for (const auto *FD : RD.fields()) {
10402 // Ill-formed if the field is an ObjectiveC pointer or of a type that is
10403 // non-trivial for the purpose of calls.
10404 QualType FT = FD->getType();
10406 PrintDiagAndRemoveAttr(4);
10407 return;
10408 }
10409
10410 if (const auto *RT = FT->getBaseElementTypeUnsafe()->getAs<RecordType>())
10411 if (!RT->isDependentType() &&
10412 !cast<CXXRecordDecl>(RT->getDecl())->canPassInRegisters()) {
10413 PrintDiagAndRemoveAttr(5);
10414 return;
10415 }
10416 }
10417}
10418
10420 CXXRecordDecl &RD) {
10422 diag::err_incomplete_type_vtable_pointer_auth))
10423 return;
10424
10425 const CXXRecordDecl *PrimaryBase = &RD;
10426 if (PrimaryBase->hasAnyDependentBases())
10427 return;
10428
10429 while (1) {
10430 assert(PrimaryBase);
10431 const CXXRecordDecl *Base = nullptr;
10432 for (const CXXBaseSpecifier &BasePtr : PrimaryBase->bases()) {
10433 if (!BasePtr.getType()->getAsCXXRecordDecl()->isDynamicClass())
10434 continue;
10435 Base = BasePtr.getType()->getAsCXXRecordDecl();
10436 break;
10437 }
10438 if (!Base || Base == PrimaryBase || !Base->isPolymorphic())
10439 break;
10440 Diag(RD.getAttr<VTablePointerAuthenticationAttr>()->getLocation(),
10441 diag::err_non_top_level_vtable_pointer_auth)
10442 << &RD << Base;
10443 PrimaryBase = Base;
10444 }
10445
10446 if (!RD.isPolymorphic())
10447 Diag(RD.getAttr<VTablePointerAuthenticationAttr>()->getLocation(),
10448 diag::err_non_polymorphic_vtable_pointer_auth)
10449 << &RD;
10450}
10451
10454 SourceLocation RBrac, const ParsedAttributesView &AttrList) {
10455 if (!TagDecl)
10456 return;
10457
10459
10460 for (const ParsedAttr &AL : AttrList) {
10461 if (AL.getKind() != ParsedAttr::AT_Visibility)
10462 continue;
10463 AL.setInvalid();
10464 Diag(AL.getLoc(), diag::warn_attribute_after_definition_ignored) << AL;
10465 }
10466
10467 ActOnFields(S, RLoc, TagDecl,
10469 // strict aliasing violation!
10470 reinterpret_cast<Decl **>(FieldCollector->getCurFields()),
10471 FieldCollector->getCurNumFields()),
10472 LBrac, RBrac, AttrList);
10473
10474 CheckCompletedCXXClass(S, cast<CXXRecordDecl>(TagDecl));
10475}
10476
10477/// Find the equality comparison functions that should be implicitly declared
10478/// in a given class definition, per C++2a [class.compare.default]p3.
10480 ASTContext &Ctx, CXXRecordDecl *RD,
10482 DeclarationName EqEq = Ctx.DeclarationNames.getCXXOperatorName(OO_EqualEqual);
10483 if (!RD->lookup(EqEq).empty())
10484 // Member operator== explicitly declared: no implicit operator==s.
10485 return;
10486
10487 // Traverse friends looking for an '==' or a '<=>'.
10488 for (FriendDecl *Friend : RD->friends()) {
10489 FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Friend->getFriendDecl());
10490 if (!FD) continue;
10491
10492 if (FD->getOverloadedOperator() == OO_EqualEqual) {
10493 // Friend operator== explicitly declared: no implicit operator==s.
10494 Spaceships.clear();
10495 return;
10496 }
10497
10498 if (FD->getOverloadedOperator() == OO_Spaceship &&
10500 Spaceships.push_back(FD);
10501 }
10502
10503 // Look for members named 'operator<=>'.
10504 DeclarationName Cmp = Ctx.DeclarationNames.getCXXOperatorName(OO_Spaceship);
10505 for (NamedDecl *ND : RD->lookup(Cmp)) {
10506 // Note that we could find a non-function here (either a function template
10507 // or a using-declaration). Neither case results in an implicit
10508 // 'operator=='.
10509 if (auto *FD = dyn_cast<FunctionDecl>(ND))
10510 if (FD->isExplicitlyDefaulted())
10511 Spaceships.push_back(FD);
10512 }
10513}
10514
10516 // Don't add implicit special members to templated classes.
10517 // FIXME: This means unqualified lookups for 'operator=' within a class
10518 // template don't work properly.
10519 if (!ClassDecl->isDependentType()) {
10520 if (ClassDecl->needsImplicitDefaultConstructor()) {
10522
10523 if (ClassDecl->hasInheritedConstructor())
10525 }
10526
10527 if (ClassDecl->needsImplicitCopyConstructor()) {
10529
10530 // If the properties or semantics of the copy constructor couldn't be
10531 // determined while the class was being declared, force a declaration
10532 // of it now.
10534 ClassDecl->hasInheritedConstructor())
10536 // For the MS ABI we need to know whether the copy ctor is deleted. A
10537 // prerequisite for deleting the implicit copy ctor is that the class has
10538 // a move ctor or move assignment that is either user-declared or whose
10539 // semantics are inherited from a subobject. FIXME: We should provide a
10540 // more direct way for CodeGen to ask whether the constructor was deleted.
10541 else if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
10542 (ClassDecl->hasUserDeclaredMoveConstructor() ||
10544 ClassDecl->hasUserDeclaredMoveAssignment() ||
10547 }
10548
10549 if (getLangOpts().CPlusPlus11 &&
10550 ClassDecl->needsImplicitMoveConstructor()) {
10552
10554 ClassDecl->hasInheritedConstructor())
10556 }
10557
10558 if (ClassDecl->needsImplicitCopyAssignment()) {
10560
10561 // If we have a dynamic class, then the copy assignment operator may be
10562 // virtual, so we have to declare it immediately. This ensures that, e.g.,
10563 // it shows up in the right place in the vtable and that we diagnose
10564 // problems with the implicit exception specification.
10565 if (ClassDecl->isDynamicClass() ||
10567 ClassDecl->hasInheritedAssignment())
10569 }
10570
10571 if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveAssignment()) {
10573
10574 // Likewise for the move assignment operator.
10575 if (ClassDecl->isDynamicClass() ||
10577 ClassDecl->hasInheritedAssignment())
10579 }
10580
10581 if (ClassDecl->needsImplicitDestructor()) {
10583
10584 // If we have a dynamic class, then the destructor may be virtual, so we
10585 // have to declare the destructor immediately. This ensures that, e.g., it
10586 // shows up in the right place in the vtable and that we diagnose problems
10587 // with the implicit exception specification.
10588 if (ClassDecl->isDynamicClass() ||
10590 DeclareImplicitDestructor(ClassDecl);
10591 }
10592 }
10593
10594 // C++2a [class.compare.default]p3:
10595 // If the member-specification does not explicitly declare any member or
10596 // friend named operator==, an == operator function is declared implicitly
10597 // for each defaulted three-way comparison operator function defined in
10598 // the member-specification
10599 // FIXME: Consider doing this lazily.
10600 // We do this during the initial parse for a class template, not during
10601 // instantiation, so that we can handle unqualified lookups for 'operator=='
10602 // when parsing the template.
10604 llvm::SmallVector<FunctionDecl *, 4> DefaultedSpaceships;
10606 DefaultedSpaceships);
10607 for (auto *FD : DefaultedSpaceships)
10608 DeclareImplicitEqualityComparison(ClassDecl, FD);
10609 }
10610}
10611
10612unsigned
10614 llvm::function_ref<Scope *()> EnterScope) {
10615 if (!D)
10616 return 0;
10618
10619 // In order to get name lookup right, reenter template scopes in order from
10620 // outermost to innermost.
10622 DeclContext *LookupDC = dyn_cast<DeclContext>(D);
10623
10624 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
10625 for (unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
10626 ParameterLists.push_back(DD->getTemplateParameterList(i));
10627
10628 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
10629 if (FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
10630 ParameterLists.push_back(FTD->getTemplateParameters());
10631 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
10632 LookupDC = VD->getDeclContext();
10633
10635 ParameterLists.push_back(VTD->getTemplateParameters());
10636 else if (auto *PSD = dyn_cast<VarTemplatePartialSpecializationDecl>(D))
10637 ParameterLists.push_back(PSD->getTemplateParameters());
10638 }
10639 } else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
10640 for (unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
10641 ParameterLists.push_back(TD->getTemplateParameterList(i));
10642
10643 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD)) {
10645 ParameterLists.push_back(CTD->getTemplateParameters());
10646 else if (auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
10647 ParameterLists.push_back(PSD->getTemplateParameters());
10648 }
10649 }
10650 // FIXME: Alias declarations and concepts.
10651
10652 unsigned Count = 0;
10653 Scope *InnermostTemplateScope = nullptr;
10654 for (TemplateParameterList *Params : ParameterLists) {
10655 // Ignore explicit specializations; they don't contribute to the template
10656 // depth.
10657 if (Params->size() == 0)
10658 continue;
10659
10660 InnermostTemplateScope = EnterScope();
10661 for (NamedDecl *Param : *Params) {
10662 if (Param->getDeclName()) {
10663 InnermostTemplateScope->AddDecl(Param);
10664 IdResolver.AddDecl(Param);
10665 }
10666 }
10667 ++Count;
10668 }
10669
10670 // Associate the new template scopes with the corresponding entities.
10671 if (InnermostTemplateScope) {
10672 assert(LookupDC && "no enclosing DeclContext for template lookup");
10673 EnterTemplatedContext(InnermostTemplateScope, LookupDC);
10674 }
10675
10676 return Count;
10677}
10678
10680 if (!RecordD) return;
10681 AdjustDeclIfTemplate(RecordD);
10682 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD);
10684}
10685
10687 if (!RecordD) return;
10689}
10690
10692 if (!Param)
10693 return;
10694
10695 S->AddDecl(Param);
10696 if (Param->getDeclName())
10697 IdResolver.AddDecl(Param);
10698}
10699
10701}
10702
10703/// ActOnDelayedCXXMethodParameter - We've already started a delayed
10704/// C++ method declaration. We're (re-)introducing the given
10705/// function parameter into scope for use in parsing later parts of
10706/// the method declaration. For example, we could see an
10707/// ActOnParamDefaultArgument event for this parameter.
10709 if (!ParamD)
10710 return;
10711
10712 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD);
10713
10714 S->AddDecl(Param);
10715 if (Param->getDeclName())
10716 IdResolver.AddDecl(Param);
10717}
10718
10720 if (!MethodD)
10721 return;
10722
10723 AdjustDeclIfTemplate(MethodD);
10724
10725 FunctionDecl *Method = cast<FunctionDecl>(MethodD);
10726
10727 // Now that we have our default arguments, check the constructor
10728 // again. It could produce additional diagnostics or affect whether
10729 // the class has implicitly-declared destructors, among other
10730 // things.
10731 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
10732 CheckConstructor(Constructor);
10733
10734 // Check the default arguments, which we may have added.
10735 if (!Method->isInvalidDecl())
10737}
10738
10739// Emit the given diagnostic for each non-address-space qualifier.
10740// Common part of CheckConstructorDeclarator and CheckDestructorDeclarator.
10741static void checkMethodTypeQualifiers(Sema &S, Declarator &D, unsigned DiagID) {
10742 const DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
10743 if (FTI.hasMethodTypeQualifiers() && !D.isInvalidType()) {
10744 bool DiagOccured = false;
10746 [DiagID, &S, &DiagOccured](DeclSpec::TQ, StringRef QualName,
10747 SourceLocation SL) {
10748 // This diagnostic should be emitted on any qualifier except an addr
10749 // space qualifier. However, forEachQualifier currently doesn't visit
10750 // addr space qualifiers, so there's no way to write this condition
10751 // right now; we just diagnose on everything.
10752 S.Diag(SL, DiagID) << QualName << SourceRange(SL);
10753 DiagOccured = true;
10754 });
10755 if (DiagOccured)
10756 D.setInvalidType();
10757 }
10758}
10759
10761 unsigned Kind) {
10762 if (D.isInvalidType() || D.getNumTypeObjects() <= 1)
10763 return;
10764
10765 DeclaratorChunk &Chunk = D.getTypeObject(D.getNumTypeObjects() - 1);
10766 if (Chunk.Kind == DeclaratorChunk::Paren ||
10768 return;
10769
10770 SourceLocation PointerLoc = Chunk.getSourceRange().getBegin();
10771 S.Diag(PointerLoc, diag::err_invalid_ctor_dtor_decl)
10772 << Kind << Chunk.getSourceRange();
10773 D.setInvalidType();
10774}
10775
10777 StorageClass &SC) {
10778 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
10779
10780 // C++ [class.ctor]p3:
10781 // A constructor shall not be virtual (10.3) or static (9.4). A
10782 // constructor can be invoked for a const, volatile or const
10783 // volatile object. A constructor shall not be declared const,
10784 // volatile, or const volatile (9.3.2).
10785 if (isVirtual) {
10786 if (!D.isInvalidType())
10787 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
10788 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
10789 << SourceRange(D.getIdentifierLoc());
10790 D.setInvalidType();
10791 }
10792 if (SC == SC_Static) {
10793 if (!D.isInvalidType())
10794 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
10795 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
10796 << SourceRange(D.getIdentifierLoc());
10797 D.setInvalidType();
10798 SC = SC_None;
10799 }
10800
10801 if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
10803 diag::err_constructor_return_type, TypeQuals, SourceLocation(),
10804 D.getDeclSpec().getConstSpecLoc(), D.getDeclSpec().getVolatileSpecLoc(),
10805 D.getDeclSpec().getRestrictSpecLoc(),
10806 D.getDeclSpec().getAtomicSpecLoc());
10807 D.setInvalidType();
10808 }
10809
10810 checkMethodTypeQualifiers(*this, D, diag::err_invalid_qualified_constructor);
10811 diagnoseInvalidDeclaratorChunks(*this, D, /*constructor*/ 0);
10812
10813 // C++0x [class.ctor]p4:
10814 // A constructor shall not be declared with a ref-qualifier.
10815 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
10816 if (FTI.hasRefQualifier()) {
10817 Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_constructor)
10820 D.setInvalidType();
10821 }
10822
10823 // Rebuild the function type "R" without any type qualifiers (in
10824 // case any of the errors above fired) and with "void" as the
10825 // return type, since constructors don't have return types.
10826 const FunctionProtoType *Proto = R->castAs<FunctionProtoType>();
10827 if (Proto->getReturnType() == Context.VoidTy && !D.isInvalidType())
10828 return R;
10829
10831 EPI.TypeQuals = Qualifiers();
10832 EPI.RefQualifier = RQ_None;
10833
10834 return Context.getFunctionType(Context.VoidTy, Proto->getParamTypes(), EPI);
10835}
10836
10838 CXXRecordDecl *ClassDecl
10839 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
10840 if (!ClassDecl)
10841 return Constructor->setInvalidDecl();
10842
10843 // C++ [class.copy]p3:
10844 // A declaration of a constructor for a class X is ill-formed if
10845 // its first parameter is of type (optionally cv-qualified) X and
10846 // either there are no other parameters or else all other
10847 // parameters have default arguments.
10848 if (!Constructor->isInvalidDecl() &&
10849 Constructor->hasOneParamOrDefaultArgs() &&
10850 Constructor->getTemplateSpecializationKind() !=
10852 QualType ParamType = Constructor->getParamDecl(0)->getType();
10853 QualType ClassTy = Context.getTagDeclType(ClassDecl);
10854 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
10855 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
10856 const char *ConstRef
10857 = Constructor->getParamDecl(0)->getIdentifier() ? "const &"
10858 : " const &";
10859 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
10860 << FixItHint::CreateInsertion(ParamLoc, ConstRef);
10861
10862 // FIXME: Rather that making the constructor invalid, we should endeavor
10863 // to fix the type.
10864 Constructor->setInvalidDecl();
10865 }
10866 }
10867}
10868
10870 CXXRecordDecl *RD = Destructor->getParent();
10871
10872 if (!Destructor->getOperatorDelete() && Destructor->isVirtual()) {
10874
10875 if (!Destructor->isImplicit())
10876 Loc = Destructor->getLocation();
10877 else
10878 Loc = RD->getLocation();
10879
10880 // If we have a virtual destructor, look up the deallocation function
10881 if (FunctionDecl *OperatorDelete =
10883 Expr *ThisArg = nullptr;
10884
10885 // If the notional 'delete this' expression requires a non-trivial
10886 // conversion from 'this' to the type of a destroying operator delete's
10887 // first parameter, perform that conversion now.
10888 if (OperatorDelete->isDestroyingOperatorDelete()) {
10889 QualType ParamType = OperatorDelete->getParamDecl(0)->getType();
10890 if (!declaresSameEntity(ParamType->getAsCXXRecordDecl(), RD)) {
10891 // C++ [class.dtor]p13:
10892 // ... as if for the expression 'delete this' appearing in a
10893 // non-virtual destructor of the destructor's class.
10894 ContextRAII SwitchContext(*this, Destructor);
10895 ExprResult This =
10896 ActOnCXXThis(OperatorDelete->getParamDecl(0)->getLocation());
10897 assert(!This.isInvalid() && "couldn't form 'this' expr in dtor?");
10898 This = PerformImplicitConversion(This.get(), ParamType,
10900 if (This.isInvalid()) {
10901 // FIXME: Register this as a context note so that it comes out
10902 // in the right order.
10903 Diag(Loc, diag::note_implicit_delete_this_in_destructor_here);
10904 return true;
10905 }
10906 ThisArg = This.get();
10907 }
10908 }
10909
10910 DiagnoseUseOfDecl(OperatorDelete, Loc);
10911 MarkFunctionReferenced(Loc, OperatorDelete);
10912 Destructor->setOperatorDelete(OperatorDelete, ThisArg);
10913 }
10914 }
10915
10916 return false;
10917}
10918
10920 StorageClass& SC) {
10921 // C++ [class.dtor]p1:
10922 // [...] A typedef-name that names a class is a class-name
10923 // (7.1.3); however, a typedef-name that names a class shall not
10924 // be used as the identifier in the declarator for a destructor
10925 // declaration.
10926 QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
10927 if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
10928 Diag(D.getIdentifierLoc(), diag::ext_destructor_typedef_name)
10929 << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
10930 else if (const TemplateSpecializationType *TST =
10931 DeclaratorType->getAs<TemplateSpecializationType>())
10932 if (TST->isTypeAlias())
10933 Diag(D.getIdentifierLoc(), diag::ext_destructor_typedef_name)
10934 << DeclaratorType << 1;
10935
10936 // C++ [class.dtor]p2:
10937 // A destructor is used to destroy objects of its class type. A
10938 // destructor takes no parameters, and no return type can be
10939 // specified for it (not even void). The address of a destructor
10940 // shall not be taken. A destructor shall not be static. A
10941 // destructor can be invoked for a const, volatile or const
10942 // volatile object. A destructor shall not be declared const,
10943 // volatile or const volatile (9.3.2).
10944 if (SC == SC_Static) {
10945 if (!D.isInvalidType())
10946 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
10947 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
10948 << SourceRange(D.getIdentifierLoc())
10949 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
10950
10951 SC = SC_None;
10952 }
10953 if (!D.isInvalidType()) {
10954 // Destructors don't have return types, but the parser will
10955 // happily parse something like:
10956 //
10957 // class X {
10958 // float ~X();
10959 // };
10960 //
10961 // The return type will be eliminated later.
10962 if (D.getDeclSpec().hasTypeSpecifier())
10963 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
10964 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
10965 << SourceRange(D.getIdentifierLoc());
10966 else if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
10967 diagnoseIgnoredQualifiers(diag::err_destructor_return_type, TypeQuals,
10969 D.getDeclSpec().getConstSpecLoc(),
10970 D.getDeclSpec().getVolatileSpecLoc(),
10971 D.getDeclSpec().getRestrictSpecLoc(),
10972 D.getDeclSpec().getAtomicSpecLoc());
10973 D.setInvalidType();
10974 }
10975 }
10976
10977 checkMethodTypeQualifiers(*this, D, diag::err_invalid_qualified_destructor);
10978 diagnoseInvalidDeclaratorChunks(*this, D, /*destructor*/ 1);
10979
10980 // C++0x [class.dtor]p2:
10981 // A destructor shall not be declared with a ref-qualifier.
10982 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
10983 if (FTI.hasRefQualifier()) {
10984 Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_destructor)
10987 D.setInvalidType();
10988 }
10989
10990 // Make sure we don't have any parameters.
10991 if (FTIHasNonVoidParameters(FTI)) {
10992 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
10993
10994 // Delete the parameters.
10995 FTI.freeParams();
10996 D.setInvalidType();
10997 }
10998
10999 // Make sure the destructor isn't variadic.
11000 if (FTI.isVariadic) {
11001 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
11002 D.setInvalidType();
11003 }
11004
11005 // Rebuild the function type "R" without any type qualifiers or
11006 // parameters (in case any of the errors above fired) and with
11007 // "void" as the return type, since destructors don't have return
11008 // types.
11009 if (!D.isInvalidType())
11010 return R;
11011
11012 const FunctionProtoType *Proto = R->castAs<FunctionProtoType>();
11014 EPI.Variadic = false;
11015 EPI.TypeQuals = Qualifiers();
11016 EPI.RefQualifier = RQ_None;
11017 return Context.getFunctionType(Context.VoidTy, {}, EPI);
11018}
11019
11020static void extendLeft(SourceRange &R, SourceRange Before) {
11021 if (Before.isInvalid())
11022 return;
11023 R.setBegin(Before.getBegin());
11024 if (R.getEnd().isInvalid())
11025 R.setEnd(Before.getEnd());
11026}
11027
11028static void extendRight(SourceRange &R, SourceRange After) {
11029 if (After.isInvalid())
11030 return;
11031 if (R.getBegin().isInvalid())
11032 R.setBegin(After.getBegin());
11033 R.setEnd(After.getEnd());
11034}
11035
11037 StorageClass& SC) {
11038 // C++ [class.conv.fct]p1:
11039 // Neither parameter types nor return type can be specified. The
11040 // type of a conversion function (8.3.5) is "function taking no
11041 // parameter returning conversion-type-id."
11042 if (SC == SC_Static) {
11043 if (!D.isInvalidType())
11044 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
11045 << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
11046 << D.getName().getSourceRange();
11047 D.setInvalidType();
11048 SC = SC_None;
11049 }
11050
11051 TypeSourceInfo *ConvTSI = nullptr;
11052 QualType ConvType =
11053 GetTypeFromParser(D.getName().ConversionFunctionId, &ConvTSI);
11054
11055 const DeclSpec &DS = D.getDeclSpec();
11056 if (DS.hasTypeSpecifier() && !D.isInvalidType()) {
11057 // Conversion functions don't have return types, but the parser will
11058 // happily parse something like:
11059 //
11060 // class X {
11061 // float operator bool();
11062 // };
11063 //
11064 // The return type will be changed later anyway.
11065 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
11067 << SourceRange(D.getIdentifierLoc());
11068 D.setInvalidType();
11069 } else if (DS.getTypeQualifiers() && !D.isInvalidType()) {
11070 // It's also plausible that the user writes type qualifiers in the wrong
11071 // place, such as:
11072 // struct S { const operator int(); };
11073 // FIXME: we could provide a fixit to move the qualifiers onto the
11074 // conversion type.
11075 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_complex_decl)
11076 << SourceRange(D.getIdentifierLoc()) << 0;
11077 D.setInvalidType();
11078 }
11079 const auto *Proto = R->castAs<FunctionProtoType>();
11080 // Make sure we don't have any parameters.
11081 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
11082 unsigned NumParam = Proto->getNumParams();
11083
11084 // [C++2b]
11085 // A conversion function shall have no non-object parameters.
11086 if (NumParam == 1) {
11087 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
11088 if (const auto *First =
11089 dyn_cast_if_present<ParmVarDecl>(FTI.Params[0].Param);
11090 First && First->isExplicitObjectParameter())
11091 NumParam--;
11092 }
11093
11094 if (NumParam != 0) {
11095 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
11096 // Delete the parameters.
11097 FTI.freeParams();
11098 D.setInvalidType();
11099 } else if (Proto->isVariadic()) {
11100 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
11101 D.setInvalidType();
11102 }
11103
11104 // Diagnose "&operator bool()" and other such nonsense. This
11105 // is actually a gcc extension which we don't support.
11106 if (Proto->getReturnType() != ConvType) {
11107 bool NeedsTypedef = false;
11108 SourceRange Before, After;
11109
11110 // Walk the chunks and extract information on them for our diagnostic.
11111 bool PastFunctionChunk = false;
11112 for (auto &Chunk : D.type_objects()) {
11113 switch (Chunk.Kind) {
11115 if (!PastFunctionChunk) {
11116 if (Chunk.Fun.HasTrailingReturnType) {
11117 TypeSourceInfo *TRT = nullptr;
11118 GetTypeFromParser(Chunk.Fun.getTrailingReturnType(), &TRT);
11119 if (TRT) extendRight(After, TRT->getTypeLoc().getSourceRange());
11120 }
11121 PastFunctionChunk = true;
11122 break;
11123 }
11124 [[fallthrough]];
11126 NeedsTypedef = true;
11127 extendRight(After, Chunk.getSourceRange());
11128 break;
11129
11135 extendLeft(Before, Chunk.getSourceRange());
11136 break;
11137
11139 extendLeft(Before, Chunk.Loc);
11140 extendRight(After, Chunk.EndLoc);
11141 break;
11142 }
11143 }
11144
11145 SourceLocation Loc = Before.isValid() ? Before.getBegin() :
11146 After.isValid() ? After.getBegin() :
11147 D.getIdentifierLoc();
11148 auto &&DB = Diag(Loc, diag::err_conv_function_with_complex_decl);
11149 DB << Before << After;
11150
11151 if (!NeedsTypedef) {
11152 DB << /*don't need a typedef*/0;
11153
11154 // If we can provide a correct fix-it hint, do so.
11155 if (After.isInvalid() && ConvTSI) {
11156 SourceLocation InsertLoc =
11158 DB << FixItHint::CreateInsertion(InsertLoc, " ")
11160 InsertLoc, CharSourceRange::getTokenRange(Before))
11161 << FixItHint::CreateRemoval(Before);
11162 }
11163 } else if (!Proto->getReturnType()->isDependentType()) {
11164 DB << /*typedef*/1 << Proto->getReturnType();
11165 } else if (getLangOpts().CPlusPlus11) {
11166 DB << /*alias template*/2 << Proto->getReturnType();
11167 } else {
11168 DB << /*might not be fixable*/3;
11169 }
11170
11171 // Recover by incorporating the other type chunks into the result type.
11172 // Note, this does *not* change the name of the function. This is compatible
11173 // with the GCC extension:
11174 // struct S { &operator int(); } s;
11175 // int &r = s.operator int(); // ok in GCC
11176 // S::operator int&() {} // error in GCC, function name is 'operator int'.
11177 ConvType = Proto->getReturnType();
11178 }
11179
11180 // C++ [class.conv.fct]p4:
11181 // The conversion-type-id shall not represent a function type nor
11182 // an array type.
11183 if (ConvType->isArrayType()) {
11184 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
11185 ConvType = Context.getPointerType(ConvType);
11186 D.setInvalidType();
11187 } else if (ConvType->isFunctionType()) {
11188 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
11189 ConvType = Context.getPointerType(ConvType);
11190 D.setInvalidType();
11191 }
11192
11193 // Rebuild the function type "R" without any parameters (in case any
11194 // of the errors above fired) and with the conversion type as the
11195 // return type.
11196 if (D.isInvalidType())
11197 R = Context.getFunctionType(ConvType, {}, Proto->getExtProtoInfo());
11198
11199 // C++0x explicit conversion operators.
11203 ? diag::warn_cxx98_compat_explicit_conversion_functions
11204 : diag::ext_explicit_conversion_functions)
11206}
11207
11209 assert(Conversion && "Expected to receive a conversion function declaration");
11210
11211 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
11212
11213 // Make sure we aren't redeclaring the conversion function.
11214 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
11215 // C++ [class.conv.fct]p1:
11216 // [...] A conversion function is never used to convert a
11217 // (possibly cv-qualified) object to the (possibly cv-qualified)
11218 // same object type (or a reference to it), to a (possibly
11219 // cv-qualified) base class of that type (or a reference to it),
11220 // or to (possibly cv-qualified) void.
11221 QualType ClassType
11223 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
11224 ConvType = ConvTypeRef->getPointeeType();
11225 if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared &&
11227 /* Suppress diagnostics for instantiations. */;
11228 else if (Conversion->size_overridden_methods() != 0)
11229 /* Suppress diagnostics for overriding virtual function in a base class. */;
11230 else if (ConvType->isRecordType()) {
11231 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
11232 if (ConvType == ClassType)
11233 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
11234 << ClassType;
11235 else if (IsDerivedFrom(Conversion->getLocation(), ClassType, ConvType))
11236 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
11237 << ClassType << ConvType;
11238 } else if (ConvType->isVoidType()) {
11239 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
11240 << ClassType << ConvType;
11241 }
11242
11243 if (FunctionTemplateDecl *ConversionTemplate =
11244 Conversion->getDescribedFunctionTemplate()) {
11245 if (const auto *ConvTypePtr = ConvType->getAs<PointerType>()) {
11246 ConvType = ConvTypePtr->getPointeeType();
11247 }
11248 if (ConvType->isUndeducedAutoType()) {
11249 Diag(Conversion->getTypeSpecStartLoc(), diag::err_auto_not_allowed)
11250 << getReturnTypeLoc(Conversion).getSourceRange()
11251 << llvm::to_underlying(ConvType->castAs<AutoType>()->getKeyword())
11252 << /* in declaration of conversion function template= */ 24;
11253 }
11254
11255 return ConversionTemplate;
11256 }
11257
11258 return Conversion;
11259}
11260
11262 DeclarationName Name, QualType R) {
11263 CheckExplicitObjectMemberFunction(D, Name, R, false, DC);
11264}
11265
11267 CheckExplicitObjectMemberFunction(D, {}, {}, true);
11268}
11269
11271 DeclarationName Name, QualType R,
11272 bool IsLambda, DeclContext *DC) {
11273 if (!D.isFunctionDeclarator())
11274 return;
11275
11276 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
11277 if (FTI.NumParams == 0)
11278 return;
11279 ParmVarDecl *ExplicitObjectParam = nullptr;
11280 for (unsigned Idx = 0; Idx < FTI.NumParams; Idx++) {
11281 const auto &ParamInfo = FTI.Params[Idx];
11282 if (!ParamInfo.Param)
11283 continue;
11284 ParmVarDecl *Param = cast<ParmVarDecl>(ParamInfo.Param);
11285 if (!Param->isExplicitObjectParameter())
11286 continue;
11287 if (Idx == 0) {
11288 ExplicitObjectParam = Param;
11289 continue;
11290 } else {
11291 Diag(Param->getLocation(),
11292 diag::err_explicit_object_parameter_must_be_first)
11293 << IsLambda << Param->getSourceRange();
11294 }
11295 }
11296 if (!ExplicitObjectParam)
11297 return;
11298
11299 if (ExplicitObjectParam->hasDefaultArg()) {
11300 Diag(ExplicitObjectParam->getLocation(),
11301 diag::err_explicit_object_default_arg)
11302 << ExplicitObjectParam->getSourceRange();
11303 }
11304
11305 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static ||
11306 (D.getContext() == clang::DeclaratorContext::Member &&
11307 D.isStaticMember())) {
11308 Diag(ExplicitObjectParam->getBeginLoc(),
11309 diag::err_explicit_object_parameter_nonmember)
11310 << D.getSourceRange() << /*static=*/0 << IsLambda;
11311 D.setInvalidType();
11312 }
11313
11314 if (D.getDeclSpec().isVirtualSpecified()) {
11315 Diag(ExplicitObjectParam->getBeginLoc(),
11316 diag::err_explicit_object_parameter_nonmember)
11317 << D.getSourceRange() << /*virtual=*/1 << IsLambda;
11318 D.setInvalidType();
11319 }
11320
11321 // Friend declarations require some care. Consider:
11322 //
11323 // namespace N {
11324 // struct A{};
11325 // int f(A);
11326 // }
11327 //
11328 // struct S {
11329 // struct T {
11330 // int f(this T);
11331 // };
11332 //
11333 // friend int T::f(this T); // Allow this.
11334 // friend int f(this S); // But disallow this.
11335 // friend int N::f(this A); // And disallow this.
11336 // };
11337 //
11338 // Here, it seems to suffice to check whether the scope
11339 // specifier designates a class type.
11340 if (D.getDeclSpec().isFriendSpecified() &&
11341 !isa_and_present<CXXRecordDecl>(
11342 computeDeclContext(D.getCXXScopeSpec()))) {
11343 Diag(ExplicitObjectParam->getBeginLoc(),
11344 diag::err_explicit_object_parameter_nonmember)
11345 << D.getSourceRange() << /*non-member=*/2 << IsLambda;
11346 D.setInvalidType();
11347 }
11348
11349 if (IsLambda && FTI.hasMutableQualifier()) {
11350 Diag(ExplicitObjectParam->getBeginLoc(),
11351 diag::err_explicit_object_parameter_mutable)
11352 << D.getSourceRange();
11353 }
11354
11355 if (IsLambda)
11356 return;
11357
11358 if (!DC || !DC->isRecord()) {
11359 assert(D.isInvalidType() && "Explicit object parameter in non-member "
11360 "should have been diagnosed already");
11361 return;
11362 }
11363
11364 // CWG2674: constructors and destructors cannot have explicit parameters.
11365 if (Name.getNameKind() == DeclarationName::CXXConstructorName ||
11366 Name.getNameKind() == DeclarationName::CXXDestructorName) {
11367 Diag(ExplicitObjectParam->getBeginLoc(),
11368 diag::err_explicit_object_parameter_constructor)
11369 << (Name.getNameKind() == DeclarationName::CXXDestructorName)
11370 << D.getSourceRange();
11371 D.setInvalidType();
11372 }
11373}
11374
11375namespace {
11376/// Utility class to accumulate and print a diagnostic listing the invalid
11377/// specifier(s) on a declaration.
11378struct BadSpecifierDiagnoser {
11379 BadSpecifierDiagnoser(Sema &S, SourceLocation Loc, unsigned DiagID)
11380 : S(S), Diagnostic(S.Diag(Loc, DiagID)) {}
11381 ~BadSpecifierDiagnoser() {
11382 Diagnostic << Specifiers;
11383 }
11384
11385 template<typename T> void check(SourceLocation SpecLoc, T Spec) {
11386 return check(SpecLoc, DeclSpec::getSpecifierName(Spec));
11387 }
11388 void check(SourceLocation SpecLoc, DeclSpec::TST Spec) {
11389 return check(SpecLoc,
11391 }
11392 void check(SourceLocation SpecLoc, const char *Spec) {
11393 if (SpecLoc.isInvalid()) return;
11394 Diagnostic << SourceRange(SpecLoc, SpecLoc);
11395 if (!Specifiers.empty()) Specifiers += " ";
11396 Specifiers += Spec;
11397 }
11398
11399 Sema &S;
11401 std::string Specifiers;
11402};
11403}
11404
11406 StorageClass &SC) {
11407 TemplateName GuidedTemplate = D.getName().TemplateName.get().get();
11408 TemplateDecl *GuidedTemplateDecl = GuidedTemplate.getAsTemplateDecl();
11409 assert(GuidedTemplateDecl && "missing template decl for deduction guide");
11410
11411 // C++ [temp.deduct.guide]p3:
11412 // A deduction-gide shall be declared in the same scope as the
11413 // corresponding class template.
11415 GuidedTemplateDecl->getDeclContext()->getRedeclContext())) {
11416 Diag(D.getIdentifierLoc(), diag::err_deduction_guide_wrong_scope)
11417 << GuidedTemplateDecl;
11418 NoteTemplateLocation(*GuidedTemplateDecl);
11419 }
11420
11421 auto &DS = D.getMutableDeclSpec();
11422 // We leave 'friend' and 'virtual' to be rejected in the normal way.
11423 if (DS.hasTypeSpecifier() || DS.getTypeQualifiers() ||
11424 DS.getStorageClassSpecLoc().isValid() || DS.isInlineSpecified() ||
11425 DS.isNoreturnSpecified() || DS.hasConstexprSpecifier()) {
11426 BadSpecifierDiagnoser Diagnoser(
11427 *this, D.getIdentifierLoc(),
11428 diag::err_deduction_guide_invalid_specifier);
11429
11430 Diagnoser.check(DS.getStorageClassSpecLoc(), DS.getStorageClassSpec());
11431 DS.ClearStorageClassSpecs();
11432 SC = SC_None;
11433
11434 // 'explicit' is permitted.
11435 Diagnoser.check(DS.getInlineSpecLoc(), "inline");
11436 Diagnoser.check(DS.getNoreturnSpecLoc(), "_Noreturn");
11437 Diagnoser.check(DS.getConstexprSpecLoc(), "constexpr");
11438 DS.ClearConstexprSpec();
11439
11440 Diagnoser.check(DS.getConstSpecLoc(), "const");
11441 Diagnoser.check(DS.getRestrictSpecLoc(), "__restrict");
11442 Diagnoser.check(DS.getVolatileSpecLoc(), "volatile");
11443 Diagnoser.check(DS.getAtomicSpecLoc(), "_Atomic");
11444 Diagnoser.check(DS.getUnalignedSpecLoc(), "__unaligned");
11445 DS.ClearTypeQualifiers();
11446
11447 Diagnoser.check(DS.getTypeSpecComplexLoc(), DS.getTypeSpecComplex());
11448 Diagnoser.check(DS.getTypeSpecSignLoc(), DS.getTypeSpecSign());
11449 Diagnoser.check(DS.getTypeSpecWidthLoc(), DS.getTypeSpecWidth());
11450 Diagnoser.check(DS.getTypeSpecTypeLoc(), DS.getTypeSpecType());
11451 DS.ClearTypeSpecType();
11452 }
11453
11454 if (D.isInvalidType())
11455 return true;
11456
11457 // Check the declarator is simple enough.
11458 bool FoundFunction = false;
11459 for (const DeclaratorChunk &Chunk : llvm::reverse(D.type_objects())) {
11460 if (Chunk.Kind == DeclaratorChunk::Paren)
11461 continue;
11462 if (Chunk.Kind != DeclaratorChunk::Function || FoundFunction) {
11463 Diag(D.getDeclSpec().getBeginLoc(),
11464 diag::err_deduction_guide_with_complex_decl)
11465 << D.getSourceRange();
11466 break;
11467 }
11468 if (!Chunk.Fun.hasTrailingReturnType())
11469 return Diag(D.getName().getBeginLoc(),
11470 diag::err_deduction_guide_no_trailing_return_type);
11471
11472 // Check that the return type is written as a specialization of
11473 // the template specified as the deduction-guide's name.
11474 // The template name may not be qualified. [temp.deduct.guide]
11475 ParsedType TrailingReturnType = Chunk.Fun.getTrailingReturnType();
11476 TypeSourceInfo *TSI = nullptr;
11477 QualType RetTy = GetTypeFromParser(TrailingReturnType, &TSI);
11478 assert(TSI && "deduction guide has valid type but invalid return type?");
11479 bool AcceptableReturnType = false;
11480 bool MightInstantiateToSpecialization = false;
11481 if (auto RetTST =
11483 TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
11484 bool TemplateMatches = Context.hasSameTemplateName(
11485 SpecifiedName, GuidedTemplate, /*IgnoreDeduced=*/true);
11486
11488 SpecifiedName.getAsQualifiedTemplateName();
11489 assert(Qualifiers && "expected QualifiedTemplate");
11490 bool SimplyWritten = !Qualifiers->hasTemplateKeyword() &&
11491 Qualifiers->getQualifier() == nullptr;
11492 if (SimplyWritten && TemplateMatches)
11493 AcceptableReturnType = true;
11494 else {
11495 // This could still instantiate to the right type, unless we know it
11496 // names the wrong class template.
11497 auto *TD = SpecifiedName.getAsTemplateDecl();
11498 MightInstantiateToSpecialization =
11499 !(TD && isa<ClassTemplateDecl>(TD) && !TemplateMatches);
11500 }
11501 } else if (!RetTy.hasQualifiers() && RetTy->isDependentType()) {
11502 MightInstantiateToSpecialization = true;
11503 }
11504
11505 if (!AcceptableReturnType)
11506 return Diag(TSI->getTypeLoc().getBeginLoc(),
11507 diag::err_deduction_guide_bad_trailing_return_type)
11508 << GuidedTemplate << TSI->getType()
11509 << MightInstantiateToSpecialization
11510 << TSI->getTypeLoc().getSourceRange();
11511
11512 // Keep going to check that we don't have any inner declarator pieces (we
11513 // could still have a function returning a pointer to a function).
11514 FoundFunction = true;
11515 }
11516
11517 if (D.isFunctionDefinition())
11518 // we can still create a valid deduction guide here.
11519 Diag(D.getIdentifierLoc(), diag::err_deduction_guide_defines_function);
11520 return false;
11521}
11522
11523//===----------------------------------------------------------------------===//
11524// Namespace Handling
11525//===----------------------------------------------------------------------===//
11526
11527/// Diagnose a mismatch in 'inline' qualifiers when a namespace is
11528/// reopened.
11531 IdentifierInfo *II, bool *IsInline,
11532 NamespaceDecl *PrevNS) {
11533 assert(*IsInline != PrevNS->isInline());
11534
11535 // 'inline' must appear on the original definition, but not necessarily
11536 // on all extension definitions, so the note should point to the first
11537 // definition to avoid confusion.
11538 PrevNS = PrevNS->getFirstDecl();
11539
11540 if (PrevNS->isInline())
11541 // The user probably just forgot the 'inline', so suggest that it
11542 // be added back.
11543 S.Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
11544 << FixItHint::CreateInsertion(KeywordLoc, "inline ");
11545 else
11546 S.Diag(Loc, diag::err_inline_namespace_mismatch);
11547
11548 S.Diag(PrevNS->getLocation(), diag::note_previous_definition);
11549 *IsInline = PrevNS->isInline();
11550}
11551
11552/// ActOnStartNamespaceDef - This is called at the start of a namespace
11553/// definition.
11555 SourceLocation InlineLoc,
11556 SourceLocation NamespaceLoc,
11557 SourceLocation IdentLoc, IdentifierInfo *II,
11558 SourceLocation LBrace,
11559 const ParsedAttributesView &AttrList,
11560 UsingDirectiveDecl *&UD, bool IsNested) {
11561 SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc;
11562 // For anonymous namespace, take the location of the left brace.
11563 SourceLocation Loc = II ? IdentLoc : LBrace;
11564 bool IsInline = InlineLoc.isValid();
11565 bool IsInvalid = false;
11566 bool IsStd = false;
11567 bool AddToKnown = false;
11568 Scope *DeclRegionScope = NamespcScope->getParent();
11569
11570 NamespaceDecl *PrevNS = nullptr;
11571 if (II) {
11572 // C++ [namespace.std]p7:
11573 // A translation unit shall not declare namespace std to be an inline
11574 // namespace (9.8.2).
11575 //
11576 // Precondition: the std namespace is in the file scope and is declared to
11577 // be inline
11578 auto DiagnoseInlineStdNS = [&]() {
11579 assert(IsInline && II->isStr("std") &&
11581 "Precondition of DiagnoseInlineStdNS not met");
11582 Diag(InlineLoc, diag::err_inline_namespace_std)
11583 << SourceRange(InlineLoc, InlineLoc.getLocWithOffset(6));
11584 IsInline = false;
11585 };
11586 // C++ [namespace.def]p2:
11587 // The identifier in an original-namespace-definition shall not
11588 // have been previously defined in the declarative region in
11589 // which the original-namespace-definition appears. The
11590 // identifier in an original-namespace-definition is the name of
11591 // the namespace. Subsequently in that declarative region, it is
11592 // treated as an original-namespace-name.
11593 //
11594 // Since namespace names are unique in their scope, and we don't
11595 // look through using directives, just look for any ordinary names
11596 // as if by qualified name lookup.
11597 LookupResult R(*this, II, IdentLoc, LookupOrdinaryName,
11598 RedeclarationKind::ForExternalRedeclaration);
11600 NamedDecl *PrevDecl =
11601 R.isSingleResult() ? R.getRepresentativeDecl() : nullptr;
11602 PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
11603
11604 if (PrevNS) {
11605 // This is an extended namespace definition.
11606 if (IsInline && II->isStr("std") &&
11608 DiagnoseInlineStdNS();
11609 else if (IsInline != PrevNS->isInline())
11610 DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, Loc, II,
11611 &IsInline, PrevNS);
11612 } else if (PrevDecl) {
11613 // This is an invalid name redefinition.
11614 Diag(Loc, diag::err_redefinition_different_kind)
11615 << II;
11616 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
11617 IsInvalid = true;
11618 // Continue on to push Namespc as current DeclContext and return it.
11619 } else if (II->isStr("std") &&
11621 if (IsInline)
11622 DiagnoseInlineStdNS();
11623 // This is the first "real" definition of the namespace "std", so update
11624 // our cache of the "std" namespace to point at this definition.
11625 PrevNS = getStdNamespace();
11626 IsStd = true;
11627 AddToKnown = !IsInline;
11628 } else {
11629 // We've seen this namespace for the first time.
11630 AddToKnown = !IsInline;
11631 }
11632 } else {
11633 // Anonymous namespaces.
11634
11635 // Determine whether the parent already has an anonymous namespace.
11637 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
11638 PrevNS = TU->getAnonymousNamespace();
11639 } else {
11640 NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
11641 PrevNS = ND->getAnonymousNamespace();
11642 }
11643
11644 if (PrevNS && IsInline != PrevNS->isInline())
11645 DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, NamespaceLoc, II,
11646 &IsInline, PrevNS);
11647 }
11648
11650 Context, CurContext, IsInline, StartLoc, Loc, II, PrevNS, IsNested);
11651 if (IsInvalid)
11652 Namespc->setInvalidDecl();
11653
11654 ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
11655 AddPragmaAttributes(DeclRegionScope, Namespc);
11656 ProcessAPINotes(Namespc);
11657
11658 // FIXME: Should we be merging attributes?
11659 if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
11661
11662 if (IsStd)
11663 StdNamespace = Namespc;
11664 if (AddToKnown)
11665 KnownNamespaces[Namespc] = false;
11666
11667 if (II) {
11668 PushOnScopeChains(Namespc, DeclRegionScope);
11669 } else {
11670 // Link the anonymous namespace into its parent.
11672 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
11673 TU->setAnonymousNamespace(Namespc);
11674 } else {
11675 cast<NamespaceDecl>(Parent)->setAnonymousNamespace(Namespc);
11676 }
11677
11678 CurContext->addDecl(Namespc);
11679
11680 // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
11681 // behaves as if it were replaced by
11682 // namespace unique { /* empty body */ }
11683 // using namespace unique;
11684 // namespace unique { namespace-body }
11685 // where all occurrences of 'unique' in a translation unit are
11686 // replaced by the same identifier and this identifier differs
11687 // from all other identifiers in the entire program.
11688
11689 // We just create the namespace with an empty name and then add an
11690 // implicit using declaration, just like the standard suggests.
11691 //
11692 // CodeGen enforces the "universally unique" aspect by giving all
11693 // declarations semantically contained within an anonymous
11694 // namespace internal linkage.
11695
11696 if (!PrevNS) {
11698 /* 'using' */ LBrace,
11699 /* 'namespace' */ SourceLocation(),
11700 /* qualifier */ NestedNameSpecifierLoc(),
11701 /* identifier */ SourceLocation(),
11702 Namespc,
11703 /* Ancestor */ Parent);
11704 UD->setImplicit();
11705 Parent->addDecl(UD);
11706 }
11707 }
11708
11709 ActOnDocumentableDecl(Namespc);
11710
11711 // Although we could have an invalid decl (i.e. the namespace name is a
11712 // redefinition), push it as current DeclContext and try to continue parsing.
11713 // FIXME: We should be able to push Namespc here, so that the each DeclContext
11714 // for the namespace has the declarations that showed up in that particular
11715 // namespace definition.
11716 PushDeclContext(NamespcScope, Namespc);
11717 return Namespc;
11718}
11719
11720/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
11721/// is a namespace alias, returns the namespace it points to.
11723 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
11724 return AD->getNamespace();
11725 return dyn_cast_or_null<NamespaceDecl>(D);
11726}
11727
11729 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
11730 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
11731 Namespc->setRBraceLoc(RBrace);
11733 if (Namespc->hasAttr<VisibilityAttr>())
11734 PopPragmaVisibility(true, RBrace);
11735 // If this namespace contains an export-declaration, export it now.
11736 if (DeferredExportedNamespaces.erase(Namespc))
11738}
11739
11741 return cast_or_null<CXXRecordDecl>(
11743}
11744
11746 return cast_or_null<EnumDecl>(StdAlignValT.get(Context.getExternalSource()));
11747}
11748
11750 return cast_or_null<NamespaceDecl>(
11752}
11753namespace {
11754
11755enum UnsupportedSTLSelect {
11756 USS_InvalidMember,
11757 USS_MissingMember,
11758 USS_NonTrivial,
11759 USS_Other
11760};
11761
11762struct InvalidSTLDiagnoser {
11763 Sema &S;
11765 QualType TyForDiags;
11766
11767 QualType operator()(UnsupportedSTLSelect Sel = USS_Other, StringRef Name = "",
11768 const VarDecl *VD = nullptr) {
11769 {
11770 auto D = S.Diag(Loc, diag::err_std_compare_type_not_supported)
11771 << TyForDiags << ((int)Sel);
11772 if (Sel == USS_InvalidMember || Sel == USS_MissingMember) {
11773 assert(!Name.empty());
11774 D << Name;
11775 }
11776 }
11777 if (Sel == USS_InvalidMember) {
11778 S.Diag(VD->getLocation(), diag::note_var_declared_here)
11779 << VD << VD->getSourceRange();
11780 }
11781 return QualType();
11782 }
11783};
11784} // namespace
11785
11789 assert(getLangOpts().CPlusPlus &&
11790 "Looking for comparison category type outside of C++.");
11791
11792 // Use an elaborated type for diagnostics which has a name containing the
11793 // prepended 'std' namespace but not any inline namespace names.
11794 auto TyForDiags = [&](ComparisonCategoryInfo *Info) {
11795 auto *NNS =
11798 Info->getType());
11799 };
11800
11801 // Check if we've already successfully checked the comparison category type
11802 // before. If so, skip checking it again.
11804 if (Info && FullyCheckedComparisonCategories[static_cast<unsigned>(Kind)]) {
11805 // The only thing we need to check is that the type has a reachable
11806 // definition in the current context.
11807 if (RequireCompleteType(Loc, TyForDiags(Info), diag::err_incomplete_type))
11808 return QualType();
11809
11810 return Info->getType();
11811 }
11812
11813 // If lookup failed
11814 if (!Info) {
11815 std::string NameForDiags = "std::";
11816 NameForDiags += ComparisonCategories::getCategoryString(Kind);
11817 Diag(Loc, diag::err_implied_comparison_category_type_not_found)
11818 << NameForDiags << (int)Usage;
11819 return QualType();
11820 }
11821
11822 assert(Info->Kind == Kind);
11823 assert(Info->Record);
11824
11825 // Update the Record decl in case we encountered a forward declaration on our
11826 // first pass. FIXME: This is a bit of a hack.
11827 if (Info->Record->hasDefinition())
11828 Info->Record = Info->Record->getDefinition();
11829
11830 if (RequireCompleteType(Loc, TyForDiags(Info), diag::err_incomplete_type))
11831 return QualType();
11832
11833 InvalidSTLDiagnoser UnsupportedSTLError{*this, Loc, TyForDiags(Info)};
11834
11835 if (!Info->Record->isTriviallyCopyable())
11836 return UnsupportedSTLError(USS_NonTrivial);
11837
11838 for (const CXXBaseSpecifier &BaseSpec : Info->Record->bases()) {
11839 CXXRecordDecl *Base = BaseSpec.getType()->getAsCXXRecordDecl();
11840 // Tolerate empty base classes.
11841 if (Base->isEmpty())
11842 continue;
11843 // Reject STL implementations which have at least one non-empty base.
11844 return UnsupportedSTLError();
11845 }
11846
11847 // Check that the STL has implemented the types using a single integer field.
11848 // This expectation allows better codegen for builtin operators. We require:
11849 // (1) The class has exactly one field.
11850 // (2) The field is an integral or enumeration type.
11851 auto FIt = Info->Record->field_begin(), FEnd = Info->Record->field_end();
11852 if (std::distance(FIt, FEnd) != 1 ||
11853 !FIt->getType()->isIntegralOrEnumerationType()) {
11854 return UnsupportedSTLError();
11855 }
11856
11857 // Build each of the require values and store them in Info.
11858 for (ComparisonCategoryResult CCR :
11860 StringRef MemName = ComparisonCategories::getResultString(CCR);
11861 ComparisonCategoryInfo::ValueInfo *ValInfo = Info->lookupValueInfo(CCR);
11862
11863 if (!ValInfo)
11864 return UnsupportedSTLError(USS_MissingMember, MemName);
11865
11866 VarDecl *VD = ValInfo->VD;
11867 assert(VD && "should not be null!");
11868
11869 // Attempt to diagnose reasons why the STL definition of this type
11870 // might be foobar, including it failing to be a constant expression.
11871 // TODO Handle more ways the lookup or result can be invalid.
11872 if (!VD->isStaticDataMember() ||
11874 return UnsupportedSTLError(USS_InvalidMember, MemName, VD);
11875
11876 // Attempt to evaluate the var decl as a constant expression and extract
11877 // the value of its first field as a ICE. If this fails, the STL
11878 // implementation is not supported.
11879 if (!ValInfo->hasValidIntValue())
11880 return UnsupportedSTLError();
11881
11883 }
11884
11885 // We've successfully built the required types and expressions. Update
11886 // the cache and return the newly cached value.
11887 FullyCheckedComparisonCategories[static_cast<unsigned>(Kind)] = true;
11888 return Info->getType();
11889}
11890
11892 if (!StdNamespace) {
11893 // The "std" namespace has not yet been defined, so build one implicitly.
11896 /*Inline=*/false, SourceLocation(), SourceLocation(),
11897 &PP.getIdentifierTable().get("std"),
11898 /*PrevDecl=*/nullptr, /*Nested=*/false);
11900 // We want the created NamespaceDecl to be available for redeclaration
11901 // lookups, but not for regular name lookups.
11904 }
11905
11906 return getStdNamespace();
11907}
11908
11910 assert(getLangOpts().CPlusPlus &&
11911 "Looking for std::initializer_list outside of C++.");
11912
11913 // We're looking for implicit instantiations of
11914 // template <typename E> class std::initializer_list.
11915
11916 if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it.
11917 return false;
11918
11919 ClassTemplateDecl *Template = nullptr;
11920 const TemplateArgument *Arguments = nullptr;
11921
11922 if (const RecordType *RT = Ty->getAs<RecordType>()) {
11923
11925 dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
11926 if (!Specialization)
11927 return false;
11928
11929 Template = Specialization->getSpecializedTemplate();
11930 Arguments = Specialization->getTemplateArgs().data();
11931 } else {
11932 const TemplateSpecializationType *TST = nullptr;
11933 if (auto *ICN = Ty->getAs<InjectedClassNameType>())
11934 TST = ICN->getInjectedTST();
11935 else
11936 TST = Ty->getAs<TemplateSpecializationType>();
11937 if (TST) {
11938 Template = dyn_cast_or_null<ClassTemplateDecl>(
11940 Arguments = TST->template_arguments().begin();
11941 }
11942 }
11943 if (!Template)
11944 return false;
11945
11946 if (!StdInitializerList) {
11947 // Haven't recognized std::initializer_list yet, maybe this is it.
11948 CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
11949 if (TemplateClass->getIdentifier() !=
11950 &PP.getIdentifierTable().get("initializer_list") ||
11951 !getStdNamespace()->InEnclosingNamespaceSetOf(
11952 TemplateClass->getNonTransparentDeclContext()))
11953 return false;
11954 // This is a template called std::initializer_list, but is it the right
11955 // template?
11956 TemplateParameterList *Params = Template->getTemplateParameters();
11957 if (Params->getMinRequiredArguments() != 1)
11958 return false;
11959 if (!isa<TemplateTypeParmDecl>(Params->getParam(0)))
11960 return false;
11961
11962 // It's the right template.
11963 StdInitializerList = Template;
11964 }
11965
11967 return false;
11968
11969 // This is an instance of std::initializer_list. Find the argument type.
11970 if (Element)
11971 *Element = Arguments[0].getAsType();
11972 return true;
11973}
11974
11977 if (!Std) {
11978 S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
11979 return nullptr;
11980 }
11981
11982 LookupResult Result(S, &S.PP.getIdentifierTable().get("initializer_list"),
11984 if (!S.LookupQualifiedName(Result, Std)) {
11985 S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
11986 return nullptr;
11987 }
11988 ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>();
11989 if (!Template) {
11990 Result.suppressDiagnostics();
11991 // We found something weird. Complain about the first thing we found.
11992 NamedDecl *Found = *Result.begin();
11993 S.Diag(Found->getLocation(), diag::err_malformed_std_initializer_list);
11994 return nullptr;
11995 }
11996
11997 // We found some template called std::initializer_list. Now verify that it's
11998 // correct.
11999 TemplateParameterList *Params = Template->getTemplateParameters();
12000 if (Params->getMinRequiredArguments() != 1 ||
12001 !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
12002 S.Diag(Template->getLocation(), diag::err_malformed_std_initializer_list);
12003 return nullptr;
12004 }
12005
12006 return Template;
12007}
12008
12010 if (!StdInitializerList) {
12012 if (!StdInitializerList)
12013 return QualType();
12014 }
12015
12019 Loc)));
12024}
12025
12027 // C++ [dcl.init.list]p2:
12028 // A constructor is an initializer-list constructor if its first parameter
12029 // is of type std::initializer_list<E> or reference to possibly cv-qualified
12030 // std::initializer_list<E> for some type E, and either there are no other
12031 // parameters or else all other parameters have default arguments.
12032 if (!Ctor->hasOneParamOrDefaultArgs())
12033 return false;
12034
12035 QualType ArgType = Ctor->getParamDecl(0)->getType();
12036 if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
12037 ArgType = RT->getPointeeType().getUnqualifiedType();
12038
12039 return isStdInitializerList(ArgType, nullptr);
12040}
12041
12042/// Determine whether a using statement is in a context where it will be
12043/// apply in all contexts.
12045 switch (CurContext->getDeclKind()) {
12046 case Decl::TranslationUnit:
12047 return true;
12048 case Decl::LinkageSpec:
12050 default:
12051 return false;
12052 }
12053}
12054
12055namespace {
12056
12057// Callback to only accept typo corrections that are namespaces.
12058class NamespaceValidatorCCC final : public CorrectionCandidateCallback {
12059public:
12060 bool ValidateCandidate(const TypoCorrection &candidate) override {
12061 if (NamedDecl *ND = candidate.getCorrectionDecl())
12062 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
12063 return false;
12064 }
12065
12066 std::unique_ptr<CorrectionCandidateCallback> clone() override {
12067 return std::make_unique<NamespaceValidatorCCC>(*this);
12068 }
12069};
12070
12071}
12072
12073static void DiagnoseInvisibleNamespace(const TypoCorrection &Corrected,
12074 Sema &S) {
12075 auto *ND = cast<NamespaceDecl>(Corrected.getFoundDecl());
12076 Module *M = ND->getOwningModule();
12077 assert(M && "hidden namespace definition not in a module?");
12078
12079 if (M->isExplicitGlobalModule())
12080 S.Diag(Corrected.getCorrectionRange().getBegin(),
12081 diag::err_module_unimported_use_header)
12083 << /*Header Name*/ false;
12084 else
12085 S.Diag(Corrected.getCorrectionRange().getBegin(),
12086 diag::err_module_unimported_use)
12088 << M->getTopLevelModuleName();
12089}
12090
12092 CXXScopeSpec &SS,
12093 SourceLocation IdentLoc,
12094 IdentifierInfo *Ident) {
12095 R.clear();
12096 NamespaceValidatorCCC CCC{};
12097 if (TypoCorrection Corrected =
12098 S.CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), Sc, &SS, CCC,
12100 // Generally we find it is confusing more than helpful to diagnose the
12101 // invisible namespace.
12102 // See https://github.com/llvm/llvm-project/issues/73893.
12103 //
12104 // However, we should diagnose when the users are trying to using an
12105 // invisible namespace. So we handle the case specially here.
12106 if (isa_and_nonnull<NamespaceDecl>(Corrected.getFoundDecl()) &&
12107 Corrected.requiresImport()) {
12108 DiagnoseInvisibleNamespace(Corrected, S);
12109 } else if (DeclContext *DC = S.computeDeclContext(SS, false)) {
12110 std::string CorrectedStr(Corrected.getAsString(S.getLangOpts()));
12111 bool DroppedSpecifier =
12112 Corrected.WillReplaceSpecifier() && Ident->getName() == CorrectedStr;
12113 S.diagnoseTypo(Corrected,
12114 S.PDiag(diag::err_using_directive_member_suggest)
12115 << Ident << DC << DroppedSpecifier << SS.getRange(),
12116 S.PDiag(diag::note_namespace_defined_here));
12117 } else {
12118 S.diagnoseTypo(Corrected,
12119 S.PDiag(diag::err_using_directive_suggest) << Ident,
12120 S.PDiag(diag::note_namespace_defined_here));
12121 }
12122 R.addDecl(Corrected.getFoundDecl());
12123 return true;
12124 }
12125 return false;
12126}
12127
12129 SourceLocation NamespcLoc, CXXScopeSpec &SS,
12130 SourceLocation IdentLoc,
12131 IdentifierInfo *NamespcName,
12132 const ParsedAttributesView &AttrList) {
12133 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
12134 assert(NamespcName && "Invalid NamespcName.");
12135 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
12136
12137 // Get the innermost enclosing declaration scope.
12138 S = S->getDeclParent();
12139
12140 UsingDirectiveDecl *UDir = nullptr;
12141 NestedNameSpecifier *Qualifier = nullptr;
12142 if (SS.isSet())
12143 Qualifier = SS.getScopeRep();
12144
12145 // Lookup namespace name.
12146 LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
12147 LookupParsedName(R, S, &SS, /*ObjectType=*/QualType());
12148 if (R.isAmbiguous())
12149 return nullptr;
12150
12151 if (R.empty()) {
12152 R.clear();
12153 // Allow "using namespace std;" or "using namespace ::std;" even if
12154 // "std" hasn't been defined yet, for GCC compatibility.
12155 if ((!Qualifier || Qualifier->getKind() == NestedNameSpecifier::Global) &&
12156 NamespcName->isStr("std")) {
12157 Diag(IdentLoc, diag::ext_using_undefined_std);
12159 R.resolveKind();
12160 }
12161 // Otherwise, attempt typo correction.
12162 else TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, NamespcName);
12163 }
12164
12165 if (!R.empty()) {
12166 NamedDecl *Named = R.getRepresentativeDecl();
12168 assert(NS && "expected namespace decl");
12169
12170 // The use of a nested name specifier may trigger deprecation warnings.
12171 DiagnoseUseOfDecl(Named, IdentLoc);
12172
12173 // C++ [namespace.udir]p1:
12174 // A using-directive specifies that the names in the nominated
12175 // namespace can be used in the scope in which the
12176 // using-directive appears after the using-directive. During
12177 // unqualified name lookup (3.4.1), the names appear as if they
12178 // were declared in the nearest enclosing namespace which
12179 // contains both the using-directive and the nominated
12180 // namespace. [Note: in this context, "contains" means "contains
12181 // directly or indirectly". ]
12182
12183 // Find enclosing context containing both using-directive and
12184 // nominated namespace.
12185 DeclContext *CommonAncestor = NS;
12186 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
12187 CommonAncestor = CommonAncestor->getParent();
12188
12189 UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
12191 IdentLoc, Named, CommonAncestor);
12192
12195 Diag(IdentLoc, diag::warn_using_directive_in_header);
12196 }
12197
12198 PushUsingDirective(S, UDir);
12199 } else {
12200 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
12201 }
12202
12203 if (UDir) {
12204 ProcessDeclAttributeList(S, UDir, AttrList);
12205 ProcessAPINotes(UDir);
12206 }
12207
12208 return UDir;
12209}
12210
12212 // If the scope has an associated entity and the using directive is at
12213 // namespace or translation unit scope, add the UsingDirectiveDecl into
12214 // its lookup structure so qualified name lookup can find it.
12215 DeclContext *Ctx = S->getEntity();
12216 if (Ctx && !Ctx->isFunctionOrMethod())
12217 Ctx->addDecl(UDir);
12218 else
12219 // Otherwise, it is at block scope. The using-directives will affect lookup
12220 // only to the end of the scope.
12221 S->PushUsingDirective(UDir);
12222}
12223
12225 SourceLocation UsingLoc,
12226 SourceLocation TypenameLoc, CXXScopeSpec &SS,
12227 UnqualifiedId &Name,
12228 SourceLocation EllipsisLoc,
12229 const ParsedAttributesView &AttrList) {
12230 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
12231
12232 if (SS.isEmpty()) {
12233 Diag(Name.getBeginLoc(), diag::err_using_requires_qualname);
12234 return nullptr;
12235 }
12236
12237 switch (Name.getKind()) {
12243 break;
12244
12247 // C++11 inheriting constructors.
12248 Diag(Name.getBeginLoc(),
12250 ? diag::warn_cxx98_compat_using_decl_constructor
12251 : diag::err_using_decl_constructor)
12252 << SS.getRange();
12253
12254 if (getLangOpts().CPlusPlus11) break;
12255
12256 return nullptr;
12257
12259 Diag(Name.getBeginLoc(), diag::err_using_decl_destructor) << SS.getRange();
12260 return nullptr;
12261
12263 Diag(Name.getBeginLoc(), diag::err_using_decl_template_id)
12264 << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
12265 return nullptr;
12266
12268 llvm_unreachable("cannot parse qualified deduction guide name");
12269 }
12270
12271 DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
12272 DeclarationName TargetName = TargetNameInfo.getName();
12273 if (!TargetName)
12274 return nullptr;
12275
12276 // Warn about access declarations.
12277 if (UsingLoc.isInvalid()) {
12278 Diag(Name.getBeginLoc(), getLangOpts().CPlusPlus11
12279 ? diag::err_access_decl
12280 : diag::warn_access_decl_deprecated)
12281 << FixItHint::CreateInsertion(SS.getRange().getBegin(), "using ");
12282 }
12283
12284 if (EllipsisLoc.isInvalid()) {
12287 return nullptr;
12288 } else {
12290 !TargetNameInfo.containsUnexpandedParameterPack()) {
12291 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
12292 << SourceRange(SS.getBeginLoc(), TargetNameInfo.getEndLoc());
12293 EllipsisLoc = SourceLocation();
12294 }
12295 }
12296
12297 NamedDecl *UD =
12298 BuildUsingDeclaration(S, AS, UsingLoc, TypenameLoc.isValid(), TypenameLoc,
12299 SS, TargetNameInfo, EllipsisLoc, AttrList,
12300 /*IsInstantiation*/ false,
12301 AttrList.hasAttribute(ParsedAttr::AT_UsingIfExists));
12302 if (UD)
12303 PushOnScopeChains(UD, S, /*AddToContext*/ false);
12304
12305 return UD;
12306}
12307
12309 SourceLocation UsingLoc,
12310 SourceLocation EnumLoc, SourceRange TyLoc,
12311 const IdentifierInfo &II, ParsedType Ty,
12312 CXXScopeSpec *SS) {
12313 assert(SS && !SS->isInvalid() && "ScopeSpec is invalid");
12314 TypeSourceInfo *TSI = nullptr;
12315 SourceLocation IdentLoc = TyLoc.getBegin();
12316 QualType EnumTy = GetTypeFromParser(Ty, &TSI);
12317 if (EnumTy.isNull()) {
12318 Diag(IdentLoc, isDependentScopeSpecifier(*SS)
12319 ? diag::err_using_enum_is_dependent
12320 : diag::err_unknown_typename)
12321 << II.getName() << SourceRange(SS->getBeginLoc(), TyLoc.getEnd());
12322 return nullptr;
12323 }
12324
12325 if (EnumTy->isDependentType()) {
12326 Diag(IdentLoc, diag::err_using_enum_is_dependent);
12327 return nullptr;
12328 }
12329
12330 auto *Enum = dyn_cast_if_present<EnumDecl>(EnumTy->getAsTagDecl());
12331 if (!Enum) {
12332 Diag(IdentLoc, diag::err_using_enum_not_enum) << EnumTy;
12333 return nullptr;
12334 }
12335
12336 if (auto *Def = Enum->getDefinition())
12337 Enum = Def;
12338
12339 if (TSI == nullptr)
12340 TSI = Context.getTrivialTypeSourceInfo(EnumTy, IdentLoc);
12341
12342 auto *UD =
12343 BuildUsingEnumDeclaration(S, AS, UsingLoc, EnumLoc, IdentLoc, TSI, Enum);
12344
12345 if (UD)
12346 PushOnScopeChains(UD, S, /*AddToContext*/ false);
12347
12348 return UD;
12349}
12350
12351/// Determine whether a using declaration considers the given
12352/// declarations as "equivalent", e.g., if they are redeclarations of
12353/// the same entity or are both typedefs of the same type.
12354static bool
12356 if (D1->getCanonicalDecl() == D2->getCanonicalDecl())
12357 return true;
12358
12359 if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(D1))
12360 if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2))
12361 return Context.hasSameType(TD1->getUnderlyingType(),
12362 TD2->getUnderlyingType());
12363
12364 // Two using_if_exists using-declarations are equivalent if both are
12365 // unresolved.
12366 if (isa<UnresolvedUsingIfExistsDecl>(D1) &&
12367 isa<UnresolvedUsingIfExistsDecl>(D2))
12368 return true;
12369
12370 return false;
12371}
12372
12374 const LookupResult &Previous,
12375 UsingShadowDecl *&PrevShadow) {
12376 // Diagnose finding a decl which is not from a base class of the
12377 // current class. We do this now because there are cases where this
12378 // function will silently decide not to build a shadow decl, which
12379 // will pre-empt further diagnostics.
12380 //
12381 // We don't need to do this in C++11 because we do the check once on
12382 // the qualifier.
12383 //
12384 // FIXME: diagnose the following if we care enough:
12385 // struct A { int foo; };
12386 // struct B : A { using A::foo; };
12387 // template <class T> struct C : A {};
12388 // template <class T> struct D : C<T> { using B::foo; } // <---
12389 // This is invalid (during instantiation) in C++03 because B::foo
12390 // resolves to the using decl in B, which is not a base class of D<T>.
12391 // We can't diagnose it immediately because C<T> is an unknown
12392 // specialization. The UsingShadowDecl in D<T> then points directly
12393 // to A::foo, which will look well-formed when we instantiate.
12394 // The right solution is to not collapse the shadow-decl chain.
12396 if (auto *Using = dyn_cast<UsingDecl>(BUD)) {
12397 DeclContext *OrigDC = Orig->getDeclContext();
12398
12399 // Handle enums and anonymous structs.
12400 if (isa<EnumDecl>(OrigDC))
12401 OrigDC = OrigDC->getParent();
12402 CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
12403 while (OrigRec->isAnonymousStructOrUnion())
12404 OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
12405
12406 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
12407 if (OrigDC == CurContext) {
12408 Diag(Using->getLocation(),
12409 diag::err_using_decl_nested_name_specifier_is_current_class)
12410 << Using->getQualifierLoc().getSourceRange();
12411 Diag(Orig->getLocation(), diag::note_using_decl_target);
12412 Using->setInvalidDecl();
12413 return true;
12414 }
12415
12416 Diag(Using->getQualifierLoc().getBeginLoc(),
12417 diag::err_using_decl_nested_name_specifier_is_not_base_class)
12418 << Using->getQualifier() << cast<CXXRecordDecl>(CurContext)
12419 << Using->getQualifierLoc().getSourceRange();
12420 Diag(Orig->getLocation(), diag::note_using_decl_target);
12421 Using->setInvalidDecl();
12422 return true;
12423 }
12424 }
12425
12426 if (Previous.empty()) return false;
12427
12428 NamedDecl *Target = Orig;
12429 if (isa<UsingShadowDecl>(Target))
12430 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
12431
12432 // If the target happens to be one of the previous declarations, we
12433 // don't have a conflict.
12434 //
12435 // FIXME: but we might be increasing its access, in which case we
12436 // should redeclare it.
12437 NamedDecl *NonTag = nullptr, *Tag = nullptr;
12438 bool FoundEquivalentDecl = false;
12439 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
12440 I != E; ++I) {
12441 NamedDecl *D = (*I)->getUnderlyingDecl();
12442 // We can have UsingDecls in our Previous results because we use the same
12443 // LookupResult for checking whether the UsingDecl itself is a valid
12444 // redeclaration.
12445 if (isa<UsingDecl>(D) || isa<UsingPackDecl>(D) || isa<UsingEnumDecl>(D))
12446 continue;
12447
12448 if (auto *RD = dyn_cast<CXXRecordDecl>(D)) {
12449 // C++ [class.mem]p19:
12450 // If T is the name of a class, then [every named member other than
12451 // a non-static data member] shall have a name different from T
12452 if (RD->isInjectedClassName() && !isa<FieldDecl>(Target) &&
12453 !isa<IndirectFieldDecl>(Target) &&
12454 !isa<UnresolvedUsingValueDecl>(Target) &&
12456 CurContext,
12458 return true;
12459 }
12460
12462 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(*I))
12463 PrevShadow = Shadow;
12464 FoundEquivalentDecl = true;
12466 // We don't conflict with an existing using shadow decl of an equivalent
12467 // declaration, but we're not a redeclaration of it.
12468 FoundEquivalentDecl = true;
12469 }
12470
12471 if (isVisible(D))
12472 (isa<TagDecl>(D) ? Tag : NonTag) = D;
12473 }
12474
12475 if (FoundEquivalentDecl)
12476 return false;
12477
12478 // Always emit a diagnostic for a mismatch between an unresolved
12479 // using_if_exists and a resolved using declaration in either direction.
12480 if (isa<UnresolvedUsingIfExistsDecl>(Target) !=
12481 (isa_and_nonnull<UnresolvedUsingIfExistsDecl>(NonTag))) {
12482 if (!NonTag && !Tag)
12483 return false;
12484 Diag(BUD->getLocation(), diag::err_using_decl_conflict);
12485 Diag(Target->getLocation(), diag::note_using_decl_target);
12486 Diag((NonTag ? NonTag : Tag)->getLocation(),
12487 diag::note_using_decl_conflict);
12488 BUD->setInvalidDecl();
12489 return true;
12490 }
12491
12492 if (FunctionDecl *FD = Target->getAsFunction()) {
12493 NamedDecl *OldDecl = nullptr;
12494 switch (CheckOverload(nullptr, FD, Previous, OldDecl,
12495 /*IsForUsingDecl*/ true)) {
12496 case Ovl_Overload:
12497 return false;
12498
12499 case Ovl_NonFunction:
12500 Diag(BUD->getLocation(), diag::err_using_decl_conflict);
12501 break;
12502
12503 // We found a decl with the exact signature.
12504 case Ovl_Match:
12505 // If we're in a record, we want to hide the target, so we
12506 // return true (without a diagnostic) to tell the caller not to
12507 // build a shadow decl.
12508 if (CurContext->isRecord())
12509 return true;
12510
12511 // If we're not in a record, this is an error.
12512 Diag(BUD->getLocation(), diag::err_using_decl_conflict);
12513 break;
12514 }
12515
12516 Diag(Target->getLocation(), diag::note_using_decl_target);
12517 Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
12518 BUD->setInvalidDecl();
12519 return true;
12520 }
12521
12522 // Target is not a function.
12523
12524 if (isa<TagDecl>(Target)) {
12525 // No conflict between a tag and a non-tag.
12526 if (!Tag) return false;
12527
12528 Diag(BUD->getLocation(), diag::err_using_decl_conflict);
12529 Diag(Target->getLocation(), diag::note_using_decl_target);
12530 Diag(Tag->getLocation(), diag::note_using_decl_conflict);
12531 BUD->setInvalidDecl();
12532 return true;
12533 }
12534
12535 // No conflict between a tag and a non-tag.
12536 if (!NonTag) return false;
12537
12538 Diag(BUD->getLocation(), diag::err_using_decl_conflict);
12539 Diag(Target->getLocation(), diag::note_using_decl_target);
12540 Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
12541 BUD->setInvalidDecl();
12542 return true;
12543}
12544
12545/// Determine whether a direct base class is a virtual base class.
12547 if (!Derived->getNumVBases())
12548 return false;
12549 for (auto &B : Derived->bases())
12550 if (B.getType()->getAsCXXRecordDecl() == Base)
12551 return B.isVirtual();
12552 llvm_unreachable("not a direct base class");
12553}
12554
12556 NamedDecl *Orig,
12557 UsingShadowDecl *PrevDecl) {
12558 // If we resolved to another shadow declaration, just coalesce them.
12559 NamedDecl *Target = Orig;
12560 if (isa<UsingShadowDecl>(Target)) {
12561 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
12562 assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
12563 }
12564
12565 NamedDecl *NonTemplateTarget = Target;
12566 if (auto *TargetTD = dyn_cast<TemplateDecl>(Target))
12567 NonTemplateTarget = TargetTD->getTemplatedDecl();
12568
12569 UsingShadowDecl *Shadow;
12570 if (NonTemplateTarget && isa<CXXConstructorDecl>(NonTemplateTarget)) {
12571 UsingDecl *Using = cast<UsingDecl>(BUD);
12572 bool IsVirtualBase =
12573 isVirtualDirectBase(cast<CXXRecordDecl>(CurContext),
12574 Using->getQualifier()->getAsRecordDecl());
12576 Context, CurContext, Using->getLocation(), Using, Orig, IsVirtualBase);
12577 } else {
12579 Target->getDeclName(), BUD, Target);
12580 }
12581 BUD->addShadowDecl(Shadow);
12582
12583 Shadow->setAccess(BUD->getAccess());
12584 if (Orig->isInvalidDecl() || BUD->isInvalidDecl())
12585 Shadow->setInvalidDecl();
12586
12587 Shadow->setPreviousDecl(PrevDecl);
12588
12589 if (S)
12590 PushOnScopeChains(Shadow, S);
12591 else
12592 CurContext->addDecl(Shadow);
12593
12594
12595 return Shadow;
12596}
12597
12599 if (Shadow->getDeclName().getNameKind() ==
12601 cast<CXXRecordDecl>(Shadow->getDeclContext())->removeConversion(Shadow);
12602
12603 // Remove it from the DeclContext...
12604 Shadow->getDeclContext()->removeDecl(Shadow);
12605
12606 // ...and the scope, if applicable...
12607 if (S) {
12608 S->RemoveDecl(Shadow);
12609 IdResolver.RemoveDecl(Shadow);
12610 }
12611
12612 // ...and the using decl.
12613 Shadow->getIntroducer()->removeShadowDecl(Shadow);
12614
12615 // TODO: complain somehow if Shadow was used. It shouldn't
12616 // be possible for this to happen, because...?
12617}
12618
12619/// Find the base specifier for a base class with the given type.
12621 QualType DesiredBase,
12622 bool &AnyDependentBases) {
12623 // Check whether the named type is a direct base class.
12624 CanQualType CanonicalDesiredBase = DesiredBase->getCanonicalTypeUnqualified()
12626 for (auto &Base : Derived->bases()) {
12627 CanQualType BaseType = Base.getType()->getCanonicalTypeUnqualified();
12628 if (CanonicalDesiredBase == BaseType)
12629 return &Base;
12630 if (BaseType->isDependentType())
12631 AnyDependentBases = true;
12632 }
12633 return nullptr;
12634}
12635
12636namespace {
12637class UsingValidatorCCC final : public CorrectionCandidateCallback {
12638public:
12639 UsingValidatorCCC(bool HasTypenameKeyword, bool IsInstantiation,
12640 NestedNameSpecifier *NNS, CXXRecordDecl *RequireMemberOf)
12641 : HasTypenameKeyword(HasTypenameKeyword),
12642 IsInstantiation(IsInstantiation), OldNNS(NNS),
12643 RequireMemberOf(RequireMemberOf) {}
12644
12645 bool ValidateCandidate(const TypoCorrection &Candidate) override {
12646 NamedDecl *ND = Candidate.getCorrectionDecl();
12647
12648 // Keywords are not valid here.
12649 if (!ND || isa<NamespaceDecl>(ND))
12650 return false;
12651
12652 // Completely unqualified names are invalid for a 'using' declaration.
12653 if (Candidate.WillReplaceSpecifier() && !Candidate.getCorrectionSpecifier())
12654 return false;
12655
12656 // FIXME: Don't correct to a name that CheckUsingDeclRedeclaration would
12657 // reject.
12658
12659 if (RequireMemberOf) {
12660 auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
12661 if (FoundRecord && FoundRecord->isInjectedClassName()) {
12662 // No-one ever wants a using-declaration to name an injected-class-name
12663 // of a base class, unless they're declaring an inheriting constructor.
12664 ASTContext &Ctx = ND->getASTContext();
12665 if (!Ctx.getLangOpts().CPlusPlus11)
12666 return false;
12667 QualType FoundType = Ctx.getRecordType(FoundRecord);
12668
12669 // Check that the injected-class-name is named as a member of its own
12670 // type; we don't want to suggest 'using Derived::Base;', since that
12671 // means something else.
12673 Candidate.WillReplaceSpecifier()
12674 ? Candidate.getCorrectionSpecifier()
12675 : OldNNS;
12676 if (!Specifier->getAsType() ||
12677 !Ctx.hasSameType(QualType(Specifier->getAsType(), 0), FoundType))
12678 return false;
12679
12680 // Check that this inheriting constructor declaration actually names a
12681 // direct base class of the current class.
12682 bool AnyDependentBases = false;
12683 if (!findDirectBaseWithType(RequireMemberOf,
12684 Ctx.getRecordType(FoundRecord),
12685 AnyDependentBases) &&
12686 !AnyDependentBases)
12687 return false;
12688 } else {
12689 auto *RD = dyn_cast<CXXRecordDecl>(ND->getDeclContext());
12690 if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(RD))
12691 return false;
12692
12693 // FIXME: Check that the base class member is accessible?
12694 }
12695 } else {
12696 auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
12697 if (FoundRecord && FoundRecord->isInjectedClassName())
12698 return false;
12699 }
12700
12701 if (isa<TypeDecl>(ND))
12702 return HasTypenameKeyword || !IsInstantiation;
12703
12704 return !HasTypenameKeyword;
12705 }
12706
12707 std::unique_ptr<CorrectionCandidateCallback> clone() override {
12708 return std::make_unique<UsingValidatorCCC>(*this);
12709 }
12710
12711private:
12712 bool HasTypenameKeyword;
12713 bool IsInstantiation;
12714 NestedNameSpecifier *OldNNS;
12715 CXXRecordDecl *RequireMemberOf;
12716};
12717} // end anonymous namespace
12718
12720 // It is really dumb that we have to do this.
12721 LookupResult::Filter F = Previous.makeFilter();
12722 while (F.hasNext()) {
12723 NamedDecl *D = F.next();
12724 if (!isDeclInScope(D, CurContext, S))
12725 F.erase();
12726 // If we found a local extern declaration that's not ordinarily visible,
12727 // and this declaration is being added to a non-block scope, ignore it.
12728 // We're only checking for scope conflicts here, not also for violations
12729 // of the linkage rules.
12730 else if (!CurContext->isFunctionOrMethod() && D->isLocalExternDecl() &&
12732 F.erase();
12733 }
12734 F.done();
12735}
12736
12738 Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,
12739 bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,
12740 DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,
12741 const ParsedAttributesView &AttrList, bool IsInstantiation,
12742 bool IsUsingIfExists) {
12743 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
12744 SourceLocation IdentLoc = NameInfo.getLoc();
12745 assert(IdentLoc.isValid() && "Invalid TargetName location.");
12746
12747 // FIXME: We ignore attributes for now.
12748
12749 // For an inheriting constructor declaration, the name of the using
12750 // declaration is the name of a constructor in this class, not in the
12751 // base class.
12752 DeclarationNameInfo UsingName = NameInfo;
12754 if (auto *RD = dyn_cast<CXXRecordDecl>(CurContext))
12757
12758 // Do the redeclaration lookup in the current scope.
12759 LookupResult Previous(*this, UsingName, LookupUsingDeclName,
12760 RedeclarationKind::ForVisibleRedeclaration);
12761 Previous.setHideTags(false);
12762 if (S) {
12763 LookupName(Previous, S);
12764
12766 } else {
12767 assert(IsInstantiation && "no scope in non-instantiation");
12768 if (CurContext->isRecord())
12770 else {
12771 // No redeclaration check is needed here; in non-member contexts we
12772 // diagnosed all possible conflicts with other using-declarations when
12773 // building the template:
12774 //
12775 // For a dependent non-type using declaration, the only valid case is
12776 // if we instantiate to a single enumerator. We check for conflicts
12777 // between shadow declarations we introduce, and we check in the template
12778 // definition for conflicts between a non-type using declaration and any
12779 // other declaration, which together covers all cases.
12780 //
12781 // A dependent typename using declaration will never successfully
12782 // instantiate, since it will always name a class member, so we reject
12783 // that in the template definition.
12784 }
12785 }
12786
12787 // Check for invalid redeclarations.
12788 if (CheckUsingDeclRedeclaration(UsingLoc, HasTypenameKeyword,
12789 SS, IdentLoc, Previous))
12790 return nullptr;
12791
12792 // 'using_if_exists' doesn't make sense on an inherited constructor.
12793 if (IsUsingIfExists && UsingName.getName().getNameKind() ==
12795 Diag(UsingLoc, diag::err_using_if_exists_on_ctor);
12796 return nullptr;
12797 }
12798
12799 DeclContext *LookupContext = computeDeclContext(SS);
12801 if (!LookupContext || EllipsisLoc.isValid()) {
12802 NamedDecl *D;
12803 // Dependent scope, or an unexpanded pack
12804 if (!LookupContext && CheckUsingDeclQualifier(UsingLoc, HasTypenameKeyword,
12805 SS, NameInfo, IdentLoc))
12806 return nullptr;
12807
12808 if (HasTypenameKeyword) {
12809 // FIXME: not all declaration name kinds are legal here
12811 UsingLoc, TypenameLoc,
12812 QualifierLoc,
12813 IdentLoc, NameInfo.getName(),
12814 EllipsisLoc);
12815 } else {
12817 QualifierLoc, NameInfo, EllipsisLoc);
12818 }
12819 D->setAccess(AS);
12821 ProcessDeclAttributeList(S, D, AttrList);
12822 return D;
12823 }
12824
12825 auto Build = [&](bool Invalid) {
12826 UsingDecl *UD =
12827 UsingDecl::Create(Context, CurContext, UsingLoc, QualifierLoc,
12828 UsingName, HasTypenameKeyword);
12829 UD->setAccess(AS);
12830 CurContext->addDecl(UD);
12831 ProcessDeclAttributeList(S, UD, AttrList);
12833 return UD;
12834 };
12835 auto BuildInvalid = [&]{ return Build(true); };
12836 auto BuildValid = [&]{ return Build(false); };
12837
12838 if (RequireCompleteDeclContext(SS, LookupContext))
12839 return BuildInvalid();
12840
12841 // Look up the target name.
12842 LookupResult R(*this, NameInfo, LookupOrdinaryName);
12843
12844 // Unlike most lookups, we don't always want to hide tag
12845 // declarations: tag names are visible through the using declaration
12846 // even if hidden by ordinary names, *except* in a dependent context
12847 // where they may be used by two-phase lookup.
12848 if (!IsInstantiation)
12849 R.setHideTags(false);
12850
12851 // For the purposes of this lookup, we have a base object type
12852 // equal to that of the current context.
12853 if (CurContext->isRecord()) {
12855 Context.getTypeDeclType(cast<CXXRecordDecl>(CurContext)));
12856 }
12857
12858 LookupQualifiedName(R, LookupContext);
12859
12860 // Validate the context, now we have a lookup
12861 if (CheckUsingDeclQualifier(UsingLoc, HasTypenameKeyword, SS, NameInfo,
12862 IdentLoc, &R))
12863 return nullptr;
12864
12865 if (R.empty() && IsUsingIfExists)
12867 UsingName.getName()),
12868 AS_public);
12869
12870 // Try to correct typos if possible. If constructor name lookup finds no
12871 // results, that means the named class has no explicit constructors, and we
12872 // suppressed declaring implicit ones (probably because it's dependent or
12873 // invalid).
12874 if (R.empty() &&
12876 // HACK 2017-01-08: Work around an issue with libstdc++'s detection of
12877 // ::gets. Sometimes it believes that glibc provides a ::gets in cases where
12878 // it does not. The issue was fixed in libstdc++ 6.3 (2016-12-21) and later.
12879 auto *II = NameInfo.getName().getAsIdentifierInfo();
12880 if (getLangOpts().CPlusPlus14 && II && II->isStr("gets") &&
12882 isa<TranslationUnitDecl>(LookupContext) &&
12883 getSourceManager().isInSystemHeader(UsingLoc))
12884 return nullptr;
12885 UsingValidatorCCC CCC(HasTypenameKeyword, IsInstantiation, SS.getScopeRep(),
12886 dyn_cast<CXXRecordDecl>(CurContext));
12887 if (TypoCorrection Corrected =
12888 CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, &SS, CCC,
12890 // We reject candidates where DroppedSpecifier == true, hence the
12891 // literal '0' below.
12892 diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
12893 << NameInfo.getName() << LookupContext << 0
12894 << SS.getRange());
12895
12896 // If we picked a correction with no attached Decl we can't do anything
12897 // useful with it, bail out.
12898 NamedDecl *ND = Corrected.getCorrectionDecl();
12899 if (!ND)
12900 return BuildInvalid();
12901
12902 // If we corrected to an inheriting constructor, handle it as one.
12903 auto *RD = dyn_cast<CXXRecordDecl>(ND);
12904 if (RD && RD->isInjectedClassName()) {
12905 // The parent of the injected class name is the class itself.
12906 RD = cast<CXXRecordDecl>(RD->getParent());
12907
12908 // Fix up the information we'll use to build the using declaration.
12909 if (Corrected.WillReplaceSpecifier()) {
12911 Builder.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
12912 QualifierLoc.getSourceRange());
12913 QualifierLoc = Builder.getWithLocInContext(Context);
12914 }
12915
12916 // In this case, the name we introduce is the name of a derived class
12917 // constructor.
12918 auto *CurClass = cast<CXXRecordDecl>(CurContext);
12921 UsingName.setNamedTypeInfo(nullptr);
12922 for (auto *Ctor : LookupConstructors(RD))
12923 R.addDecl(Ctor);
12924 R.resolveKind();
12925 } else {
12926 // FIXME: Pick up all the declarations if we found an overloaded
12927 // function.
12928 UsingName.setName(ND->getDeclName());
12929 R.addDecl(ND);
12930 }
12931 } else {
12932 Diag(IdentLoc, diag::err_no_member)
12933 << NameInfo.getName() << LookupContext << SS.getRange();
12934 return BuildInvalid();
12935 }
12936 }
12937
12938 if (R.isAmbiguous())
12939 return BuildInvalid();
12940
12941 if (HasTypenameKeyword) {
12942 // If we asked for a typename and got a non-type decl, error out.
12943 if (!R.getAsSingle<TypeDecl>() &&
12945 Diag(IdentLoc, diag::err_using_typename_non_type);
12946 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
12947 Diag((*I)->getUnderlyingDecl()->getLocation(),
12948 diag::note_using_decl_target);
12949 return BuildInvalid();
12950 }
12951 } else {
12952 // If we asked for a non-typename and we got a type, error out,
12953 // but only if this is an instantiation of an unresolved using
12954 // decl. Otherwise just silently find the type name.
12955 if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
12956 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
12957 Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
12958 return BuildInvalid();
12959 }
12960 }
12961
12962 // C++14 [namespace.udecl]p6:
12963 // A using-declaration shall not name a namespace.
12964 if (R.getAsSingle<NamespaceDecl>()) {
12965 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
12966 << SS.getRange();
12967 // Suggest using 'using namespace ...' instead.
12968 Diag(SS.getBeginLoc(), diag::note_namespace_using_decl)
12969 << FixItHint::CreateInsertion(SS.getBeginLoc(), "namespace ");
12970 return BuildInvalid();
12971 }
12972
12973 UsingDecl *UD = BuildValid();
12974
12975 // Some additional rules apply to inheriting constructors.
12976 if (UsingName.getName().getNameKind() ==
12978 // Suppress access diagnostics; the access check is instead performed at the
12979 // point of use for an inheriting constructor.
12982 return UD;
12983 }
12984
12985 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
12986 UsingShadowDecl *PrevDecl = nullptr;
12987 if (!CheckUsingShadowDecl(UD, *I, Previous, PrevDecl))
12988 BuildUsingShadowDecl(S, UD, *I, PrevDecl);
12989 }
12990
12991 return UD;
12992}
12993
12995 SourceLocation UsingLoc,
12996 SourceLocation EnumLoc,
12997 SourceLocation NameLoc,
12999 EnumDecl *ED) {
13000 bool Invalid = false;
13001
13003 /// In class scope, check if this is a duplicate, for better a diagnostic.
13004 DeclarationNameInfo UsingEnumName(ED->getDeclName(), NameLoc);
13005 LookupResult Previous(*this, UsingEnumName, LookupUsingDeclName,
13006 RedeclarationKind::ForVisibleRedeclaration);
13007
13008 LookupName(Previous, S);
13009
13010 for (NamedDecl *D : Previous)
13011 if (UsingEnumDecl *UED = dyn_cast<UsingEnumDecl>(D))
13012 if (UED->getEnumDecl() == ED) {
13013 Diag(UsingLoc, diag::err_using_enum_decl_redeclaration)
13014 << SourceRange(EnumLoc, NameLoc);
13015 Diag(D->getLocation(), diag::note_using_enum_decl) << 1;
13016 Invalid = true;
13017 break;
13018 }
13019 }
13020
13021 if (RequireCompleteEnumDecl(ED, NameLoc))
13022 Invalid = true;
13023
13025 EnumLoc, NameLoc, EnumType);
13026 UD->setAccess(AS);
13027 CurContext->addDecl(UD);
13028
13029 if (Invalid) {
13030 UD->setInvalidDecl();
13031 return UD;
13032 }
13033
13034 // Create the shadow decls for each enumerator
13035 for (EnumConstantDecl *EC : ED->enumerators()) {
13036 UsingShadowDecl *PrevDecl = nullptr;
13037 DeclarationNameInfo DNI(EC->getDeclName(), EC->getLocation());
13039 RedeclarationKind::ForVisibleRedeclaration);
13040 LookupName(Previous, S);
13042
13043 if (!CheckUsingShadowDecl(UD, EC, Previous, PrevDecl))
13044 BuildUsingShadowDecl(S, UD, EC, PrevDecl);
13045 }
13046
13047 return UD;
13048}
13049
13051 ArrayRef<NamedDecl *> Expansions) {
13052 assert(isa<UnresolvedUsingValueDecl>(InstantiatedFrom) ||
13053 isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) ||
13054 isa<UsingPackDecl>(InstantiatedFrom));
13055
13056 auto *UPD =
13057 UsingPackDecl::Create(Context, CurContext, InstantiatedFrom, Expansions);
13058 UPD->setAccess(InstantiatedFrom->getAccess());
13059 CurContext->addDecl(UPD);
13060 return UPD;
13061}
13062
13064 assert(!UD->hasTypename() && "expecting a constructor name");
13065
13066 const Type *SourceType = UD->getQualifier()->getAsType();
13067 assert(SourceType &&
13068 "Using decl naming constructor doesn't have type in scope spec.");
13069 CXXRecordDecl *TargetClass = cast<CXXRecordDecl>(CurContext);
13070
13071 // Check whether the named type is a direct base class.
13072 bool AnyDependentBases = false;
13073 auto *Base = findDirectBaseWithType(TargetClass, QualType(SourceType, 0),
13074 AnyDependentBases);
13075 if (!Base && !AnyDependentBases) {
13076 Diag(UD->getUsingLoc(),
13077 diag::err_using_decl_constructor_not_in_direct_base)
13078 << UD->getNameInfo().getSourceRange()
13079 << QualType(SourceType, 0) << TargetClass;
13080 UD->setInvalidDecl();
13081 return true;
13082 }
13083
13084 if (Base)
13085 Base->setInheritConstructors();
13086
13087 return false;
13088}
13089
13091 bool HasTypenameKeyword,
13092 const CXXScopeSpec &SS,
13093 SourceLocation NameLoc,
13094 const LookupResult &Prev) {
13095 NestedNameSpecifier *Qual = SS.getScopeRep();
13096
13097 // C++03 [namespace.udecl]p8:
13098 // C++0x [namespace.udecl]p10:
13099 // A using-declaration is a declaration and can therefore be used
13100 // repeatedly where (and only where) multiple declarations are
13101 // allowed.
13102 //
13103 // That's in non-member contexts.
13105 // A dependent qualifier outside a class can only ever resolve to an
13106 // enumeration type. Therefore it conflicts with any other non-type
13107 // declaration in the same scope.
13108 // FIXME: How should we check for dependent type-type conflicts at block
13109 // scope?
13110 if (Qual->isDependent() && !HasTypenameKeyword) {
13111 for (auto *D : Prev) {
13112 if (!isa<TypeDecl>(D) && !isa<UsingDecl>(D) && !isa<UsingPackDecl>(D)) {
13113 bool OldCouldBeEnumerator =
13114 isa<UnresolvedUsingValueDecl>(D) || isa<EnumConstantDecl>(D);
13115 Diag(NameLoc,
13116 OldCouldBeEnumerator ? diag::err_redefinition
13117 : diag::err_redefinition_different_kind)
13118 << Prev.getLookupName();
13119 Diag(D->getLocation(), diag::note_previous_definition);
13120 return true;
13121 }
13122 }
13123 }
13124 return false;
13125 }
13126
13127 const NestedNameSpecifier *CNNS =
13129 for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
13130 NamedDecl *D = *I;
13131
13132 bool DTypename;
13133 NestedNameSpecifier *DQual;
13134 if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
13135 DTypename = UD->hasTypename();
13136 DQual = UD->getQualifier();
13137 } else if (UnresolvedUsingValueDecl *UD
13138 = dyn_cast<UnresolvedUsingValueDecl>(D)) {
13139 DTypename = false;
13140 DQual = UD->getQualifier();
13141 } else if (UnresolvedUsingTypenameDecl *UD
13142 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
13143 DTypename = true;
13144 DQual = UD->getQualifier();
13145 } else continue;
13146
13147 // using decls differ if one says 'typename' and the other doesn't.
13148 // FIXME: non-dependent using decls?
13149 if (HasTypenameKeyword != DTypename) continue;
13150
13151 // using decls differ if they name different scopes (but note that
13152 // template instantiation can cause this check to trigger when it
13153 // didn't before instantiation).
13154 if (CNNS != Context.getCanonicalNestedNameSpecifier(DQual))
13155 continue;
13156
13157 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
13158 Diag(D->getLocation(), diag::note_using_decl) << 1;
13159 return true;
13160 }
13161
13162 return false;
13163}
13164
13165bool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename,
13166 const CXXScopeSpec &SS,
13167 const DeclarationNameInfo &NameInfo,
13168 SourceLocation NameLoc,
13169 const LookupResult *R, const UsingDecl *UD) {
13170 DeclContext *NamedContext = computeDeclContext(SS);
13171 assert(bool(NamedContext) == (R || UD) && !(R && UD) &&
13172 "resolvable context must have exactly one set of decls");
13173
13174 // C++ 20 permits using an enumerator that does not have a class-hierarchy
13175 // relationship.
13176 bool Cxx20Enumerator = false;
13177 if (NamedContext) {
13178 EnumConstantDecl *EC = nullptr;
13179 if (R)
13180 EC = R->getAsSingle<EnumConstantDecl>();
13181 else if (UD && UD->shadow_size() == 1)
13182 EC = dyn_cast<EnumConstantDecl>(UD->shadow_begin()->getTargetDecl());
13183 if (EC)
13184 Cxx20Enumerator = getLangOpts().CPlusPlus20;
13185
13186 if (auto *ED = dyn_cast<EnumDecl>(NamedContext)) {
13187 // C++14 [namespace.udecl]p7:
13188 // A using-declaration shall not name a scoped enumerator.
13189 // C++20 p1099 permits enumerators.
13190 if (EC && R && ED->isScoped())
13191 Diag(SS.getBeginLoc(),
13193 ? diag::warn_cxx17_compat_using_decl_scoped_enumerator
13194 : diag::ext_using_decl_scoped_enumerator)
13195 << SS.getRange();
13196
13197 // We want to consider the scope of the enumerator
13198 NamedContext = ED->getDeclContext();
13199 }
13200 }
13201
13202 if (!CurContext->isRecord()) {
13203 // C++03 [namespace.udecl]p3:
13204 // C++0x [namespace.udecl]p8:
13205 // A using-declaration for a class member shall be a member-declaration.
13206 // C++20 [namespace.udecl]p7
13207 // ... other than an enumerator ...
13208
13209 // If we weren't able to compute a valid scope, it might validly be a
13210 // dependent class or enumeration scope. If we have a 'typename' keyword,
13211 // the scope must resolve to a class type.
13212 if (NamedContext ? !NamedContext->getRedeclContext()->isRecord()
13213 : !HasTypename)
13214 return false; // OK
13215
13216 Diag(NameLoc,
13217 Cxx20Enumerator
13218 ? diag::warn_cxx17_compat_using_decl_class_member_enumerator
13219 : diag::err_using_decl_can_not_refer_to_class_member)
13220 << SS.getRange();
13221
13222 if (Cxx20Enumerator)
13223 return false; // OK
13224
13225 auto *RD = NamedContext
13226 ? cast<CXXRecordDecl>(NamedContext->getRedeclContext())
13227 : nullptr;
13228 if (RD && !RequireCompleteDeclContext(const_cast<CXXScopeSpec &>(SS), RD)) {
13229 // See if there's a helpful fixit
13230
13231 if (!R) {
13232 // We will have already diagnosed the problem on the template
13233 // definition, Maybe we should do so again?
13234 } else if (R->getAsSingle<TypeDecl>()) {
13235 if (getLangOpts().CPlusPlus11) {
13236 // Convert 'using X::Y;' to 'using Y = X::Y;'.
13237 Diag(SS.getBeginLoc(), diag::note_using_decl_class_member_workaround)
13238 << diag::MemClassWorkaround::AliasDecl
13240 NameInfo.getName().getAsString() +
13241 " = ");
13242 } else {
13243 // Convert 'using X::Y;' to 'typedef X::Y Y;'.
13244 SourceLocation InsertLoc = getLocForEndOfToken(NameInfo.getEndLoc());
13245 Diag(InsertLoc, diag::note_using_decl_class_member_workaround)
13246 << diag::MemClassWorkaround::TypedefDecl
13247 << FixItHint::CreateReplacement(UsingLoc, "typedef")
13249 InsertLoc, " " + NameInfo.getName().getAsString());
13250 }
13251 } else if (R->getAsSingle<VarDecl>()) {
13252 // Don't provide a fixit outside C++11 mode; we don't want to suggest
13253 // repeating the type of the static data member here.
13254 FixItHint FixIt;
13255 if (getLangOpts().CPlusPlus11) {
13256 // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
13258 UsingLoc, "auto &" + NameInfo.getName().getAsString() + " = ");
13259 }
13260
13261 Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
13262 << diag::MemClassWorkaround::ReferenceDecl << FixIt;
13263 } else if (R->getAsSingle<EnumConstantDecl>()) {
13264 // Don't provide a fixit outside C++11 mode; we don't want to suggest
13265 // repeating the type of the enumeration here, and we can't do so if
13266 // the type is anonymous.
13267 FixItHint FixIt;
13268 if (getLangOpts().CPlusPlus11) {
13269 // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
13271 UsingLoc,
13272 "constexpr auto " + NameInfo.getName().getAsString() + " = ");
13273 }
13274
13275 Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
13276 << (getLangOpts().CPlusPlus11
13277 ? diag::MemClassWorkaround::ConstexprVar
13278 : diag::MemClassWorkaround::ConstVar)
13279 << FixIt;
13280 }
13281 }
13282
13283 return true; // Fail
13284 }
13285
13286 // If the named context is dependent, we can't decide much.
13287 if (!NamedContext) {
13288 // FIXME: in C++0x, we can diagnose if we can prove that the
13289 // nested-name-specifier does not refer to a base class, which is
13290 // still possible in some cases.
13291
13292 // Otherwise we have to conservatively report that things might be
13293 // okay.
13294 return false;
13295 }
13296
13297 // The current scope is a record.
13298 if (!NamedContext->isRecord()) {
13299 // Ideally this would point at the last name in the specifier,
13300 // but we don't have that level of source info.
13301 Diag(SS.getBeginLoc(),
13302 Cxx20Enumerator
13303 ? diag::warn_cxx17_compat_using_decl_non_member_enumerator
13304 : diag::err_using_decl_nested_name_specifier_is_not_class)
13305 << SS.getScopeRep() << SS.getRange();
13306
13307 if (Cxx20Enumerator)
13308 return false; // OK
13309
13310 return true;
13311 }
13312
13313 if (!NamedContext->isDependentContext() &&
13314 RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), NamedContext))
13315 return true;
13316
13317 if (getLangOpts().CPlusPlus11) {
13318 // C++11 [namespace.udecl]p3:
13319 // In a using-declaration used as a member-declaration, the
13320 // nested-name-specifier shall name a base class of the class
13321 // being defined.
13322
13323 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
13324 cast<CXXRecordDecl>(NamedContext))) {
13325
13326 if (Cxx20Enumerator) {
13327 Diag(NameLoc, diag::warn_cxx17_compat_using_decl_non_member_enumerator)
13328 << SS.getRange();
13329 return false;
13330 }
13331
13332 if (CurContext == NamedContext) {
13333 Diag(SS.getBeginLoc(),
13334 diag::err_using_decl_nested_name_specifier_is_current_class)
13335 << SS.getRange();
13336 return !getLangOpts().CPlusPlus20;
13337 }
13338
13339 if (!cast<CXXRecordDecl>(NamedContext)->isInvalidDecl()) {
13340 Diag(SS.getBeginLoc(),
13341 diag::err_using_decl_nested_name_specifier_is_not_base_class)
13342 << SS.getScopeRep() << cast<CXXRecordDecl>(CurContext)
13343 << SS.getRange();
13344 }
13345 return true;
13346 }
13347
13348 return false;
13349 }
13350
13351 // C++03 [namespace.udecl]p4:
13352 // A using-declaration used as a member-declaration shall refer
13353 // to a member of a base class of the class being defined [etc.].
13354
13355 // Salient point: SS doesn't have to name a base class as long as
13356 // lookup only finds members from base classes. Therefore we can
13357 // diagnose here only if we can prove that can't happen,
13358 // i.e. if the class hierarchies provably don't intersect.
13359
13360 // TODO: it would be nice if "definitely valid" results were cached
13361 // in the UsingDecl and UsingShadowDecl so that these checks didn't
13362 // need to be repeated.
13363
13365 auto Collect = [&Bases](const CXXRecordDecl *Base) {
13366 Bases.insert(Base);
13367 return true;
13368 };
13369
13370 // Collect all bases. Return false if we find a dependent base.
13371 if (!cast<CXXRecordDecl>(CurContext)->forallBases(Collect))
13372 return false;
13373
13374 // Returns true if the base is dependent or is one of the accumulated base
13375 // classes.
13376 auto IsNotBase = [&Bases](const CXXRecordDecl *Base) {
13377 return !Bases.count(Base);
13378 };
13379
13380 // Return false if the class has a dependent base or if it or one
13381 // of its bases is present in the base set of the current context.
13382 if (Bases.count(cast<CXXRecordDecl>(NamedContext)) ||
13383 !cast<CXXRecordDecl>(NamedContext)->forallBases(IsNotBase))
13384 return false;
13385
13386 Diag(SS.getRange().getBegin(),
13387 diag::err_using_decl_nested_name_specifier_is_not_base_class)
13388 << SS.getScopeRep()
13389 << cast<CXXRecordDecl>(CurContext)
13390 << SS.getRange();
13391
13392 return true;
13393}
13394
13396 MultiTemplateParamsArg TemplateParamLists,
13397 SourceLocation UsingLoc, UnqualifiedId &Name,
13398 const ParsedAttributesView &AttrList,
13399 TypeResult Type, Decl *DeclFromDeclSpec) {
13400 // Get the innermost enclosing declaration scope.
13401 S = S->getDeclParent();
13402
13403 if (Type.isInvalid())
13404 return nullptr;
13405
13406 bool Invalid = false;
13408 TypeSourceInfo *TInfo = nullptr;
13409 GetTypeFromParser(Type.get(), &TInfo);
13410
13411 if (DiagnoseClassNameShadow(CurContext, NameInfo))
13412 return nullptr;
13413
13414 if (DiagnoseUnexpandedParameterPack(Name.StartLocation, TInfo,
13416 Invalid = true;
13418 TInfo->getTypeLoc().getBeginLoc());
13419 }
13420
13421 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
13422 TemplateParamLists.size()
13424 : RedeclarationKind::ForVisibleRedeclaration);
13425 LookupName(Previous, S);
13426
13427 // Warn about shadowing the name of a template parameter.
13428 if (Previous.isSingleResult() &&
13429 Previous.getFoundDecl()->isTemplateParameter()) {
13430 DiagnoseTemplateParameterShadow(Name.StartLocation,Previous.getFoundDecl());
13431 Previous.clear();
13432 }
13433
13434 assert(Name.getKind() == UnqualifiedIdKind::IK_Identifier &&
13435 "name in alias declaration must be an identifier");
13437 Name.StartLocation,
13438 Name.Identifier, TInfo);
13439
13440 NewTD->setAccess(AS);
13441
13442 if (Invalid)
13443 NewTD->setInvalidDecl();
13444
13445 ProcessDeclAttributeList(S, NewTD, AttrList);
13446 AddPragmaAttributes(S, NewTD);
13447 ProcessAPINotes(NewTD);
13448
13450 Invalid |= NewTD->isInvalidDecl();
13451
13452 bool Redeclaration = false;
13453
13454 NamedDecl *NewND;
13455 if (TemplateParamLists.size()) {
13456 TypeAliasTemplateDecl *OldDecl = nullptr;
13457 TemplateParameterList *OldTemplateParams = nullptr;
13458
13459 if (TemplateParamLists.size() != 1) {
13460 Diag(UsingLoc, diag::err_alias_template_extra_headers)
13461 << SourceRange(TemplateParamLists[1]->getTemplateLoc(),
13462 TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
13463 Invalid = true;
13464 }
13465 TemplateParameterList *TemplateParams = TemplateParamLists[0];
13466
13467 // Check that we can declare a template here.
13468 if (CheckTemplateDeclScope(S, TemplateParams))
13469 return nullptr;
13470
13471 // Only consider previous declarations in the same scope.
13472 FilterLookupForScope(Previous, CurContext, S, /*ConsiderLinkage*/false,
13473 /*ExplicitInstantiationOrSpecialization*/false);
13474 if (!Previous.empty()) {
13475 Redeclaration = true;
13476
13477 OldDecl = Previous.getAsSingle<TypeAliasTemplateDecl>();
13478 if (!OldDecl && !Invalid) {
13479 Diag(UsingLoc, diag::err_redefinition_different_kind)
13480 << Name.Identifier;
13481
13482 NamedDecl *OldD = Previous.getRepresentativeDecl();
13483 if (OldD->getLocation().isValid())
13484 Diag(OldD->getLocation(), diag::note_previous_definition);
13485
13486 Invalid = true;
13487 }
13488
13489 if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) {
13490 if (TemplateParameterListsAreEqual(TemplateParams,
13491 OldDecl->getTemplateParameters(),
13492 /*Complain=*/true,
13494 OldTemplateParams =
13496 else
13497 Invalid = true;
13498
13499 TypeAliasDecl *OldTD = OldDecl->getTemplatedDecl();
13500 if (!Invalid &&
13502 NewTD->getUnderlyingType())) {
13503 // FIXME: The C++0x standard does not clearly say this is ill-formed,
13504 // but we can't reasonably accept it.
13505 Diag(NewTD->getLocation(), diag::err_redefinition_different_typedef)
13506 << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType();
13507 if (OldTD->getLocation().isValid())
13508 Diag(OldTD->getLocation(), diag::note_previous_definition);
13509 Invalid = true;
13510 }
13511 }
13512 }
13513
13514 // Merge any previous default template arguments into our parameters,
13515 // and check the parameter list.
13516 if (CheckTemplateParameterList(TemplateParams, OldTemplateParams,
13518 return nullptr;
13519
13520 TypeAliasTemplateDecl *NewDecl =
13522 Name.Identifier, TemplateParams,
13523 NewTD);
13524 NewTD->setDescribedAliasTemplate(NewDecl);
13525
13526 NewDecl->setAccess(AS);
13527
13528 if (Invalid)
13529 NewDecl->setInvalidDecl();
13530 else if (OldDecl) {
13531 NewDecl->setPreviousDecl(OldDecl);
13532 CheckRedeclarationInModule(NewDecl, OldDecl);
13533 }
13534
13535 NewND = NewDecl;
13536 } else {
13537 if (auto *TD = dyn_cast_or_null<TagDecl>(DeclFromDeclSpec)) {
13539 handleTagNumbering(TD, S);
13540 }
13541 ActOnTypedefNameDecl(S, CurContext, NewTD, Previous, Redeclaration);
13542 NewND = NewTD;
13543 }
13544
13545 PushOnScopeChains(NewND, S);
13546 ActOnDocumentableDecl(NewND);
13547 return NewND;
13548}
13549
13551 SourceLocation AliasLoc,
13552 IdentifierInfo *Alias, CXXScopeSpec &SS,
13553 SourceLocation IdentLoc,
13554 IdentifierInfo *Ident) {
13555
13556 // Lookup the namespace name.
13557 LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
13558 LookupParsedName(R, S, &SS, /*ObjectType=*/QualType());
13559
13560 if (R.isAmbiguous())
13561 return nullptr;
13562
13563 if (R.empty()) {
13564 if (!TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, Ident)) {
13565 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
13566 return nullptr;
13567 }
13568 }
13569 assert(!R.isAmbiguous() && !R.empty());
13571
13572 // Check if we have a previous declaration with the same name.
13573 LookupResult PrevR(*this, Alias, AliasLoc, LookupOrdinaryName,
13574 RedeclarationKind::ForVisibleRedeclaration);
13575 LookupName(PrevR, S);
13576
13577 // Check we're not shadowing a template parameter.
13578 if (PrevR.isSingleResult() && PrevR.getFoundDecl()->isTemplateParameter()) {
13580 PrevR.clear();
13581 }
13582
13583 // Filter out any other lookup result from an enclosing scope.
13584 FilterLookupForScope(PrevR, CurContext, S, /*ConsiderLinkage*/false,
13585 /*AllowInlineNamespace*/false);
13586
13587 // Find the previous declaration and check that we can redeclare it.
13588 NamespaceAliasDecl *Prev = nullptr;
13589 if (PrevR.isSingleResult()) {
13590 NamedDecl *PrevDecl = PrevR.getRepresentativeDecl();
13591 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
13592 // We already have an alias with the same name that points to the same
13593 // namespace; check that it matches.
13594 if (AD->getNamespace()->Equals(getNamespaceDecl(ND))) {
13595 Prev = AD;
13596 } else if (isVisible(PrevDecl)) {
13597 Diag(AliasLoc, diag::err_redefinition_different_namespace_alias)
13598 << Alias;
13599 Diag(AD->getLocation(), diag::note_previous_namespace_alias)
13600 << AD->getNamespace();
13601 return nullptr;
13602 }
13603 } else if (isVisible(PrevDecl)) {
13604 unsigned DiagID = isa<NamespaceDecl>(PrevDecl->getUnderlyingDecl())
13605 ? diag::err_redefinition
13606 : diag::err_redefinition_different_kind;
13607 Diag(AliasLoc, DiagID) << Alias;
13608 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
13609 return nullptr;
13610 }
13611 }
13612
13613 // The use of a nested name specifier may trigger deprecation warnings.
13614 DiagnoseUseOfDecl(ND, IdentLoc);
13615
13617 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
13618 Alias, SS.getWithLocInContext(Context),
13619 IdentLoc, ND);
13620 if (Prev)
13621 AliasDecl->setPreviousDecl(Prev);
13622
13624 return AliasDecl;
13625}
13626
13627namespace {
13628struct SpecialMemberExceptionSpecInfo
13629 : SpecialMemberVisitor<SpecialMemberExceptionSpecInfo> {
13632
13633 SpecialMemberExceptionSpecInfo(Sema &S, CXXMethodDecl *MD,
13637 : SpecialMemberVisitor(S, MD, CSM, ICI), Loc(Loc), ExceptSpec(S) {}
13638
13639 bool visitBase(CXXBaseSpecifier *Base);
13640 bool visitField(FieldDecl *FD);
13641
13642 void visitClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
13643 unsigned Quals);
13644
13645 void visitSubobjectCall(Subobject Subobj,
13647};
13648}
13649
13650bool SpecialMemberExceptionSpecInfo::visitBase(CXXBaseSpecifier *Base) {
13651 auto *RT = Base->getType()->getAs<RecordType>();
13652 if (!RT)
13653 return false;
13654
13655 auto *BaseClass = cast<CXXRecordDecl>(RT->getDecl());
13656 Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
13657 if (auto *BaseCtor = SMOR.getMethod()) {
13658 visitSubobjectCall(Base, BaseCtor);
13659 return false;
13660 }
13661
13662 visitClassSubobject(BaseClass, Base, 0);
13663 return false;
13664}
13665
13666bool SpecialMemberExceptionSpecInfo::visitField(FieldDecl *FD) {
13668 FD->hasInClassInitializer()) {
13669 Expr *E = FD->getInClassInitializer();
13670 if (!E)
13671 // FIXME: It's a little wasteful to build and throw away a
13672 // CXXDefaultInitExpr here.
13673 // FIXME: We should have a single context note pointing at Loc, and
13674 // this location should be MD->getLocation() instead, since that's
13675 // the location where we actually use the default init expression.
13676 E = S.BuildCXXDefaultInitExpr(Loc, FD).get();
13677 if (E)
13678 ExceptSpec.CalledExpr(E);
13679 } else if (auto *RT = S.Context.getBaseElementType(FD->getType())
13680 ->getAs<RecordType>()) {
13681 visitClassSubobject(cast<CXXRecordDecl>(RT->getDecl()), FD,
13682 FD->getType().getCVRQualifiers());
13683 }
13684 return false;
13685}
13686
13687void SpecialMemberExceptionSpecInfo::visitClassSubobject(CXXRecordDecl *Class,
13688 Subobject Subobj,
13689 unsigned Quals) {
13690 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
13691 bool IsMutable = Field && Field->isMutable();
13692 visitSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable));
13693}
13694
13695void SpecialMemberExceptionSpecInfo::visitSubobjectCall(
13696 Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR) {
13697 // Note, if lookup fails, it doesn't matter what exception specification we
13698 // choose because the special member will be deleted.
13699 if (CXXMethodDecl *MD = SMOR.getMethod())
13700 ExceptSpec.CalledDecl(getSubobjectLoc(Subobj), MD);
13701}
13702
13704 llvm::APSInt Result;
13706 ExplicitSpec.getExpr(), Context.BoolTy, Result, CCEK_ExplicitBool);
13707 ExplicitSpec.setExpr(Converted.get());
13708 if (Converted.isUsable() && !Converted.get()->isValueDependent()) {
13709 ExplicitSpec.setKind(Result.getBoolValue()
13712 return true;
13713 }
13715 return false;
13716}
13717
13720 if (!ExplicitExpr->isTypeDependent())
13722 return ES;
13723}
13724
13729 ComputingExceptionSpec CES(S, MD, Loc);
13730
13731 CXXRecordDecl *ClassDecl = MD->getParent();
13732
13733 // C++ [except.spec]p14:
13734 // An implicitly declared special member function (Clause 12) shall have an
13735 // exception-specification. [...]
13736 SpecialMemberExceptionSpecInfo Info(S, MD, CSM, ICI, MD->getLocation());
13737 if (ClassDecl->isInvalidDecl())
13738 return Info.ExceptSpec;
13739
13740 // FIXME: If this diagnostic fires, we're probably missing a check for
13741 // attempting to resolve an exception specification before it's known
13742 // at a higher level.
13743 if (S.RequireCompleteType(MD->getLocation(),
13744 S.Context.getRecordType(ClassDecl),
13745 diag::err_exception_spec_incomplete_type))
13746 return Info.ExceptSpec;
13747
13748 // C++1z [except.spec]p7:
13749 // [Look for exceptions thrown by] a constructor selected [...] to
13750 // initialize a potentially constructed subobject,
13751 // C++1z [except.spec]p8:
13752 // The exception specification for an implicitly-declared destructor, or a
13753 // destructor without a noexcept-specifier, is potentially-throwing if and
13754 // only if any of the destructors for any of its potentially constructed
13755 // subojects is potentially throwing.
13756 // FIXME: We respect the first rule but ignore the "potentially constructed"
13757 // in the second rule to resolve a core issue (no number yet) that would have
13758 // us reject:
13759 // struct A { virtual void f() = 0; virtual ~A() noexcept(false) = 0; };
13760 // struct B : A {};
13761 // struct C : B { void f(); };
13762 // ... due to giving B::~B() a non-throwing exception specification.
13763 Info.visit(Info.IsConstructor ? Info.VisitPotentiallyConstructedBases
13764 : Info.VisitAllBases);
13765
13766 return Info.ExceptSpec;
13767}
13768
13769namespace {
13770/// RAII object to register a special member as being currently declared.
13771struct DeclaringSpecialMember {
13772 Sema &S;
13774 Sema::ContextRAII SavedContext;
13775 bool WasAlreadyBeingDeclared;
13776
13777 DeclaringSpecialMember(Sema &S, CXXRecordDecl *RD, CXXSpecialMemberKind CSM)
13778 : S(S), D(RD, CSM), SavedContext(S, RD) {
13779 WasAlreadyBeingDeclared = !S.SpecialMembersBeingDeclared.insert(D).second;
13780 if (WasAlreadyBeingDeclared)
13781 // This almost never happens, but if it does, ensure that our cache
13782 // doesn't contain a stale result.
13783 S.SpecialMemberCache.clear();
13784 else {
13785 // Register a note to be produced if we encounter an error while
13786 // declaring the special member.
13789 // FIXME: We don't have a location to use here. Using the class's
13790 // location maintains the fiction that we declare all special members
13791 // with the class, but (1) it's not clear that lying about that helps our
13792 // users understand what's going on, and (2) there may be outer contexts
13793 // on the stack (some of which are relevant) and printing them exposes
13794 // our lies.
13796 Ctx.Entity = RD;
13797 Ctx.SpecialMember = CSM;
13799 }
13800 }
13801 ~DeclaringSpecialMember() {
13802 if (!WasAlreadyBeingDeclared) {
13805 }
13806 }
13807
13808 /// Are we already trying to declare this special member?
13809 bool isAlreadyBeingDeclared() const {
13810 return WasAlreadyBeingDeclared;
13811 }
13812};
13813}
13814
13816 // Look up any existing declarations, but don't trigger declaration of all
13817 // implicit special members with this name.
13818 DeclarationName Name = FD->getDeclName();
13820 RedeclarationKind::ForExternalRedeclaration);
13821 for (auto *D : FD->getParent()->lookup(Name))
13822 if (auto *Acceptable = R.getAcceptableDecl(D))
13823 R.addDecl(Acceptable);
13824 R.resolveKind();
13826
13827 CheckFunctionDeclaration(S, FD, R, /*IsMemberSpecialization*/ false,
13829}
13830
13831void Sema::setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem,
13832 QualType ResultTy,
13833 ArrayRef<QualType> Args) {
13834 // Build an exception specification pointing back at this constructor.
13836
13838 if (AS != LangAS::Default) {
13839 EPI.TypeQuals.addAddressSpace(AS);
13840 }
13841
13842 auto QT = Context.getFunctionType(ResultTy, Args, EPI);
13843 SpecialMem->setType(QT);
13844
13845 // During template instantiation of implicit special member functions we need
13846 // a reliable TypeSourceInfo for the function prototype in order to allow
13847 // functions to be substituted.
13849 cast<CXXRecordDecl>(SpecialMem->getParent())->isLambda()) {
13850 TypeSourceInfo *TSI =
13852 SpecialMem->setTypeSourceInfo(TSI);
13853 }
13854}
13855
13857 CXXRecordDecl *ClassDecl) {
13858 // C++ [class.ctor]p5:
13859 // A default constructor for a class X is a constructor of class X
13860 // that can be called without an argument. If there is no
13861 // user-declared constructor for class X, a default constructor is
13862 // implicitly declared. An implicitly-declared default constructor
13863 // is an inline public member of its class.
13864 assert(ClassDecl->needsImplicitDefaultConstructor() &&
13865 "Should not build implicit default constructor!");
13866
13867 DeclaringSpecialMember DSM(*this, ClassDecl,
13869 if (DSM.isAlreadyBeingDeclared())
13870 return nullptr;
13871
13873 *this, ClassDecl, CXXSpecialMemberKind::DefaultConstructor, false);
13874
13875 // Create the actual constructor declaration.
13876 CanQualType ClassType
13878 SourceLocation ClassLoc = ClassDecl->getLocation();
13879 DeclarationName Name
13881 DeclarationNameInfo NameInfo(Name, ClassLoc);
13883 Context, ClassDecl, ClassLoc, NameInfo, /*Type*/ QualType(),
13884 /*TInfo=*/nullptr, ExplicitSpecifier(),
13885 getCurFPFeatures().isFPConstrained(),
13886 /*isInline=*/true, /*isImplicitlyDeclared=*/true,
13889 DefaultCon->setAccess(AS_public);
13890 DefaultCon->setDefaulted();
13891
13892 setupImplicitSpecialMemberType(DefaultCon, Context.VoidTy, {});
13893
13894 if (getLangOpts().CUDA)
13896 ClassDecl, CXXSpecialMemberKind::DefaultConstructor, DefaultCon,
13897 /* ConstRHS */ false,
13898 /* Diagnose */ false);
13899
13900 // We don't need to use SpecialMemberIsTrivial here; triviality for default
13901 // constructors is easy to compute.
13902 DefaultCon->setTrivial(ClassDecl->hasTrivialDefaultConstructor());
13903
13904 // Note that we have declared this constructor.
13906
13907 Scope *S = getScopeForContext(ClassDecl);
13909
13910 if (ShouldDeleteSpecialMember(DefaultCon,
13912 SetDeclDeleted(DefaultCon, ClassLoc);
13913
13914 if (S)
13915 PushOnScopeChains(DefaultCon, S, false);
13916 ClassDecl->addDecl(DefaultCon);
13917
13918 return DefaultCon;
13919}
13920
13922 CXXConstructorDecl *Constructor) {
13923 assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
13924 !Constructor->doesThisDeclarationHaveABody() &&
13925 !Constructor->isDeleted()) &&
13926 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
13927 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
13928 return;
13929
13930 CXXRecordDecl *ClassDecl = Constructor->getParent();
13931 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
13932 if (ClassDecl->isInvalidDecl()) {
13933 return;
13934 }
13935
13936 SynthesizedFunctionScope Scope(*this, Constructor);
13937
13938 // The exception specification is needed because we are defining the
13939 // function.
13940 ResolveExceptionSpec(CurrentLocation,
13941 Constructor->getType()->castAs<FunctionProtoType>());
13942 MarkVTableUsed(CurrentLocation, ClassDecl);
13943
13944 // Add a context note for diagnostics produced after this point.
13945 Scope.addContextNote(CurrentLocation);
13946
13947 if (SetCtorInitializers(Constructor, /*AnyErrors=*/false)) {
13948 Constructor->setInvalidDecl();
13949 return;
13950 }
13951
13952 SourceLocation Loc = Constructor->getEndLoc().isValid()
13953 ? Constructor->getEndLoc()
13954 : Constructor->getLocation();
13955 Constructor->setBody(new (Context) CompoundStmt(Loc));
13956 Constructor->markUsed(Context);
13957
13959 L->CompletedImplicitDefinition(Constructor);
13960 }
13961
13962 DiagnoseUninitializedFields(*this, Constructor);
13963}
13964
13966 // Perform any delayed checks on exception specifications.
13968}
13969
13970/// Find or create the fake constructor we synthesize to model constructing an
13971/// object of a derived class via a constructor of a base class.
13974 CXXConstructorDecl *BaseCtor,
13976 CXXRecordDecl *Derived = Shadow->getParent();
13977 SourceLocation UsingLoc = Shadow->getLocation();
13978
13979 // FIXME: Add a new kind of DeclarationName for an inherited constructor.
13980 // For now we use the name of the base class constructor as a member of the
13981 // derived class to indicate a (fake) inherited constructor name.
13982 DeclarationName Name = BaseCtor->getDeclName();
13983
13984 // Check to see if we already have a fake constructor for this inherited
13985 // constructor call.
13986 for (NamedDecl *Ctor : Derived->lookup(Name))
13987 if (declaresSameEntity(cast<CXXConstructorDecl>(Ctor)
13988 ->getInheritedConstructor()
13989 .getConstructor(),
13990 BaseCtor))
13991 return cast<CXXConstructorDecl>(Ctor);
13992
13993 DeclarationNameInfo NameInfo(Name, UsingLoc);
13994 TypeSourceInfo *TInfo =
13995 Context.getTrivialTypeSourceInfo(BaseCtor->getType(), UsingLoc);
13996 FunctionProtoTypeLoc ProtoLoc =
13998
13999 // Check the inherited constructor is valid and find the list of base classes
14000 // from which it was inherited.
14001 InheritedConstructorInfo ICI(*this, Loc, Shadow);
14002
14003 bool Constexpr = BaseCtor->isConstexpr() &&
14006 false, BaseCtor, &ICI);
14007
14009 Context, Derived, UsingLoc, NameInfo, TInfo->getType(), TInfo,
14010 BaseCtor->getExplicitSpecifier(), getCurFPFeatures().isFPConstrained(),
14011 /*isInline=*/true,
14012 /*isImplicitlyDeclared=*/true,
14014 InheritedConstructor(Shadow, BaseCtor),
14015 BaseCtor->getTrailingRequiresClause());
14016 if (Shadow->isInvalidDecl())
14017 DerivedCtor->setInvalidDecl();
14018
14019 // Build an unevaluated exception specification for this fake constructor.
14020 const FunctionProtoType *FPT = TInfo->getType()->castAs<FunctionProtoType>();
14023 EPI.ExceptionSpec.SourceDecl = DerivedCtor;
14024 DerivedCtor->setType(Context.getFunctionType(FPT->getReturnType(),
14025 FPT->getParamTypes(), EPI));
14026
14027 // Build the parameter declarations.
14029 for (unsigned I = 0, N = FPT->getNumParams(); I != N; ++I) {
14030 TypeSourceInfo *TInfo =
14033 Context, DerivedCtor, UsingLoc, UsingLoc, /*IdentifierInfo=*/nullptr,
14034 FPT->getParamType(I), TInfo, SC_None, /*DefArg=*/nullptr);
14035 PD->setScopeInfo(0, I);
14036 PD->setImplicit();
14037 // Ensure attributes are propagated onto parameters (this matters for
14038 // format, pass_object_size, ...).
14039 mergeDeclAttributes(PD, BaseCtor->getParamDecl(I));
14040 ParamDecls.push_back(PD);
14041 ProtoLoc.setParam(I, PD);
14042 }
14043
14044 // Set up the new constructor.
14045 assert(!BaseCtor->isDeleted() && "should not use deleted constructor");
14046 DerivedCtor->setAccess(BaseCtor->getAccess());
14047 DerivedCtor->setParams(ParamDecls);
14048 Derived->addDecl(DerivedCtor);
14049
14050 if (ShouldDeleteSpecialMember(DerivedCtor,
14052 SetDeclDeleted(DerivedCtor, UsingLoc);
14053
14054 return DerivedCtor;
14055}
14056
14058 InheritedConstructorInfo ICI(*this, Ctor->getLocation(),
14061 &ICI,
14062 /*Diagnose*/ true);
14063}
14064
14066 CXXConstructorDecl *Constructor) {
14067 CXXRecordDecl *ClassDecl = Constructor->getParent();
14068 assert(Constructor->getInheritedConstructor() &&
14069 !Constructor->doesThisDeclarationHaveABody() &&
14070 !Constructor->isDeleted());
14071 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
14072 return;
14073
14074 // Initializations are performed "as if by a defaulted default constructor",
14075 // so enter the appropriate scope.
14076 SynthesizedFunctionScope Scope(*this, Constructor);
14077
14078 // The exception specification is needed because we are defining the
14079 // function.
14080 ResolveExceptionSpec(CurrentLocation,
14081 Constructor->getType()->castAs<FunctionProtoType>());
14082 MarkVTableUsed(CurrentLocation, ClassDecl);
14083
14084 // Add a context note for diagnostics produced after this point.
14085 Scope.addContextNote(CurrentLocation);
14086
14088 Constructor->getInheritedConstructor().getShadowDecl();
14089 CXXConstructorDecl *InheritedCtor =
14090 Constructor->getInheritedConstructor().getConstructor();
14091
14092 // [class.inhctor.init]p1:
14093 // initialization proceeds as if a defaulted default constructor is used to
14094 // initialize the D object and each base class subobject from which the
14095 // constructor was inherited
14096
14097 InheritedConstructorInfo ICI(*this, CurrentLocation, Shadow);
14098 CXXRecordDecl *RD = Shadow->getParent();
14099 SourceLocation InitLoc = Shadow->getLocation();
14100
14101 // Build explicit initializers for all base classes from which the
14102 // constructor was inherited.
14104 for (bool VBase : {false, true}) {
14105 for (CXXBaseSpecifier &B : VBase ? RD->vbases() : RD->bases()) {
14106 if (B.isVirtual() != VBase)
14107 continue;
14108
14109 auto *BaseRD = B.getType()->getAsCXXRecordDecl();
14110 if (!BaseRD)
14111 continue;
14112
14113 auto BaseCtor = ICI.findConstructorForBase(BaseRD, InheritedCtor);
14114 if (!BaseCtor.first)
14115 continue;
14116
14117 MarkFunctionReferenced(CurrentLocation, BaseCtor.first);
14119 InitLoc, B.getType(), BaseCtor.first, VBase, BaseCtor.second);
14120
14121 auto *TInfo = Context.getTrivialTypeSourceInfo(B.getType(), InitLoc);
14122 Inits.push_back(new (Context) CXXCtorInitializer(
14123 Context, TInfo, VBase, InitLoc, Init.get(), InitLoc,
14124 SourceLocation()));
14125 }
14126 }
14127
14128 // We now proceed as if for a defaulted default constructor, with the relevant
14129 // initializers replaced.
14130
14131 if (SetCtorInitializers(Constructor, /*AnyErrors*/false, Inits)) {
14132 Constructor->setInvalidDecl();
14133 return;
14134 }
14135
14136 Constructor->setBody(new (Context) CompoundStmt(InitLoc));
14137 Constructor->markUsed(Context);
14138
14140 L->CompletedImplicitDefinition(Constructor);
14141 }
14142
14143 DiagnoseUninitializedFields(*this, Constructor);
14144}
14145
14147 // C++ [class.dtor]p2:
14148 // If a class has no user-declared destructor, a destructor is
14149 // declared implicitly. An implicitly-declared destructor is an
14150 // inline public member of its class.
14151 assert(ClassDecl->needsImplicitDestructor());
14152
14153 DeclaringSpecialMember DSM(*this, ClassDecl,
14155 if (DSM.isAlreadyBeingDeclared())
14156 return nullptr;
14157
14159 *this, ClassDecl, CXXSpecialMemberKind::Destructor, false);
14160
14161 // Create the actual destructor declaration.
14162 CanQualType ClassType
14164 SourceLocation ClassLoc = ClassDecl->getLocation();
14165 DeclarationName Name
14167 DeclarationNameInfo NameInfo(Name, ClassLoc);
14169 Context, ClassDecl, ClassLoc, NameInfo, QualType(), nullptr,
14170 getCurFPFeatures().isFPConstrained(),
14171 /*isInline=*/true,
14172 /*isImplicitlyDeclared=*/true,
14175 Destructor->setAccess(AS_public);
14176 Destructor->setDefaulted();
14177
14178 setupImplicitSpecialMemberType(Destructor, Context.VoidTy, {});
14179
14180 if (getLangOpts().CUDA)
14183 /* ConstRHS */ false,
14184 /* Diagnose */ false);
14185
14186 // We don't need to use SpecialMemberIsTrivial here; triviality for
14187 // destructors is easy to compute.
14188 Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
14189 Destructor->setTrivialForCall(ClassDecl->hasAttr<TrivialABIAttr>() ||
14190 ClassDecl->hasTrivialDestructorForCall());
14191
14192 // Note that we have declared this destructor.
14194
14195 Scope *S = getScopeForContext(ClassDecl);
14197
14198 // We can't check whether an implicit destructor is deleted before we complete
14199 // the definition of the class, because its validity depends on the alignment
14200 // of the class. We'll check this from ActOnFields once the class is complete.
14201 if (ClassDecl->isCompleteDefinition() &&
14203 SetDeclDeleted(Destructor, ClassLoc);
14204
14205 // Introduce this destructor into its scope.
14206 if (S)
14207 PushOnScopeChains(Destructor, S, false);
14208 ClassDecl->addDecl(Destructor);
14209
14210 return Destructor;
14211}
14212
14215 assert((Destructor->isDefaulted() &&
14216 !Destructor->doesThisDeclarationHaveABody() &&
14217 !Destructor->isDeleted()) &&
14218 "DefineImplicitDestructor - call it for implicit default dtor");
14219 if (Destructor->willHaveBody() || Destructor->isInvalidDecl())
14220 return;
14221
14222 CXXRecordDecl *ClassDecl = Destructor->getParent();
14223 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
14224
14226
14227 // The exception specification is needed because we are defining the
14228 // function.
14229 ResolveExceptionSpec(CurrentLocation,
14230 Destructor->getType()->castAs<FunctionProtoType>());
14231 MarkVTableUsed(CurrentLocation, ClassDecl);
14232
14233 // Add a context note for diagnostics produced after this point.
14234 Scope.addContextNote(CurrentLocation);
14235
14237 Destructor->getParent());
14238
14240 Destructor->setInvalidDecl();
14241 return;
14242 }
14243
14244 SourceLocation Loc = Destructor->getEndLoc().isValid()
14245 ? Destructor->getEndLoc()
14246 : Destructor->getLocation();
14247 Destructor->setBody(new (Context) CompoundStmt(Loc));
14248 Destructor->markUsed(Context);
14249
14251 L->CompletedImplicitDefinition(Destructor);
14252 }
14253}
14254
14257 if (Destructor->isInvalidDecl())
14258 return;
14259
14260 CXXRecordDecl *ClassDecl = Destructor->getParent();
14262 "implicit complete dtors unneeded outside MS ABI");
14263 assert(ClassDecl->getNumVBases() > 0 &&
14264 "complete dtor only exists for classes with vbases");
14265
14267
14268 // Add a context note for diagnostics produced after this point.
14269 Scope.addContextNote(CurrentLocation);
14270
14271 MarkVirtualBaseDestructorsReferenced(Destructor->getLocation(), ClassDecl);
14272}
14273
14275 // If the context is an invalid C++ class, just suppress these checks.
14276 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(CurContext)) {
14277 if (Record->isInvalidDecl()) {
14280 return;
14281 }
14283 }
14284}
14285
14288
14289 if (!DelayedDllExportMemberFunctions.empty()) {
14291 std::swap(DelayedDllExportMemberFunctions, WorkList);
14292 for (CXXMethodDecl *M : WorkList) {
14293 DefineDefaultedFunction(*this, M, M->getLocation());
14294
14295 // Pass the method to the consumer to get emitted. This is not necessary
14296 // for explicit instantiation definitions, as they will get emitted
14297 // anyway.
14298 if (M->getParent()->getTemplateSpecializationKind() !=
14301 }
14302 }
14303}
14304
14306 if (!DelayedDllExportClasses.empty()) {
14307 // Calling ReferenceDllExportedMembers might cause the current function to
14308 // be called again, so use a local copy of DelayedDllExportClasses.
14310 std::swap(DelayedDllExportClasses, WorkList);
14311 for (CXXRecordDecl *Class : WorkList)
14313 }
14314}
14315
14317 assert(getLangOpts().CPlusPlus11 &&
14318 "adjusting dtor exception specs was introduced in c++11");
14319
14320 if (Destructor->isDependentContext())
14321 return;
14322
14323 // C++11 [class.dtor]p3:
14324 // A declaration of a destructor that does not have an exception-
14325 // specification is implicitly considered to have the same exception-
14326 // specification as an implicit declaration.
14327 const auto *DtorType = Destructor->getType()->castAs<FunctionProtoType>();
14328 if (DtorType->hasExceptionSpec())
14329 return;
14330
14331 // Replace the destructor's type, building off the existing one. Fortunately,
14332 // the only thing of interest in the destructor type is its extended info.
14333 // The return and arguments are fixed.
14334 FunctionProtoType::ExtProtoInfo EPI = DtorType->getExtProtoInfo();
14337 Destructor->setType(Context.getFunctionType(Context.VoidTy, {}, EPI));
14338
14339 // FIXME: If the destructor has a body that could throw, and the newly created
14340 // spec doesn't allow exceptions, we should emit a warning, because this
14341 // change in behavior can break conforming C++03 programs at runtime.
14342 // However, we don't have a body or an exception specification yet, so it
14343 // needs to be done somewhere else.
14344}
14345
14346namespace {
14347/// An abstract base class for all helper classes used in building the
14348// copy/move operators. These classes serve as factory functions and help us
14349// avoid using the same Expr* in the AST twice.
14350class ExprBuilder {
14351 ExprBuilder(const ExprBuilder&) = delete;
14352 ExprBuilder &operator=(const ExprBuilder&) = delete;
14353
14354protected:
14355 static Expr *assertNotNull(Expr *E) {
14356 assert(E && "Expression construction must not fail.");
14357 return E;
14358 }
14359
14360public:
14361 ExprBuilder() {}
14362 virtual ~ExprBuilder() {}
14363
14364 virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
14365};
14366
14367class RefBuilder: public ExprBuilder {
14368 VarDecl *Var;
14369 QualType VarType;
14370
14371public:
14372 Expr *build(Sema &S, SourceLocation Loc) const override {
14373 return assertNotNull(S.BuildDeclRefExpr(Var, VarType, VK_LValue, Loc));
14374 }
14375
14376 RefBuilder(VarDecl *Var, QualType VarType)
14377 : Var(Var), VarType(VarType) {}
14378};
14379
14380class ThisBuilder: public ExprBuilder {
14381public:
14382 Expr *build(Sema &S, SourceLocation Loc) const override {
14383 return assertNotNull(S.ActOnCXXThis(Loc).getAs<Expr>());
14384 }
14385};
14386
14387class CastBuilder: public ExprBuilder {
14388 const ExprBuilder &Builder;
14389 QualType Type;
14391 const CXXCastPath &Path;
14392
14393public:
14394 Expr *build(Sema &S, SourceLocation Loc) const override {
14395 return assertNotNull(S.ImpCastExprToType(Builder.build(S, Loc), Type,
14396 CK_UncheckedDerivedToBase, Kind,
14397 &Path).get());
14398 }
14399
14400 CastBuilder(const ExprBuilder &Builder, QualType Type, ExprValueKind Kind,
14401 const CXXCastPath &Path)
14402 : Builder(Builder), Type(Type), Kind(Kind), Path(Path) {}
14403};
14404
14405class DerefBuilder: public ExprBuilder {
14406 const ExprBuilder &Builder;
14407
14408public:
14409 Expr *build(Sema &S, SourceLocation Loc) const override {
14410 return assertNotNull(
14411 S.CreateBuiltinUnaryOp(Loc, UO_Deref, Builder.build(S, Loc)).get());
14412 }
14413
14414 DerefBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
14415};
14416
14417class MemberBuilder: public ExprBuilder {
14418 const ExprBuilder &Builder;
14419 QualType Type;
14420 CXXScopeSpec SS;
14421 bool IsArrow;
14422 LookupResult &MemberLookup;
14423
14424public:
14425 Expr *build(Sema &S, SourceLocation Loc) const override {
14426 return assertNotNull(S.BuildMemberReferenceExpr(
14427 Builder.build(S, Loc), Type, Loc, IsArrow, SS, SourceLocation(),
14428 nullptr, MemberLookup, nullptr, nullptr).get());
14429 }
14430
14431 MemberBuilder(const ExprBuilder &Builder, QualType Type, bool IsArrow,
14432 LookupResult &MemberLookup)
14433 : Builder(Builder), Type(Type), IsArrow(IsArrow),
14434 MemberLookup(MemberLookup) {}
14435};
14436
14437class MoveCastBuilder: public ExprBuilder {
14438 const ExprBuilder &Builder;
14439
14440public:
14441 Expr *build(Sema &S, SourceLocation Loc) const override {
14442 return assertNotNull(CastForMoving(S, Builder.build(S, Loc)));
14443 }
14444
14445 MoveCastBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
14446};
14447
14448class LvalueConvBuilder: public ExprBuilder {
14449 const ExprBuilder &Builder;
14450
14451public:
14452 Expr *build(Sema &S, SourceLocation Loc) const override {
14453 return assertNotNull(
14454 S.DefaultLvalueConversion(Builder.build(S, Loc)).get());
14455 }
14456
14457 LvalueConvBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
14458};
14459
14460class SubscriptBuilder: public ExprBuilder {
14461 const ExprBuilder &Base;
14462 const ExprBuilder &Index;
14463
14464public:
14465 Expr *build(Sema &S, SourceLocation Loc) const override {
14466 return assertNotNull(S.CreateBuiltinArraySubscriptExpr(
14467 Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).get());
14468 }
14469
14470 SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index)
14471 : Base(Base), Index(Index) {}
14472};
14473
14474} // end anonymous namespace
14475
14476/// When generating a defaulted copy or move assignment operator, if a field
14477/// should be copied with __builtin_memcpy rather than via explicit assignments,
14478/// do so. This optimization only applies for arrays of scalars, and for arrays
14479/// of class type where the selected copy/move-assignment operator is trivial.
14480static StmtResult
14482 const ExprBuilder &ToB, const ExprBuilder &FromB) {
14483 // Compute the size of the memory buffer to be copied.
14484 QualType SizeType = S.Context.getSizeType();
14485 llvm::APInt Size(S.Context.getTypeSize(SizeType),
14487
14488 // Take the address of the field references for "from" and "to". We
14489 // directly construct UnaryOperators here because semantic analysis
14490 // does not permit us to take the address of an xvalue.
14491 Expr *From = FromB.build(S, Loc);
14492 From = UnaryOperator::Create(
14493 S.Context, From, UO_AddrOf, S.Context.getPointerType(From->getType()),
14495 Expr *To = ToB.build(S, Loc);
14497 S.Context, To, UO_AddrOf, S.Context.getPointerType(To->getType()),
14499
14500 const Type *E = T->getBaseElementTypeUnsafe();
14501 bool NeedsCollectableMemCpy =
14502 E->isRecordType() &&
14503 E->castAs<RecordType>()->getDecl()->hasObjectMember();
14504
14505 // Create a reference to the __builtin_objc_memmove_collectable function
14506 StringRef MemCpyName = NeedsCollectableMemCpy ?
14507 "__builtin_objc_memmove_collectable" :
14508 "__builtin_memcpy";
14509 LookupResult R(S, &S.Context.Idents.get(MemCpyName), Loc,
14511 S.LookupName(R, S.TUScope, true);
14512
14513 FunctionDecl *MemCpy = R.getAsSingle<FunctionDecl>();
14514 if (!MemCpy)
14515 // Something went horribly wrong earlier, and we will have complained
14516 // about it.
14517 return StmtError();
14518
14519 ExprResult MemCpyRef = S.BuildDeclRefExpr(MemCpy, S.Context.BuiltinFnTy,
14520 VK_PRValue, Loc, nullptr);
14521 assert(MemCpyRef.isUsable() && "Builtin reference cannot fail");
14522
14523 Expr *CallArgs[] = {
14524 To, From, IntegerLiteral::Create(S.Context, Size, SizeType, Loc)
14525 };
14526 ExprResult Call = S.BuildCallExpr(/*Scope=*/nullptr, MemCpyRef.get(),
14527 Loc, CallArgs, Loc);
14528
14529 assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!");
14530 return Call.getAs<Stmt>();
14531}
14532
14533/// Builds a statement that copies/moves the given entity from \p From to
14534/// \c To.
14535///
14536/// This routine is used to copy/move the members of a class with an
14537/// implicitly-declared copy/move assignment operator. When the entities being
14538/// copied are arrays, this routine builds for loops to copy them.
14539///
14540/// \param S The Sema object used for type-checking.
14541///
14542/// \param Loc The location where the implicit copy/move is being generated.
14543///
14544/// \param T The type of the expressions being copied/moved. Both expressions
14545/// must have this type.
14546///
14547/// \param To The expression we are copying/moving to.
14548///
14549/// \param From The expression we are copying/moving from.
14550///
14551/// \param CopyingBaseSubobject Whether we're copying/moving a base subobject.
14552/// Otherwise, it's a non-static member subobject.
14553///
14554/// \param Copying Whether we're copying or moving.
14555///
14556/// \param Depth Internal parameter recording the depth of the recursion.
14557///
14558/// \returns A statement or a loop that copies the expressions, or StmtResult(0)
14559/// if a memcpy should be used instead.
14560static StmtResult
14562 const ExprBuilder &To, const ExprBuilder &From,
14563 bool CopyingBaseSubobject, bool Copying,
14564 unsigned Depth = 0) {
14565 // C++11 [class.copy]p28:
14566 // Each subobject is assigned in the manner appropriate to its type:
14567 //
14568 // - if the subobject is of class type, as if by a call to operator= with
14569 // the subobject as the object expression and the corresponding
14570 // subobject of x as a single function argument (as if by explicit
14571 // qualification; that is, ignoring any possible virtual overriding
14572 // functions in more derived classes);
14573 //
14574 // C++03 [class.copy]p13:
14575 // - if the subobject is of class type, the copy assignment operator for
14576 // the class is used (as if by explicit qualification; that is,
14577 // ignoring any possible virtual overriding functions in more derived
14578 // classes);
14579 if (const RecordType *RecordTy = T->getAs<RecordType>()) {
14580 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
14581
14582 // Look for operator=.
14583 DeclarationName Name
14585 LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName);
14586 S.LookupQualifiedName(OpLookup, ClassDecl, false);
14587
14588 // Prior to C++11, filter out any result that isn't a copy/move-assignment
14589 // operator.
14590 if (!S.getLangOpts().CPlusPlus11) {
14591 LookupResult::Filter F = OpLookup.makeFilter();
14592 while (F.hasNext()) {
14593 NamedDecl *D = F.next();
14594 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
14595 if (Method->isCopyAssignmentOperator() ||
14596 (!Copying && Method->isMoveAssignmentOperator()))
14597 continue;
14598
14599 F.erase();
14600 }
14601 F.done();
14602 }
14603
14604 // Suppress the protected check (C++ [class.protected]) for each of the
14605 // assignment operators we found. This strange dance is required when
14606 // we're assigning via a base classes's copy-assignment operator. To
14607 // ensure that we're getting the right base class subobject (without
14608 // ambiguities), we need to cast "this" to that subobject type; to
14609 // ensure that we don't go through the virtual call mechanism, we need
14610 // to qualify the operator= name with the base class (see below). However,
14611 // this means that if the base class has a protected copy assignment
14612 // operator, the protected member access check will fail. So, we
14613 // rewrite "protected" access to "public" access in this case, since we
14614 // know by construction that we're calling from a derived class.
14615 if (CopyingBaseSubobject) {
14616 for (LookupResult::iterator L = OpLookup.begin(), LEnd = OpLookup.end();
14617 L != LEnd; ++L) {
14618 if (L.getAccess() == AS_protected)
14619 L.setAccess(AS_public);
14620 }
14621 }
14622
14623 // Create the nested-name-specifier that will be used to qualify the
14624 // reference to operator=; this is required to suppress the virtual
14625 // call mechanism.
14626 CXXScopeSpec SS;
14627 const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
14628 SS.MakeTrivial(S.Context,
14629 NestedNameSpecifier::Create(S.Context, nullptr, false,
14630 CanonicalT),
14631 Loc);
14632
14633 // Create the reference to operator=.
14634 ExprResult OpEqualRef
14635 = S.BuildMemberReferenceExpr(To.build(S, Loc), T, Loc, /*IsArrow=*/false,
14636 SS, /*TemplateKWLoc=*/SourceLocation(),
14637 /*FirstQualifierInScope=*/nullptr,
14638 OpLookup,
14639 /*TemplateArgs=*/nullptr, /*S*/nullptr,
14640 /*SuppressQualifierCheck=*/true);
14641 if (OpEqualRef.isInvalid())
14642 return StmtError();
14643
14644 // Build the call to the assignment operator.
14645
14646 Expr *FromInst = From.build(S, Loc);
14647 ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/nullptr,
14648 OpEqualRef.getAs<Expr>(),
14649 Loc, FromInst, Loc);
14650 if (Call.isInvalid())
14651 return StmtError();
14652
14653 // If we built a call to a trivial 'operator=' while copying an array,
14654 // bail out. We'll replace the whole shebang with a memcpy.
14655 CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(Call.get());
14656 if (CE && CE->getMethodDecl()->isTrivial() && Depth)
14657 return StmtResult((Stmt*)nullptr);
14658
14659 // Convert to an expression-statement, and clean up any produced
14660 // temporaries.
14661 return S.ActOnExprStmt(Call);
14662 }
14663
14664 // - if the subobject is of scalar type, the built-in assignment
14665 // operator is used.
14667 if (!ArrayTy) {
14668 ExprResult Assignment = S.CreateBuiltinBinOp(
14669 Loc, BO_Assign, To.build(S, Loc), From.build(S, Loc));
14670 if (Assignment.isInvalid())
14671 return StmtError();
14672 return S.ActOnExprStmt(Assignment);
14673 }
14674
14675 // - if the subobject is an array, each element is assigned, in the
14676 // manner appropriate to the element type;
14677
14678 // Construct a loop over the array bounds, e.g.,
14679 //
14680 // for (__SIZE_TYPE__ i0 = 0; i0 != array-size; ++i0)
14681 //
14682 // that will copy each of the array elements.
14683 QualType SizeType = S.Context.getSizeType();
14684
14685 // Create the iteration variable.
14686 IdentifierInfo *IterationVarName = nullptr;
14687 {
14688 SmallString<8> Str;
14689 llvm::raw_svector_ostream OS(Str);
14690 OS << "__i" << Depth;
14691 IterationVarName = &S.Context.Idents.get(OS.str());
14692 }
14693 VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
14694 IterationVarName, SizeType,
14696 SC_None);
14697
14698 // Initialize the iteration variable to zero.
14699 llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
14700 IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
14701
14702 // Creates a reference to the iteration variable.
14703 RefBuilder IterationVarRef(IterationVar, SizeType);
14704 LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
14705
14706 // Create the DeclStmt that holds the iteration variable.
14707 Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);
14708
14709 // Subscript the "from" and "to" expressions with the iteration variable.
14710 SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
14711 MoveCastBuilder FromIndexMove(FromIndexCopy);
14712 const ExprBuilder *FromIndex;
14713 if (Copying)
14714 FromIndex = &FromIndexCopy;
14715 else
14716 FromIndex = &FromIndexMove;
14717
14718 SubscriptBuilder ToIndex(To, IterationVarRefRVal);
14719
14720 // Build the copy/move for an individual element of the array.
14723 ToIndex, *FromIndex, CopyingBaseSubobject,
14724 Copying, Depth + 1);
14725 // Bail out if copying fails or if we determined that we should use memcpy.
14726 if (Copy.isInvalid() || !Copy.get())
14727 return Copy;
14728
14729 // Create the comparison against the array bound.
14730 llvm::APInt Upper
14731 = ArrayTy->getSize().zextOrTrunc(S.Context.getTypeSize(SizeType));
14732 Expr *Comparison = BinaryOperator::Create(
14733 S.Context, IterationVarRefRVal.build(S, Loc),
14734 IntegerLiteral::Create(S.Context, Upper, SizeType, Loc), BO_NE,
14737
14738 // Create the pre-increment of the iteration variable. We can determine
14739 // whether the increment will overflow based on the value of the array
14740 // bound.
14741 Expr *Increment = UnaryOperator::Create(
14742 S.Context, IterationVarRef.build(S, Loc), UO_PreInc, SizeType, VK_LValue,
14743 OK_Ordinary, Loc, Upper.isMaxValue(), S.CurFPFeatureOverrides());
14744
14745 // Construct the loop that copies all elements of this array.
14746 return S.ActOnForStmt(
14747 Loc, Loc, InitStmt,
14748 S.ActOnCondition(nullptr, Loc, Comparison, Sema::ConditionKind::Boolean),
14749 S.MakeFullDiscardedValueExpr(Increment), Loc, Copy.get());
14750}
14751
14752static StmtResult
14754 const ExprBuilder &To, const ExprBuilder &From,
14755 bool CopyingBaseSubobject, bool Copying) {
14756 // Maybe we should use a memcpy?
14757 if (T->isArrayType() && !T.isConstQualified() && !T.isVolatileQualified() &&
14758 T.isTriviallyCopyableType(S.Context))
14759 return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
14760
14762 CopyingBaseSubobject,
14763 Copying, 0));
14764
14765 // If we ended up picking a trivial assignment operator for an array of a
14766 // non-trivially-copyable class type, just emit a memcpy.
14767 if (!Result.isInvalid() && !Result.get())
14768 return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
14769
14770 return Result;
14771}
14772
14774 // Note: The following rules are largely analoguous to the copy
14775 // constructor rules. Note that virtual bases are not taken into account
14776 // for determining the argument type of the operator. Note also that
14777 // operators taking an object instead of a reference are allowed.
14778 assert(ClassDecl->needsImplicitCopyAssignment());
14779
14780 DeclaringSpecialMember DSM(*this, ClassDecl,
14782 if (DSM.isAlreadyBeingDeclared())
14783 return nullptr;
14784
14785 QualType ArgType = Context.getTypeDeclType(ClassDecl);
14787 ArgType, nullptr);
14789 if (AS != LangAS::Default)
14790 ArgType = Context.getAddrSpaceQualType(ArgType, AS);
14791 QualType RetType = Context.getLValueReferenceType(ArgType);
14792 bool Const = ClassDecl->implicitCopyAssignmentHasConstParam();
14793 if (Const)
14794 ArgType = ArgType.withConst();
14795
14796 ArgType = Context.getLValueReferenceType(ArgType);
14797
14799 *this, ClassDecl, CXXSpecialMemberKind::CopyAssignment, Const);
14800
14801 // An implicitly-declared copy assignment operator is an inline public
14802 // member of its class.
14804 SourceLocation ClassLoc = ClassDecl->getLocation();
14805 DeclarationNameInfo NameInfo(Name, ClassLoc);
14807 Context, ClassDecl, ClassLoc, NameInfo, QualType(),
14808 /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
14809 getCurFPFeatures().isFPConstrained(),
14810 /*isInline=*/true,
14812 SourceLocation());
14813 CopyAssignment->setAccess(AS_public);
14814 CopyAssignment->setDefaulted();
14815 CopyAssignment->setImplicit();
14816
14817 setupImplicitSpecialMemberType(CopyAssignment, RetType, ArgType);
14818
14819 if (getLangOpts().CUDA)
14822 /* ConstRHS */ Const,
14823 /* Diagnose */ false);
14824
14825 // Add the parameter to the operator.
14827 ClassLoc, ClassLoc,
14828 /*Id=*/nullptr, ArgType,
14829 /*TInfo=*/nullptr, SC_None,
14830 nullptr);
14831 CopyAssignment->setParams(FromParam);
14832
14833 CopyAssignment->setTrivial(
14837 : ClassDecl->hasTrivialCopyAssignment());
14838
14839 // Note that we have added this copy-assignment operator.
14841
14842 Scope *S = getScopeForContext(ClassDecl);
14844
14848 SetDeclDeleted(CopyAssignment, ClassLoc);
14849 }
14850
14851 if (S)
14853 ClassDecl->addDecl(CopyAssignment);
14854
14855 return CopyAssignment;
14856}
14857
14858/// Diagnose an implicit copy operation for a class which is odr-used, but
14859/// which is deprecated because the class has a user-declared copy constructor,
14860/// copy assignment operator, or destructor.
14862 assert(CopyOp->isImplicit());
14863
14864 CXXRecordDecl *RD = CopyOp->getParent();
14865 CXXMethodDecl *UserDeclaredOperation = nullptr;
14866
14867 if (RD->hasUserDeclaredDestructor()) {
14868 UserDeclaredOperation = RD->getDestructor();
14869 } else if (!isa<CXXConstructorDecl>(CopyOp) &&
14871 // Find any user-declared copy constructor.
14872 for (auto *I : RD->ctors()) {
14873 if (I->isCopyConstructor()) {
14874 UserDeclaredOperation = I;
14875 break;
14876 }
14877 }
14878 assert(UserDeclaredOperation);
14879 } else if (isa<CXXConstructorDecl>(CopyOp) &&
14881 // Find any user-declared move assignment operator.
14882 for (auto *I : RD->methods()) {
14883 if (I->isCopyAssignmentOperator()) {
14884 UserDeclaredOperation = I;
14885 break;
14886 }
14887 }
14888 assert(UserDeclaredOperation);
14889 }
14890
14891 if (UserDeclaredOperation) {
14892 bool UDOIsUserProvided = UserDeclaredOperation->isUserProvided();
14893 bool UDOIsDestructor = isa<CXXDestructorDecl>(UserDeclaredOperation);
14894 bool IsCopyAssignment = !isa<CXXConstructorDecl>(CopyOp);
14895 unsigned DiagID =
14896 (UDOIsUserProvided && UDOIsDestructor)
14897 ? diag::warn_deprecated_copy_with_user_provided_dtor
14898 : (UDOIsUserProvided && !UDOIsDestructor)
14899 ? diag::warn_deprecated_copy_with_user_provided_copy
14900 : (!UDOIsUserProvided && UDOIsDestructor)
14901 ? diag::warn_deprecated_copy_with_dtor
14902 : diag::warn_deprecated_copy;
14903 S.Diag(UserDeclaredOperation->getLocation(), DiagID)
14904 << RD << IsCopyAssignment;
14905 }
14906}
14907
14909 CXXMethodDecl *CopyAssignOperator) {
14910 assert((CopyAssignOperator->isDefaulted() &&
14911 CopyAssignOperator->isOverloadedOperator() &&
14912 CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
14913 !CopyAssignOperator->doesThisDeclarationHaveABody() &&
14914 !CopyAssignOperator->isDeleted()) &&
14915 "DefineImplicitCopyAssignment called for wrong function");
14916 if (CopyAssignOperator->willHaveBody() || CopyAssignOperator->isInvalidDecl())
14917 return;
14918
14919 CXXRecordDecl *ClassDecl = CopyAssignOperator->getParent();
14920 if (ClassDecl->isInvalidDecl()) {
14921 CopyAssignOperator->setInvalidDecl();
14922 return;
14923 }
14924
14925 SynthesizedFunctionScope Scope(*this, CopyAssignOperator);
14926
14927 // The exception specification is needed because we are defining the
14928 // function.
14929 ResolveExceptionSpec(CurrentLocation,
14930 CopyAssignOperator->getType()->castAs<FunctionProtoType>());
14931
14932 // Add a context note for diagnostics produced after this point.
14933 Scope.addContextNote(CurrentLocation);
14934
14935 // C++11 [class.copy]p18:
14936 // The [definition of an implicitly declared copy assignment operator] is
14937 // deprecated if the class has a user-declared copy constructor or a
14938 // user-declared destructor.
14939 if (getLangOpts().CPlusPlus11 && CopyAssignOperator->isImplicit())
14940 diagnoseDeprecatedCopyOperation(*this, CopyAssignOperator);
14941
14942 // C++0x [class.copy]p30:
14943 // The implicitly-defined or explicitly-defaulted copy assignment operator
14944 // for a non-union class X performs memberwise copy assignment of its
14945 // subobjects. The direct base classes of X are assigned first, in the
14946 // order of their declaration in the base-specifier-list, and then the
14947 // immediate non-static data members of X are assigned, in the order in
14948 // which they were declared in the class definition.
14949
14950 // The statements that form the synthesized function body.
14951 SmallVector<Stmt*, 8> Statements;
14952
14953 // The parameter for the "other" object, which we are copying from.
14954 ParmVarDecl *Other = CopyAssignOperator->getNonObjectParameter(0);
14955 Qualifiers OtherQuals = Other->getType().getQualifiers();
14956 QualType OtherRefType = Other->getType();
14957 if (OtherRefType->isLValueReferenceType()) {
14958 OtherRefType = OtherRefType->getPointeeType();
14959 OtherQuals = OtherRefType.getQualifiers();
14960 }
14961
14962 // Our location for everything implicitly-generated.
14963 SourceLocation Loc = CopyAssignOperator->getEndLoc().isValid()
14964 ? CopyAssignOperator->getEndLoc()
14965 : CopyAssignOperator->getLocation();
14966
14967 // Builds a DeclRefExpr for the "other" object.
14968 RefBuilder OtherRef(Other, OtherRefType);
14969
14970 // Builds the function object parameter.
14971 std::optional<ThisBuilder> This;
14972 std::optional<DerefBuilder> DerefThis;
14973 std::optional<RefBuilder> ExplicitObject;
14974 bool IsArrow = false;
14975 QualType ObjectType;
14976 if (CopyAssignOperator->isExplicitObjectMemberFunction()) {
14977 ObjectType = CopyAssignOperator->getParamDecl(0)->getType();
14978 if (ObjectType->isReferenceType())
14979 ObjectType = ObjectType->getPointeeType();
14980 ExplicitObject.emplace(CopyAssignOperator->getParamDecl(0), ObjectType);
14981 } else {
14982 ObjectType = getCurrentThisType();
14983 This.emplace();
14984 DerefThis.emplace(*This);
14985 IsArrow = !LangOpts.HLSL;
14986 }
14987 ExprBuilder &ObjectParameter =
14988 ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
14989 : static_cast<ExprBuilder &>(*This);
14990
14991 // Assign base classes.
14992 bool Invalid = false;
14993 for (auto &Base : ClassDecl->bases()) {
14994 // Form the assignment:
14995 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other));
14996 QualType BaseType = Base.getType().getUnqualifiedType();
14997 if (!BaseType->isRecordType()) {
14998 Invalid = true;
14999 continue;
15000 }
15001
15002 CXXCastPath BasePath;
15003 BasePath.push_back(&Base);
15004
15005 // Construct the "from" expression, which is an implicit cast to the
15006 // appropriately-qualified base type.
15007 CastBuilder From(OtherRef, Context.getQualifiedType(BaseType, OtherQuals),
15008 VK_LValue, BasePath);
15009
15010 // Dereference "this".
15011 CastBuilder To(
15012 ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15013 : static_cast<ExprBuilder &>(*DerefThis),
15014 Context.getQualifiedType(BaseType, ObjectType.getQualifiers()),
15015 VK_LValue, BasePath);
15016
15017 // Build the copy.
15018 StmtResult Copy = buildSingleCopyAssign(*this, Loc, BaseType,
15019 To, From,
15020 /*CopyingBaseSubobject=*/true,
15021 /*Copying=*/true);
15022 if (Copy.isInvalid()) {
15023 CopyAssignOperator->setInvalidDecl();
15024 return;
15025 }
15026
15027 // Success! Record the copy.
15028 Statements.push_back(Copy.getAs<Expr>());
15029 }
15030
15031 // Assign non-static members.
15032 for (auto *Field : ClassDecl->fields()) {
15033 // FIXME: We should form some kind of AST representation for the implied
15034 // memcpy in a union copy operation.
15035 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15036 continue;
15037
15038 if (Field->isInvalidDecl()) {
15039 Invalid = true;
15040 continue;
15041 }
15042
15043 // Check for members of reference type; we can't copy those.
15044 if (Field->getType()->isReferenceType()) {
15045 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
15046 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
15047 Diag(Field->getLocation(), diag::note_declared_at);
15048 Invalid = true;
15049 continue;
15050 }
15051
15052 // Check for members of const-qualified, non-class type.
15053 QualType BaseType = Context.getBaseElementType(Field->getType());
15054 if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
15055 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
15056 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
15057 Diag(Field->getLocation(), diag::note_declared_at);
15058 Invalid = true;
15059 continue;
15060 }
15061
15062 // Suppress assigning zero-width bitfields.
15063 if (Field->isZeroLengthBitField())
15064 continue;
15065
15066 QualType FieldType = Field->getType().getNonReferenceType();
15067 if (FieldType->isIncompleteArrayType()) {
15068 assert(ClassDecl->hasFlexibleArrayMember() &&
15069 "Incomplete array type is not valid");
15070 continue;
15071 }
15072
15073 // Build references to the field in the object we're copying from and to.
15074 CXXScopeSpec SS; // Intentionally empty
15075 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
15077 MemberLookup.addDecl(Field);
15078 MemberLookup.resolveKind();
15079
15080 MemberBuilder From(OtherRef, OtherRefType, /*IsArrow=*/false, MemberLookup);
15081 MemberBuilder To(ObjectParameter, ObjectType, IsArrow, MemberLookup);
15082 // Build the copy of this field.
15083 StmtResult Copy = buildSingleCopyAssign(*this, Loc, FieldType,
15084 To, From,
15085 /*CopyingBaseSubobject=*/false,
15086 /*Copying=*/true);
15087 if (Copy.isInvalid()) {
15088 CopyAssignOperator->setInvalidDecl();
15089 return;
15090 }
15091
15092 // Success! Record the copy.
15093 Statements.push_back(Copy.getAs<Stmt>());
15094 }
15095
15096 if (!Invalid) {
15097 // Add a "return *this;"
15098 Expr *ThisExpr =
15099 (ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15100 : LangOpts.HLSL ? static_cast<ExprBuilder &>(*This)
15101 : static_cast<ExprBuilder &>(*DerefThis))
15102 .build(*this, Loc);
15103 StmtResult Return = BuildReturnStmt(Loc, ThisExpr);
15104 if (Return.isInvalid())
15105 Invalid = true;
15106 else
15107 Statements.push_back(Return.getAs<Stmt>());
15108 }
15109
15110 if (Invalid) {
15111 CopyAssignOperator->setInvalidDecl();
15112 return;
15113 }
15114
15115 StmtResult Body;
15116 {
15117 CompoundScopeRAII CompoundScope(*this);
15118 Body = ActOnCompoundStmt(Loc, Loc, Statements,
15119 /*isStmtExpr=*/false);
15120 assert(!Body.isInvalid() && "Compound statement creation cannot fail");
15121 }
15122 CopyAssignOperator->setBody(Body.getAs<Stmt>());
15123 CopyAssignOperator->markUsed(Context);
15124
15126 L->CompletedImplicitDefinition(CopyAssignOperator);
15127 }
15128}
15129
15131 assert(ClassDecl->needsImplicitMoveAssignment());
15132
15133 DeclaringSpecialMember DSM(*this, ClassDecl,
15135 if (DSM.isAlreadyBeingDeclared())
15136 return nullptr;
15137
15138 // Note: The following rules are largely analoguous to the move
15139 // constructor rules.
15140
15141 QualType ArgType = Context.getTypeDeclType(ClassDecl);
15143 ArgType, nullptr);
15145 if (AS != LangAS::Default)
15146 ArgType = Context.getAddrSpaceQualType(ArgType, AS);
15147 QualType RetType = Context.getLValueReferenceType(ArgType);
15148 ArgType = Context.getRValueReferenceType(ArgType);
15149
15151 *this, ClassDecl, CXXSpecialMemberKind::MoveAssignment, false);
15152
15153 // An implicitly-declared move assignment operator is an inline public
15154 // member of its class.
15156 SourceLocation ClassLoc = ClassDecl->getLocation();
15157 DeclarationNameInfo NameInfo(Name, ClassLoc);
15159 Context, ClassDecl, ClassLoc, NameInfo, QualType(),
15160 /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
15161 getCurFPFeatures().isFPConstrained(),
15162 /*isInline=*/true,
15164 SourceLocation());
15165 MoveAssignment->setAccess(AS_public);
15166 MoveAssignment->setDefaulted();
15167 MoveAssignment->setImplicit();
15168
15169 setupImplicitSpecialMemberType(MoveAssignment, RetType, ArgType);
15170
15171 if (getLangOpts().CUDA)
15174 /* ConstRHS */ false,
15175 /* Diagnose */ false);
15176
15177 // Add the parameter to the operator.
15179 ClassLoc, ClassLoc,
15180 /*Id=*/nullptr, ArgType,
15181 /*TInfo=*/nullptr, SC_None,
15182 nullptr);
15183 MoveAssignment->setParams(FromParam);
15184
15185 MoveAssignment->setTrivial(
15189 : ClassDecl->hasTrivialMoveAssignment());
15190
15191 // Note that we have added this copy-assignment operator.
15193
15194 Scope *S = getScopeForContext(ClassDecl);
15196
15200 SetDeclDeleted(MoveAssignment, ClassLoc);
15201 }
15202
15203 if (S)
15205 ClassDecl->addDecl(MoveAssignment);
15206
15207 return MoveAssignment;
15208}
15209
15210/// Check if we're implicitly defining a move assignment operator for a class
15211/// with virtual bases. Such a move assignment might move-assign the virtual
15212/// base multiple times.
15214 SourceLocation CurrentLocation) {
15215 assert(!Class->isDependentContext() && "should not define dependent move");
15216
15217 // Only a virtual base could get implicitly move-assigned multiple times.
15218 // Only a non-trivial move assignment can observe this. We only want to
15219 // diagnose if we implicitly define an assignment operator that assigns
15220 // two base classes, both of which move-assign the same virtual base.
15221 if (Class->getNumVBases() == 0 || Class->hasTrivialMoveAssignment() ||
15222 Class->getNumBases() < 2)
15223 return;
15224
15226 typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
15227 VBaseMap VBases;
15228
15229 for (auto &BI : Class->bases()) {
15230 Worklist.push_back(&BI);
15231 while (!Worklist.empty()) {
15232 CXXBaseSpecifier *BaseSpec = Worklist.pop_back_val();
15233 CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
15234
15235 // If the base has no non-trivial move assignment operators,
15236 // we don't care about moves from it.
15237 if (!Base->hasNonTrivialMoveAssignment())
15238 continue;
15239
15240 // If there's nothing virtual here, skip it.
15241 if (!BaseSpec->isVirtual() && !Base->getNumVBases())
15242 continue;
15243
15244 // If we're not actually going to call a move assignment for this base,
15245 // or the selected move assignment is trivial, skip it.
15248 /*ConstArg*/ false, /*VolatileArg*/ false,
15249 /*RValueThis*/ true, /*ConstThis*/ false,
15250 /*VolatileThis*/ false);
15251 if (!SMOR.getMethod() || SMOR.getMethod()->isTrivial() ||
15253 continue;
15254
15255 if (BaseSpec->isVirtual()) {
15256 // We're going to move-assign this virtual base, and its move
15257 // assignment operator is not trivial. If this can happen for
15258 // multiple distinct direct bases of Class, diagnose it. (If it
15259 // only happens in one base, we'll diagnose it when synthesizing
15260 // that base class's move assignment operator.)
15261 CXXBaseSpecifier *&Existing =
15262 VBases.insert(std::make_pair(Base->getCanonicalDecl(), &BI))
15263 .first->second;
15264 if (Existing && Existing != &BI) {
15265 S.Diag(CurrentLocation, diag::warn_vbase_moved_multiple_times)
15266 << Class << Base;
15267 S.Diag(Existing->getBeginLoc(), diag::note_vbase_moved_here)
15268 << (Base->getCanonicalDecl() ==
15270 << Base << Existing->getType() << Existing->getSourceRange();
15271 S.Diag(BI.getBeginLoc(), diag::note_vbase_moved_here)
15272 << (Base->getCanonicalDecl() ==
15273 BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
15274 << Base << BI.getType() << BaseSpec->getSourceRange();
15275
15276 // Only diagnose each vbase once.
15277 Existing = nullptr;
15278 }
15279 } else {
15280 // Only walk over bases that have defaulted move assignment operators.
15281 // We assume that any user-provided move assignment operator handles
15282 // the multiple-moves-of-vbase case itself somehow.
15283 if (!SMOR.getMethod()->isDefaulted())
15284 continue;
15285
15286 // We're going to move the base classes of Base. Add them to the list.
15287 llvm::append_range(Worklist, llvm::make_pointer_range(Base->bases()));
15288 }
15289 }
15290 }
15291}
15292
15294 CXXMethodDecl *MoveAssignOperator) {
15295 assert((MoveAssignOperator->isDefaulted() &&
15296 MoveAssignOperator->isOverloadedOperator() &&
15297 MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
15298 !MoveAssignOperator->doesThisDeclarationHaveABody() &&
15299 !MoveAssignOperator->isDeleted()) &&
15300 "DefineImplicitMoveAssignment called for wrong function");
15301 if (MoveAssignOperator->willHaveBody() || MoveAssignOperator->isInvalidDecl())
15302 return;
15303
15304 CXXRecordDecl *ClassDecl = MoveAssignOperator->getParent();
15305 if (ClassDecl->isInvalidDecl()) {
15306 MoveAssignOperator->setInvalidDecl();
15307 return;
15308 }
15309
15310 // C++0x [class.copy]p28:
15311 // The implicitly-defined or move assignment operator for a non-union class
15312 // X performs memberwise move assignment of its subobjects. The direct base
15313 // classes of X are assigned first, in the order of their declaration in the
15314 // base-specifier-list, and then the immediate non-static data members of X
15315 // are assigned, in the order in which they were declared in the class
15316 // definition.
15317
15318 // Issue a warning if our implicit move assignment operator will move
15319 // from a virtual base more than once.
15320 checkMoveAssignmentForRepeatedMove(*this, ClassDecl, CurrentLocation);
15321
15322 SynthesizedFunctionScope Scope(*this, MoveAssignOperator);
15323
15324 // The exception specification is needed because we are defining the
15325 // function.
15326 ResolveExceptionSpec(CurrentLocation,
15327 MoveAssignOperator->getType()->castAs<FunctionProtoType>());
15328
15329 // Add a context note for diagnostics produced after this point.
15330 Scope.addContextNote(CurrentLocation);
15331
15332 // The statements that form the synthesized function body.
15333 SmallVector<Stmt*, 8> Statements;
15334
15335 // The parameter for the "other" object, which we are move from.
15336 ParmVarDecl *Other = MoveAssignOperator->getNonObjectParameter(0);
15337 QualType OtherRefType =
15338 Other->getType()->castAs<RValueReferenceType>()->getPointeeType();
15339
15340 // Our location for everything implicitly-generated.
15341 SourceLocation Loc = MoveAssignOperator->getEndLoc().isValid()
15342 ? MoveAssignOperator->getEndLoc()
15343 : MoveAssignOperator->getLocation();
15344
15345 // Builds a reference to the "other" object.
15346 RefBuilder OtherRef(Other, OtherRefType);
15347 // Cast to rvalue.
15348 MoveCastBuilder MoveOther(OtherRef);
15349
15350 // Builds the function object parameter.
15351 std::optional<ThisBuilder> This;
15352 std::optional<DerefBuilder> DerefThis;
15353 std::optional<RefBuilder> ExplicitObject;
15354 QualType ObjectType;
15355 bool IsArrow = false;
15356 if (MoveAssignOperator->isExplicitObjectMemberFunction()) {
15357 ObjectType = MoveAssignOperator->getParamDecl(0)->getType();
15358 if (ObjectType->isReferenceType())
15359 ObjectType = ObjectType->getPointeeType();
15360 ExplicitObject.emplace(MoveAssignOperator->getParamDecl(0), ObjectType);
15361 } else {
15362 ObjectType = getCurrentThisType();
15363 This.emplace();
15364 DerefThis.emplace(*This);
15365 IsArrow = !getLangOpts().HLSL;
15366 }
15367 ExprBuilder &ObjectParameter =
15368 ExplicitObject ? *ExplicitObject : static_cast<ExprBuilder &>(*This);
15369
15370 // Assign base classes.
15371 bool Invalid = false;
15372 for (auto &Base : ClassDecl->bases()) {
15373 // C++11 [class.copy]p28:
15374 // It is unspecified whether subobjects representing virtual base classes
15375 // are assigned more than once by the implicitly-defined copy assignment
15376 // operator.
15377 // FIXME: Do not assign to a vbase that will be assigned by some other base
15378 // class. For a move-assignment, this can result in the vbase being moved
15379 // multiple times.
15380
15381 // Form the assignment:
15382 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other));
15383 QualType BaseType = Base.getType().getUnqualifiedType();
15384 if (!BaseType->isRecordType()) {
15385 Invalid = true;
15386 continue;
15387 }
15388
15389 CXXCastPath BasePath;
15390 BasePath.push_back(&Base);
15391
15392 // Construct the "from" expression, which is an implicit cast to the
15393 // appropriately-qualified base type.
15394 CastBuilder From(OtherRef, BaseType, VK_XValue, BasePath);
15395
15396 // Implicitly cast "this" to the appropriately-qualified base type.
15397 // Dereference "this".
15398 CastBuilder To(
15399 ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15400 : static_cast<ExprBuilder &>(*DerefThis),
15401 Context.getQualifiedType(BaseType, ObjectType.getQualifiers()),
15402 VK_LValue, BasePath);
15403
15404 // Build the move.
15405 StmtResult Move = buildSingleCopyAssign(*this, Loc, BaseType,
15406 To, From,
15407 /*CopyingBaseSubobject=*/true,
15408 /*Copying=*/false);
15409 if (Move.isInvalid()) {
15410 MoveAssignOperator->setInvalidDecl();
15411 return;
15412 }
15413
15414 // Success! Record the move.
15415 Statements.push_back(Move.getAs<Expr>());
15416 }
15417
15418 // Assign non-static members.
15419 for (auto *Field : ClassDecl->fields()) {
15420 // FIXME: We should form some kind of AST representation for the implied
15421 // memcpy in a union copy operation.
15422 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15423 continue;
15424
15425 if (Field->isInvalidDecl()) {
15426 Invalid = true;
15427 continue;
15428 }
15429
15430 // Check for members of reference type; we can't move those.
15431 if (Field->getType()->isReferenceType()) {
15432 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
15433 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
15434 Diag(Field->getLocation(), diag::note_declared_at);
15435 Invalid = true;
15436 continue;
15437 }
15438
15439 // Check for members of const-qualified, non-class type.
15440 QualType BaseType = Context.getBaseElementType(Field->getType());
15441 if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
15442 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
15443 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
15444 Diag(Field->getLocation(), diag::note_declared_at);
15445 Invalid = true;
15446 continue;
15447 }
15448
15449 // Suppress assigning zero-width bitfields.
15450 if (Field->isZeroLengthBitField())
15451 continue;
15452
15453 QualType FieldType = Field->getType().getNonReferenceType();
15454 if (FieldType->isIncompleteArrayType()) {
15455 assert(ClassDecl->hasFlexibleArrayMember() &&
15456 "Incomplete array type is not valid");
15457 continue;
15458 }
15459
15460 // Build references to the field in the object we're copying from and to.
15461 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
15463 MemberLookup.addDecl(Field);
15464 MemberLookup.resolveKind();
15465 MemberBuilder From(MoveOther, OtherRefType,
15466 /*IsArrow=*/false, MemberLookup);
15467 MemberBuilder To(ObjectParameter, ObjectType, IsArrow, MemberLookup);
15468
15469 assert(!From.build(*this, Loc)->isLValue() && // could be xvalue or prvalue
15470 "Member reference with rvalue base must be rvalue except for reference "
15471 "members, which aren't allowed for move assignment.");
15472
15473 // Build the move of this field.
15474 StmtResult Move = buildSingleCopyAssign(*this, Loc, FieldType,
15475 To, From,
15476 /*CopyingBaseSubobject=*/false,
15477 /*Copying=*/false);
15478 if (Move.isInvalid()) {
15479 MoveAssignOperator->setInvalidDecl();
15480 return;
15481 }
15482
15483 // Success! Record the copy.
15484 Statements.push_back(Move.getAs<Stmt>());
15485 }
15486
15487 if (!Invalid) {
15488 // Add a "return *this;"
15489 Expr *ThisExpr =
15490 (ExplicitObject ? static_cast<ExprBuilder &>(*ExplicitObject)
15491 : LangOpts.HLSL ? static_cast<ExprBuilder &>(*This)
15492 : static_cast<ExprBuilder &>(*DerefThis))
15493 .build(*this, Loc);
15494
15495 StmtResult Return = BuildReturnStmt(Loc, ThisExpr);
15496 if (Return.isInvalid())
15497 Invalid = true;
15498 else
15499 Statements.push_back(Return.getAs<Stmt>());
15500 }
15501
15502 if (Invalid) {
15503 MoveAssignOperator->setInvalidDecl();
15504 return;
15505 }
15506
15507 StmtResult Body;
15508 {
15509 CompoundScopeRAII CompoundScope(*this);
15510 Body = ActOnCompoundStmt(Loc, Loc, Statements,
15511 /*isStmtExpr=*/false);
15512 assert(!Body.isInvalid() && "Compound statement creation cannot fail");
15513 }
15514 MoveAssignOperator->setBody(Body.getAs<Stmt>());
15515 MoveAssignOperator->markUsed(Context);
15516
15518 L->CompletedImplicitDefinition(MoveAssignOperator);
15519 }
15520}
15521
15523 CXXRecordDecl *ClassDecl) {
15524 // C++ [class.copy]p4:
15525 // If the class definition does not explicitly declare a copy
15526 // constructor, one is declared implicitly.
15527 assert(ClassDecl->needsImplicitCopyConstructor());
15528
15529 DeclaringSpecialMember DSM(*this, ClassDecl,
15531 if (DSM.isAlreadyBeingDeclared())
15532 return nullptr;
15533
15534 QualType ClassType = Context.getTypeDeclType(ClassDecl);
15535 QualType ArgType = ClassType;
15537 ArgType, nullptr);
15538 bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
15539 if (Const)
15540 ArgType = ArgType.withConst();
15541
15543 if (AS != LangAS::Default)
15544 ArgType = Context.getAddrSpaceQualType(ArgType, AS);
15545
15546 ArgType = Context.getLValueReferenceType(ArgType);
15547
15549 *this, ClassDecl, CXXSpecialMemberKind::CopyConstructor, Const);
15550
15551 DeclarationName Name
15553 Context.getCanonicalType(ClassType));
15554 SourceLocation ClassLoc = ClassDecl->getLocation();
15555 DeclarationNameInfo NameInfo(Name, ClassLoc);
15556
15557 // An implicitly-declared copy constructor is an inline public
15558 // member of its class.
15560 Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
15561 ExplicitSpecifier(), getCurFPFeatures().isFPConstrained(),
15562 /*isInline=*/true,
15563 /*isImplicitlyDeclared=*/true,
15566 CopyConstructor->setAccess(AS_public);
15567 CopyConstructor->setDefaulted();
15568
15569 setupImplicitSpecialMemberType(CopyConstructor, Context.VoidTy, ArgType);
15570
15571 if (getLangOpts().CUDA)
15574 /* ConstRHS */ Const,
15575 /* Diagnose */ false);
15576
15577 // During template instantiation of special member functions we need a
15578 // reliable TypeSourceInfo for the parameter types in order to allow functions
15579 // to be substituted.
15580 TypeSourceInfo *TSI = nullptr;
15581 if (inTemplateInstantiation() && ClassDecl->isLambda())
15582 TSI = Context.getTrivialTypeSourceInfo(ArgType);
15583
15584 // Add the parameter to the constructor.
15585 ParmVarDecl *FromParam =
15586 ParmVarDecl::Create(Context, CopyConstructor, ClassLoc, ClassLoc,
15587 /*IdentifierInfo=*/nullptr, ArgType,
15588 /*TInfo=*/TSI, SC_None, nullptr);
15589 CopyConstructor->setParams(FromParam);
15590
15591 CopyConstructor->setTrivial(
15595 : ClassDecl->hasTrivialCopyConstructor());
15596
15597 CopyConstructor->setTrivialForCall(
15598 ClassDecl->hasAttr<TrivialABIAttr>() ||
15603 : ClassDecl->hasTrivialCopyConstructorForCall()));
15604
15605 // Note that we have declared this constructor.
15607
15608 Scope *S = getScopeForContext(ClassDecl);
15610
15615 }
15616
15617 if (S)
15619 ClassDecl->addDecl(CopyConstructor);
15620
15621 return CopyConstructor;
15622}
15623
15626 assert((CopyConstructor->isDefaulted() &&
15627 CopyConstructor->isCopyConstructor() &&
15628 !CopyConstructor->doesThisDeclarationHaveABody() &&
15629 !CopyConstructor->isDeleted()) &&
15630 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
15631 if (CopyConstructor->willHaveBody() || CopyConstructor->isInvalidDecl())
15632 return;
15633
15634 CXXRecordDecl *ClassDecl = CopyConstructor->getParent();
15635 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
15636
15638
15639 // The exception specification is needed because we are defining the
15640 // function.
15641 ResolveExceptionSpec(CurrentLocation,
15642 CopyConstructor->getType()->castAs<FunctionProtoType>());
15643 MarkVTableUsed(CurrentLocation, ClassDecl);
15644
15645 // Add a context note for diagnostics produced after this point.
15646 Scope.addContextNote(CurrentLocation);
15647
15648 // C++11 [class.copy]p7:
15649 // The [definition of an implicitly declared copy constructor] is
15650 // deprecated if the class has a user-declared copy assignment operator
15651 // or a user-declared destructor.
15652 if (getLangOpts().CPlusPlus11 && CopyConstructor->isImplicit())
15654
15655 if (SetCtorInitializers(CopyConstructor, /*AnyErrors=*/false)) {
15656 CopyConstructor->setInvalidDecl();
15657 } else {
15658 SourceLocation Loc = CopyConstructor->getEndLoc().isValid()
15659 ? CopyConstructor->getEndLoc()
15660 : CopyConstructor->getLocation();
15661 Sema::CompoundScopeRAII CompoundScope(*this);
15662 CopyConstructor->setBody(
15663 ActOnCompoundStmt(Loc, Loc, {}, /*isStmtExpr=*/false).getAs<Stmt>());
15664 CopyConstructor->markUsed(Context);
15665 }
15666
15668 L->CompletedImplicitDefinition(CopyConstructor);
15669 }
15670}
15671
15673 CXXRecordDecl *ClassDecl) {
15674 assert(ClassDecl->needsImplicitMoveConstructor());
15675
15676 DeclaringSpecialMember DSM(*this, ClassDecl,
15678 if (DSM.isAlreadyBeingDeclared())
15679 return nullptr;
15680
15681 QualType ClassType = Context.getTypeDeclType(ClassDecl);
15682
15683 QualType ArgType = ClassType;
15685 ArgType, nullptr);
15687 if (AS != LangAS::Default)
15688 ArgType = Context.getAddrSpaceQualType(ClassType, AS);
15689 ArgType = Context.getRValueReferenceType(ArgType);
15690
15692 *this, ClassDecl, CXXSpecialMemberKind::MoveConstructor, false);
15693
15694 DeclarationName Name
15696 Context.getCanonicalType(ClassType));
15697 SourceLocation ClassLoc = ClassDecl->getLocation();
15698 DeclarationNameInfo NameInfo(Name, ClassLoc);
15699
15700 // C++11 [class.copy]p11:
15701 // An implicitly-declared copy/move constructor is an inline public
15702 // member of its class.
15704 Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
15705 ExplicitSpecifier(), getCurFPFeatures().isFPConstrained(),
15706 /*isInline=*/true,
15707 /*isImplicitlyDeclared=*/true,
15710 MoveConstructor->setAccess(AS_public);
15711 MoveConstructor->setDefaulted();
15712
15713 setupImplicitSpecialMemberType(MoveConstructor, Context.VoidTy, ArgType);
15714
15715 if (getLangOpts().CUDA)
15718 /* ConstRHS */ false,
15719 /* Diagnose */ false);
15720
15721 // Add the parameter to the constructor.
15723 ClassLoc, ClassLoc,
15724 /*IdentifierInfo=*/nullptr,
15725 ArgType, /*TInfo=*/nullptr,
15726 SC_None, nullptr);
15727 MoveConstructor->setParams(FromParam);
15728
15729 MoveConstructor->setTrivial(
15733 : ClassDecl->hasTrivialMoveConstructor());
15734
15735 MoveConstructor->setTrivialForCall(
15736 ClassDecl->hasAttr<TrivialABIAttr>() ||
15741 : ClassDecl->hasTrivialMoveConstructorForCall()));
15742
15743 // Note that we have declared this constructor.
15745
15746 Scope *S = getScopeForContext(ClassDecl);
15748
15753 }
15754
15755 if (S)
15757 ClassDecl->addDecl(MoveConstructor);
15758
15759 return MoveConstructor;
15760}
15761
15764 assert((MoveConstructor->isDefaulted() &&
15765 MoveConstructor->isMoveConstructor() &&
15766 !MoveConstructor->doesThisDeclarationHaveABody() &&
15767 !MoveConstructor->isDeleted()) &&
15768 "DefineImplicitMoveConstructor - call it for implicit move ctor");
15769 if (MoveConstructor->willHaveBody() || MoveConstructor->isInvalidDecl())
15770 return;
15771
15772 CXXRecordDecl *ClassDecl = MoveConstructor->getParent();
15773 assert(ClassDecl && "DefineImplicitMoveConstructor - invalid constructor");
15774
15776
15777 // The exception specification is needed because we are defining the
15778 // function.
15779 ResolveExceptionSpec(CurrentLocation,
15780 MoveConstructor->getType()->castAs<FunctionProtoType>());
15781 MarkVTableUsed(CurrentLocation, ClassDecl);
15782
15783 // Add a context note for diagnostics produced after this point.
15784 Scope.addContextNote(CurrentLocation);
15785
15786 if (SetCtorInitializers(MoveConstructor, /*AnyErrors=*/false)) {
15787 MoveConstructor->setInvalidDecl();
15788 } else {
15789 SourceLocation Loc = MoveConstructor->getEndLoc().isValid()
15790 ? MoveConstructor->getEndLoc()
15791 : MoveConstructor->getLocation();
15792 Sema::CompoundScopeRAII CompoundScope(*this);
15793 MoveConstructor->setBody(
15794 ActOnCompoundStmt(Loc, Loc, {}, /*isStmtExpr=*/false).getAs<Stmt>());
15795 MoveConstructor->markUsed(Context);
15796 }
15797
15799 L->CompletedImplicitDefinition(MoveConstructor);
15800 }
15801}
15802
15804 return FD->isDeleted() && FD->isDefaulted() && isa<CXXMethodDecl>(FD);
15805}
15806
15808 SourceLocation CurrentLocation,
15809 CXXConversionDecl *Conv) {
15810 SynthesizedFunctionScope Scope(*this, Conv);
15811 assert(!Conv->getReturnType()->isUndeducedType());
15812
15813 QualType ConvRT = Conv->getType()->castAs<FunctionType>()->getReturnType();
15814 CallingConv CC =
15815 ConvRT->getPointeeType()->castAs<FunctionType>()->getCallConv();
15816
15817 CXXRecordDecl *Lambda = Conv->getParent();
15818 FunctionDecl *CallOp = Lambda->getLambdaCallOperator();
15819 FunctionDecl *Invoker =
15820 CallOp->hasCXXExplicitFunctionObjectParameter() || CallOp->isStatic()
15821 ? CallOp
15822 : Lambda->getLambdaStaticInvoker(CC);
15823
15824 if (auto *TemplateArgs = Conv->getTemplateSpecializationArgs()) {
15826 CallOp->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
15827 if (!CallOp)
15828 return;
15829
15830 if (CallOp != Invoker) {
15832 Invoker->getDescribedFunctionTemplate(), TemplateArgs,
15833 CurrentLocation);
15834 if (!Invoker)
15835 return;
15836 }
15837 }
15838
15839 if (CallOp->isInvalidDecl())
15840 return;
15841
15842 // Mark the call operator referenced (and add to pending instantiations
15843 // if necessary).
15844 // For both the conversion and static-invoker template specializations
15845 // we construct their body's in this function, so no need to add them
15846 // to the PendingInstantiations.
15847 MarkFunctionReferenced(CurrentLocation, CallOp);
15848
15849 if (Invoker != CallOp) {
15850 // Fill in the __invoke function with a dummy implementation. IR generation
15851 // will fill in the actual details. Update its type in case it contained
15852 // an 'auto'.
15853 Invoker->markUsed(Context);
15854 Invoker->setReferenced();
15855 Invoker->setType(Conv->getReturnType()->getPointeeType());
15856 Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));
15857 }
15858
15859 // Construct the body of the conversion function { return __invoke; }.
15860 Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(), VK_LValue,
15861 Conv->getLocation());
15862 assert(FunctionRef && "Can't refer to __invoke function?");
15863 Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
15865 Conv->getLocation(), Conv->getLocation()));
15866 Conv->markUsed(Context);
15867 Conv->setReferenced();
15868
15870 L->CompletedImplicitDefinition(Conv);
15871 if (Invoker != CallOp)
15872 L->CompletedImplicitDefinition(Invoker);
15873 }
15874}
15875
15877 SourceLocation CurrentLocation, CXXConversionDecl *Conv) {
15878 assert(!Conv->getParent()->isGenericLambda());
15879
15880 SynthesizedFunctionScope Scope(*this, Conv);
15881
15882 // Copy-initialize the lambda object as needed to capture it.
15883 Expr *This = ActOnCXXThis(CurrentLocation).get();
15884 Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).get();
15885
15886 ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation,
15887 Conv->getLocation(),
15888 Conv, DerefThis);
15889
15890 // If we're not under ARC, make sure we still get the _Block_copy/autorelease
15891 // behavior. Note that only the general conversion function does this
15892 // (since it's unusable otherwise); in the case where we inline the
15893 // block literal, it has block literal lifetime semantics.
15894 if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
15895 BuildBlock = ImplicitCastExpr::Create(
15896 Context, BuildBlock.get()->getType(), CK_CopyAndAutoreleaseBlockObject,
15897 BuildBlock.get(), nullptr, VK_PRValue, FPOptionsOverride());
15898
15899 if (BuildBlock.isInvalid()) {
15900 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
15901 Conv->setInvalidDecl();
15902 return;
15903 }
15904
15905 // Create the return statement that returns the block from the conversion
15906 // function.
15907 StmtResult Return = BuildReturnStmt(Conv->getLocation(), BuildBlock.get());
15908 if (Return.isInvalid()) {
15909 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
15910 Conv->setInvalidDecl();
15911 return;
15912 }
15913
15914 // Set the body of the conversion function.
15915 Stmt *ReturnS = Return.get();
15917 Conv->getLocation(), Conv->getLocation()));
15918 Conv->markUsed(Context);
15919
15920 // We're done; notify the mutation listener, if any.
15922 L->CompletedImplicitDefinition(Conv);
15923 }
15924}
15925
15926/// Determine whether the given list arguments contains exactly one
15927/// "real" (non-default) argument.
15929 switch (Args.size()) {
15930 case 0:
15931 return false;
15932
15933 default:
15934 if (!Args[1]->isDefaultArgument())
15935 return false;
15936
15937 [[fallthrough]];
15938 case 1:
15939 return !Args[0]->isDefaultArgument();
15940 }
15941
15942 return false;
15943}
15944
15946 SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl,
15947 CXXConstructorDecl *Constructor, MultiExprArg ExprArgs,
15948 bool HadMultipleCandidates, bool IsListInitialization,
15949 bool IsStdInitListInitialization, bool RequiresZeroInit,
15950 CXXConstructionKind ConstructKind, SourceRange ParenRange) {
15951 bool Elidable = false;
15952
15953 // C++0x [class.copy]p34:
15954 // When certain criteria are met, an implementation is allowed to
15955 // omit the copy/move construction of a class object, even if the
15956 // copy/move constructor and/or destructor for the object have
15957 // side effects. [...]
15958 // - when a temporary class object that has not been bound to a
15959 // reference (12.2) would be copied/moved to a class object
15960 // with the same cv-unqualified type, the copy/move operation
15961 // can be omitted by constructing the temporary object
15962 // directly into the target of the omitted copy/move
15963 if (ConstructKind == CXXConstructionKind::Complete && Constructor &&
15964 // FIXME: Converting constructors should also be accepted.
15965 // But to fix this, the logic that digs down into a CXXConstructExpr
15966 // to find the source object needs to handle it.
15967 // Right now it assumes the source object is passed directly as the
15968 // first argument.
15969 Constructor->isCopyOrMoveConstructor() && hasOneRealArgument(ExprArgs)) {
15970 Expr *SubExpr = ExprArgs[0];
15971 // FIXME: Per above, this is also incorrect if we want to accept
15972 // converting constructors, as isTemporaryObject will
15973 // reject temporaries with different type from the
15974 // CXXRecord itself.
15975 Elidable = SubExpr->isTemporaryObject(
15976 Context, cast<CXXRecordDecl>(FoundDecl->getDeclContext()));
15977 }
15978
15979 return BuildCXXConstructExpr(ConstructLoc, DeclInitType,
15980 FoundDecl, Constructor,
15981 Elidable, ExprArgs, HadMultipleCandidates,
15982 IsListInitialization,
15983 IsStdInitListInitialization, RequiresZeroInit,
15984 ConstructKind, ParenRange);
15985}
15986
15988 SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl,
15989 CXXConstructorDecl *Constructor, bool Elidable, MultiExprArg ExprArgs,
15990 bool HadMultipleCandidates, bool IsListInitialization,
15991 bool IsStdInitListInitialization, bool RequiresZeroInit,
15992 CXXConstructionKind ConstructKind, SourceRange ParenRange) {
15993 if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl)) {
15994 Constructor = findInheritingConstructor(ConstructLoc, Constructor, Shadow);
15995 // The only way to get here is if we did overload resolution to find the
15996 // shadow decl, so we don't need to worry about re-checking the trailing
15997 // requires clause.
15998 if (DiagnoseUseOfOverloadedDecl(Constructor, ConstructLoc))
15999 return ExprError();
16000 }
16001
16002 return BuildCXXConstructExpr(
16003 ConstructLoc, DeclInitType, Constructor, Elidable, ExprArgs,
16004 HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
16005 RequiresZeroInit, ConstructKind, ParenRange);
16006}
16007
16008/// BuildCXXConstructExpr - Creates a complete call to a constructor,
16009/// including handling of its default argument expressions.
16011 SourceLocation ConstructLoc, QualType DeclInitType,
16012 CXXConstructorDecl *Constructor, bool Elidable, MultiExprArg ExprArgs,
16013 bool HadMultipleCandidates, bool IsListInitialization,
16014 bool IsStdInitListInitialization, bool RequiresZeroInit,
16015 CXXConstructionKind ConstructKind, SourceRange ParenRange) {
16016 assert(declaresSameEntity(
16017 Constructor->getParent(),
16018 DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) &&
16019 "given constructor for wrong type");
16020 MarkFunctionReferenced(ConstructLoc, Constructor);
16021 if (getLangOpts().CUDA && !CUDA().CheckCall(ConstructLoc, Constructor))
16022 return ExprError();
16023
16026 Context, DeclInitType, ConstructLoc, Constructor, Elidable, ExprArgs,
16027 HadMultipleCandidates, IsListInitialization,
16028 IsStdInitListInitialization, RequiresZeroInit,
16029 static_cast<CXXConstructionKind>(ConstructKind), ParenRange),
16030 Constructor);
16031}
16032
16034 if (VD->isInvalidDecl()) return;
16035 // If initializing the variable failed, don't also diagnose problems with
16036 // the destructor, they're likely related.
16037 if (VD->getInit() && VD->getInit()->containsErrors())
16038 return;
16039
16040 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());
16041 if (ClassDecl->isInvalidDecl()) return;
16042 if (ClassDecl->hasIrrelevantDestructor()) return;
16043 if (ClassDecl->isDependentContext()) return;
16044
16045 if (VD->isNoDestroy(getASTContext()))
16046 return;
16047
16049 // The result of `LookupDestructor` might be nullptr if the destructor is
16050 // invalid, in which case it is marked as `IneligibleOrNotSelected` and
16051 // will not be selected by `CXXRecordDecl::getDestructor()`.
16052 if (!Destructor)
16053 return;
16054 // If this is an array, we'll require the destructor during initialization, so
16055 // we can skip over this. We still want to emit exit-time destructor warnings
16056 // though.
16057 if (!VD->getType()->isArrayType()) {
16060 PDiag(diag::err_access_dtor_var)
16061 << VD->getDeclName() << VD->getType());
16063 }
16064
16065 if (Destructor->isTrivial()) return;
16066
16067 // If the destructor is constexpr, check whether the variable has constant
16068 // destruction now.
16069 if (Destructor->isConstexpr()) {
16070 bool HasConstantInit = false;
16071 if (VD->getInit() && !VD->getInit()->isValueDependent())
16072 HasConstantInit = VD->evaluateValue();
16074 if (!VD->evaluateDestruction(Notes) && VD->isConstexpr() &&
16075 HasConstantInit) {
16076 Diag(VD->getLocation(),
16077 diag::err_constexpr_var_requires_const_destruction) << VD;
16078 for (unsigned I = 0, N = Notes.size(); I != N; ++I)
16079 Diag(Notes[I].first, Notes[I].second);
16080 }
16081 }
16082
16083 if (!VD->hasGlobalStorage() || !VD->needsDestruction(Context))
16084 return;
16085
16086 // Emit warning for non-trivial dtor in global scope (a real global,
16087 // class-static, function-static).
16088 if (!VD->hasAttr<AlwaysDestroyAttr>())
16089 Diag(VD->getLocation(), diag::warn_exit_time_destructor);
16090
16091 // TODO: this should be re-enabled for static locals by !CXAAtExit
16092 if (!VD->isStaticLocal())
16093 Diag(VD->getLocation(), diag::warn_global_destructor);
16094}
16095
16097 QualType DeclInitType, MultiExprArg ArgsPtr,
16099 SmallVectorImpl<Expr *> &ConvertedArgs,
16100 bool AllowExplicit,
16101 bool IsListInitialization) {
16102 // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
16103 unsigned NumArgs = ArgsPtr.size();
16104 Expr **Args = ArgsPtr.data();
16105
16106 const auto *Proto = Constructor->getType()->castAs<FunctionProtoType>();
16107 unsigned NumParams = Proto->getNumParams();
16108
16109 // If too few arguments are available, we'll fill in the rest with defaults.
16110 if (NumArgs < NumParams)
16111 ConvertedArgs.reserve(NumParams);
16112 else
16113 ConvertedArgs.reserve(NumArgs);
16114
16115 VariadicCallType CallType =
16116 Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
16117 SmallVector<Expr *, 8> AllArgs;
16119 Loc, Constructor, Proto, 0, llvm::ArrayRef(Args, NumArgs), AllArgs,
16120 CallType, AllowExplicit, IsListInitialization);
16121 ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
16122
16123 DiagnoseSentinelCalls(Constructor, Loc, AllArgs);
16124
16125 CheckConstructorCall(Constructor, DeclInitType,
16126 llvm::ArrayRef(AllArgs.data(), AllArgs.size()), Proto,
16127 Loc);
16128
16129 return Invalid;
16130}
16131
16132static inline bool
16134 const FunctionDecl *FnDecl) {
16135 const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
16136 if (isa<NamespaceDecl>(DC)) {
16137 return SemaRef.Diag(FnDecl->getLocation(),
16138 diag::err_operator_new_delete_declared_in_namespace)
16139 << FnDecl->getDeclName();
16140 }
16141
16142 if (isa<TranslationUnitDecl>(DC) &&
16143 FnDecl->getStorageClass() == SC_Static) {
16144 return SemaRef.Diag(FnDecl->getLocation(),
16145 diag::err_operator_new_delete_declared_static)
16146 << FnDecl->getDeclName();
16147 }
16148
16149 return false;
16150}
16151
16153 const PointerType *PtrTy) {
16154 auto &Ctx = SemaRef.Context;
16155 Qualifiers PtrQuals = PtrTy->getPointeeType().getQualifiers();
16156 PtrQuals.removeAddressSpace();
16157 return Ctx.getPointerType(Ctx.getCanonicalType(Ctx.getQualifiedType(
16158 PtrTy->getPointeeType().getUnqualifiedType(), PtrQuals)));
16159}
16160
16161static inline bool
16163 CanQualType ExpectedResultType,
16164 CanQualType ExpectedFirstParamType,
16165 unsigned DependentParamTypeDiag,
16166 unsigned InvalidParamTypeDiag) {
16167 QualType ResultType =
16168 FnDecl->getType()->castAs<FunctionType>()->getReturnType();
16169
16170 if (SemaRef.getLangOpts().OpenCLCPlusPlus) {
16171 // The operator is valid on any address space for OpenCL.
16172 // Drop address space from actual and expected result types.
16173 if (const auto *PtrTy = ResultType->getAs<PointerType>())
16174 ResultType = RemoveAddressSpaceFromPtr(SemaRef, PtrTy);
16175
16176 if (auto ExpectedPtrTy = ExpectedResultType->getAs<PointerType>())
16177 ExpectedResultType = RemoveAddressSpaceFromPtr(SemaRef, ExpectedPtrTy);
16178 }
16179
16180 // Check that the result type is what we expect.
16181 if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType) {
16182 // Reject even if the type is dependent; an operator delete function is
16183 // required to have a non-dependent result type.
16184 return SemaRef.Diag(
16185 FnDecl->getLocation(),
16186 ResultType->isDependentType()
16187 ? diag::err_operator_new_delete_dependent_result_type
16188 : diag::err_operator_new_delete_invalid_result_type)
16189 << FnDecl->getDeclName() << ExpectedResultType;
16190 }
16191
16192 // A function template must have at least 2 parameters.
16193 if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
16194 return SemaRef.Diag(FnDecl->getLocation(),
16195 diag::err_operator_new_delete_template_too_few_parameters)
16196 << FnDecl->getDeclName();
16197
16198 // The function decl must have at least 1 parameter.
16199 if (FnDecl->getNumParams() == 0)
16200 return SemaRef.Diag(FnDecl->getLocation(),
16201 diag::err_operator_new_delete_too_few_parameters)
16202 << FnDecl->getDeclName();
16203
16204 QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
16205 if (SemaRef.getLangOpts().OpenCLCPlusPlus) {
16206 // The operator is valid on any address space for OpenCL.
16207 // Drop address space from actual and expected first parameter types.
16208 if (const auto *PtrTy =
16209 FnDecl->getParamDecl(0)->getType()->getAs<PointerType>())
16210 FirstParamType = RemoveAddressSpaceFromPtr(SemaRef, PtrTy);
16211
16212 if (auto ExpectedPtrTy = ExpectedFirstParamType->getAs<PointerType>())
16213 ExpectedFirstParamType =
16214 RemoveAddressSpaceFromPtr(SemaRef, ExpectedPtrTy);
16215 }
16216
16217 // Check that the first parameter type is what we expect.
16218 if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
16219 ExpectedFirstParamType) {
16220 // The first parameter type is not allowed to be dependent. As a tentative
16221 // DR resolution, we allow a dependent parameter type if it is the right
16222 // type anyway, to allow destroying operator delete in class templates.
16223 return SemaRef.Diag(FnDecl->getLocation(), FirstParamType->isDependentType()
16224 ? DependentParamTypeDiag
16225 : InvalidParamTypeDiag)
16226 << FnDecl->getDeclName() << ExpectedFirstParamType;
16227 }
16228
16229 return false;
16230}
16231
16232static bool
16234 // C++ [basic.stc.dynamic.allocation]p1:
16235 // A program is ill-formed if an allocation function is declared in a
16236 // namespace scope other than global scope or declared static in global
16237 // scope.
16239 return true;
16240
16241 CanQualType SizeTy =
16243
16244 // C++ [basic.stc.dynamic.allocation]p1:
16245 // The return type shall be void*. The first parameter shall have type
16246 // std::size_t.
16248 SizeTy,
16249 diag::err_operator_new_dependent_param_type,
16250 diag::err_operator_new_param_type))
16251 return true;
16252
16253 // C++ [basic.stc.dynamic.allocation]p1:
16254 // The first parameter shall not have an associated default argument.
16255 if (FnDecl->getParamDecl(0)->hasDefaultArg())
16256 return SemaRef.Diag(FnDecl->getLocation(),
16257 diag::err_operator_new_default_arg)
16258 << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();
16259
16260 return false;
16261}
16262
16263static bool
16265 // C++ [basic.stc.dynamic.deallocation]p1:
16266 // A program is ill-formed if deallocation functions are declared in a
16267 // namespace scope other than global scope or declared static in global
16268 // scope.
16270 return true;
16271
16272 auto *MD = dyn_cast<CXXMethodDecl>(FnDecl);
16273
16274 // C++ P0722:
16275 // Within a class C, the first parameter of a destroying operator delete
16276 // shall be of type C *. The first parameter of any other deallocation
16277 // function shall be of type void *.
16278 CanQualType ExpectedFirstParamType =
16279 MD && MD->isDestroyingOperatorDelete()
16283
16284 // C++ [basic.stc.dynamic.deallocation]p2:
16285 // Each deallocation function shall return void
16287 SemaRef, FnDecl, SemaRef.Context.VoidTy, ExpectedFirstParamType,
16288 diag::err_operator_delete_dependent_param_type,
16289 diag::err_operator_delete_param_type))
16290 return true;
16291
16292 // C++ P0722:
16293 // A destroying operator delete shall be a usual deallocation function.
16294 if (MD && !MD->getParent()->isDependentContext() &&
16297 SemaRef.Diag(MD->getLocation(),
16298 diag::err_destroying_operator_delete_not_usual);
16299 return true;
16300 }
16301
16302 return false;
16303}
16304
16306 assert(FnDecl && FnDecl->isOverloadedOperator() &&
16307 "Expected an overloaded operator declaration");
16308
16310
16311 // C++ [over.oper]p5:
16312 // The allocation and deallocation functions, operator new,
16313 // operator new[], operator delete and operator delete[], are
16314 // described completely in 3.7.3. The attributes and restrictions
16315 // found in the rest of this subclause do not apply to them unless
16316 // explicitly stated in 3.7.3.
16317 if (Op == OO_Delete || Op == OO_Array_Delete)
16318 return CheckOperatorDeleteDeclaration(*this, FnDecl);
16319
16320 if (Op == OO_New || Op == OO_Array_New)
16321 return CheckOperatorNewDeclaration(*this, FnDecl);
16322
16323 // C++ [over.oper]p7:
16324 // An operator function shall either be a member function or
16325 // be a non-member function and have at least one parameter
16326 // whose type is a class, a reference to a class, an enumeration,
16327 // or a reference to an enumeration.
16328 // Note: Before C++23, a member function could not be static. The only member
16329 // function allowed to be static is the call operator function.
16330 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
16331 if (MethodDecl->isStatic()) {
16332 if (Op == OO_Call || Op == OO_Subscript)
16333 Diag(FnDecl->getLocation(),
16334 (LangOpts.CPlusPlus23
16335 ? diag::warn_cxx20_compat_operator_overload_static
16336 : diag::ext_operator_overload_static))
16337 << FnDecl;
16338 else
16339 return Diag(FnDecl->getLocation(), diag::err_operator_overload_static)
16340 << FnDecl;
16341 }
16342 } else {
16343 bool ClassOrEnumParam = false;
16344 for (auto *Param : FnDecl->parameters()) {
16345 QualType ParamType = Param->getType().getNonReferenceType();
16346 if (ParamType->isDependentType() || ParamType->isRecordType() ||
16347 ParamType->isEnumeralType()) {
16348 ClassOrEnumParam = true;
16349 break;
16350 }
16351 }
16352
16353 if (!ClassOrEnumParam)
16354 return Diag(FnDecl->getLocation(),
16355 diag::err_operator_overload_needs_class_or_enum)
16356 << FnDecl->getDeclName();
16357 }
16358
16359 // C++ [over.oper]p8:
16360 // An operator function cannot have default arguments (8.3.6),
16361 // except where explicitly stated below.
16362 //
16363 // Only the function-call operator (C++ [over.call]p1) and the subscript
16364 // operator (CWG2507) allow default arguments.
16365 if (Op != OO_Call) {
16366 ParmVarDecl *FirstDefaultedParam = nullptr;
16367 for (auto *Param : FnDecl->parameters()) {
16368 if (Param->hasDefaultArg()) {
16369 FirstDefaultedParam = Param;
16370 break;
16371 }
16372 }
16373 if (FirstDefaultedParam) {
16374 if (Op == OO_Subscript) {
16375 Diag(FnDecl->getLocation(), LangOpts.CPlusPlus23
16376 ? diag::ext_subscript_overload
16377 : diag::error_subscript_overload)
16378 << FnDecl->getDeclName() << 1
16379 << FirstDefaultedParam->getDefaultArgRange();
16380 } else {
16381 return Diag(FirstDefaultedParam->getLocation(),
16382 diag::err_operator_overload_default_arg)
16383 << FnDecl->getDeclName()
16384 << FirstDefaultedParam->getDefaultArgRange();
16385 }
16386 }
16387 }
16388
16389 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
16390 { false, false, false }
16391#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
16392 , { Unary, Binary, MemberOnly }
16393#include "clang/Basic/OperatorKinds.def"
16394 };
16395
16396 bool CanBeUnaryOperator = OperatorUses[Op][0];
16397 bool CanBeBinaryOperator = OperatorUses[Op][1];
16398 bool MustBeMemberOperator = OperatorUses[Op][2];
16399
16400 // C++ [over.oper]p8:
16401 // [...] Operator functions cannot have more or fewer parameters
16402 // than the number required for the corresponding operator, as
16403 // described in the rest of this subclause.
16404 unsigned NumParams = FnDecl->getNumParams() +
16405 (isa<CXXMethodDecl>(FnDecl) &&
16407 ? 1
16408 : 0);
16409 if (Op != OO_Call && Op != OO_Subscript &&
16410 ((NumParams == 1 && !CanBeUnaryOperator) ||
16411 (NumParams == 2 && !CanBeBinaryOperator) || (NumParams < 1) ||
16412 (NumParams > 2))) {
16413 // We have the wrong number of parameters.
16414 unsigned ErrorKind;
16415 if (CanBeUnaryOperator && CanBeBinaryOperator) {
16416 ErrorKind = 2; // 2 -> unary or binary.
16417 } else if (CanBeUnaryOperator) {
16418 ErrorKind = 0; // 0 -> unary
16419 } else {
16420 assert(CanBeBinaryOperator &&
16421 "All non-call overloaded operators are unary or binary!");
16422 ErrorKind = 1; // 1 -> binary
16423 }
16424 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
16425 << FnDecl->getDeclName() << NumParams << ErrorKind;
16426 }
16427
16428 if (Op == OO_Subscript && NumParams != 2) {
16429 Diag(FnDecl->getLocation(), LangOpts.CPlusPlus23
16430 ? diag::ext_subscript_overload
16431 : diag::error_subscript_overload)
16432 << FnDecl->getDeclName() << (NumParams == 1 ? 0 : 2);
16433 }
16434
16435 // Overloaded operators other than operator() and operator[] cannot be
16436 // variadic.
16437 if (Op != OO_Call &&
16438 FnDecl->getType()->castAs<FunctionProtoType>()->isVariadic()) {
16439 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
16440 << FnDecl->getDeclName();
16441 }
16442
16443 // Some operators must be member functions.
16444 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
16445 return Diag(FnDecl->getLocation(),
16446 diag::err_operator_overload_must_be_member)
16447 << FnDecl->getDeclName();
16448 }
16449
16450 // C++ [over.inc]p1:
16451 // The user-defined function called operator++ implements the
16452 // prefix and postfix ++ operator. If this function is a member
16453 // function with no parameters, or a non-member function with one
16454 // parameter of class or enumeration type, it defines the prefix
16455 // increment operator ++ for objects of that type. If the function
16456 // is a member function with one parameter (which shall be of type
16457 // int) or a non-member function with two parameters (the second
16458 // of which shall be of type int), it defines the postfix
16459 // increment operator ++ for objects of that type.
16460 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
16461 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
16462 QualType ParamType = LastParam->getType();
16463
16464 if (!ParamType->isSpecificBuiltinType(BuiltinType::Int) &&
16465 !ParamType->isDependentType())
16466 return Diag(LastParam->getLocation(),
16467 diag::err_operator_overload_post_incdec_must_be_int)
16468 << LastParam->getType() << (Op == OO_MinusMinus);
16469 }
16470
16471 return false;
16472}
16473
16474static bool
16476 FunctionTemplateDecl *TpDecl) {
16477 TemplateParameterList *TemplateParams = TpDecl->getTemplateParameters();
16478
16479 // Must have one or two template parameters.
16480 if (TemplateParams->size() == 1) {
16481 NonTypeTemplateParmDecl *PmDecl =
16482 dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(0));
16483
16484 // The template parameter must be a char parameter pack.
16485 if (PmDecl && PmDecl->isTemplateParameterPack() &&
16487 return false;
16488
16489 // C++20 [over.literal]p5:
16490 // A string literal operator template is a literal operator template
16491 // whose template-parameter-list comprises a single non-type
16492 // template-parameter of class type.
16493 //
16494 // As a DR resolution, we also allow placeholders for deduced class
16495 // template specializations.
16496 if (SemaRef.getLangOpts().CPlusPlus20 && PmDecl &&
16497 !PmDecl->isTemplateParameterPack() &&
16498 (PmDecl->getType()->isRecordType() ||
16500 return false;
16501 } else if (TemplateParams->size() == 2) {
16502 TemplateTypeParmDecl *PmType =
16503 dyn_cast<TemplateTypeParmDecl>(TemplateParams->getParam(0));
16504 NonTypeTemplateParmDecl *PmArgs =
16505 dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(1));
16506
16507 // The second template parameter must be a parameter pack with the
16508 // first template parameter as its type.
16509 if (PmType && PmArgs && !PmType->isTemplateParameterPack() &&
16510 PmArgs->isTemplateParameterPack()) {
16511 const TemplateTypeParmType *TArgs =
16512 PmArgs->getType()->getAs<TemplateTypeParmType>();
16513 if (TArgs && TArgs->getDepth() == PmType->getDepth() &&
16514 TArgs->getIndex() == PmType->getIndex()) {
16516 SemaRef.Diag(TpDecl->getLocation(),
16517 diag::ext_string_literal_operator_template);
16518 return false;
16519 }
16520 }
16521 }
16522
16524 diag::err_literal_operator_template)
16525 << TpDecl->getTemplateParameters()->getSourceRange();
16526 return true;
16527}
16528
16530 if (isa<CXXMethodDecl>(FnDecl)) {
16531 Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
16532 << FnDecl->getDeclName();
16533 return true;
16534 }
16535
16536 if (FnDecl->isExternC()) {
16537 Diag(FnDecl->getLocation(), diag::err_literal_operator_extern_c);
16538 if (const LinkageSpecDecl *LSD =
16539 FnDecl->getDeclContext()->getExternCContext())
16540 Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
16541 return true;
16542 }
16543
16544 // This might be the definition of a literal operator template.
16546
16547 // This might be a specialization of a literal operator template.
16548 if (!TpDecl)
16549 TpDecl = FnDecl->getPrimaryTemplate();
16550
16551 // template <char...> type operator "" name() and
16552 // template <class T, T...> type operator "" name() are the only valid
16553 // template signatures, and the only valid signatures with no parameters.
16554 //
16555 // C++20 also allows template <SomeClass T> type operator "" name().
16556 if (TpDecl) {
16557 if (FnDecl->param_size() != 0) {
16558 Diag(FnDecl->getLocation(),
16559 diag::err_literal_operator_template_with_params);
16560 return true;
16561 }
16562
16564 return true;
16565
16566 } else if (FnDecl->param_size() == 1) {
16567 const ParmVarDecl *Param = FnDecl->getParamDecl(0);
16568
16569 QualType ParamType = Param->getType().getUnqualifiedType();
16570
16571 // Only unsigned long long int, long double, any character type, and const
16572 // char * are allowed as the only parameters.
16573 if (ParamType->isSpecificBuiltinType(BuiltinType::ULongLong) ||
16574 ParamType->isSpecificBuiltinType(BuiltinType::LongDouble) ||
16575 Context.hasSameType(ParamType, Context.CharTy) ||
16576 Context.hasSameType(ParamType, Context.WideCharTy) ||
16577 Context.hasSameType(ParamType, Context.Char8Ty) ||
16578 Context.hasSameType(ParamType, Context.Char16Ty) ||
16579 Context.hasSameType(ParamType, Context.Char32Ty)) {
16580 } else if (const PointerType *Ptr = ParamType->getAs<PointerType>()) {
16581 QualType InnerType = Ptr->getPointeeType();
16582
16583 // Pointer parameter must be a const char *.
16584 if (!(Context.hasSameType(InnerType.getUnqualifiedType(),
16585 Context.CharTy) &&
16586 InnerType.isConstQualified() && !InnerType.isVolatileQualified())) {
16587 Diag(Param->getSourceRange().getBegin(),
16588 diag::err_literal_operator_param)
16589 << ParamType << "'const char *'" << Param->getSourceRange();
16590 return true;
16591 }
16592
16593 } else if (ParamType->isRealFloatingType()) {
16594 Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
16595 << ParamType << Context.LongDoubleTy << Param->getSourceRange();
16596 return true;
16597
16598 } else if (ParamType->isIntegerType()) {
16599 Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
16600 << ParamType << Context.UnsignedLongLongTy << Param->getSourceRange();
16601 return true;
16602
16603 } else {
16604 Diag(Param->getSourceRange().getBegin(),
16605 diag::err_literal_operator_invalid_param)
16606 << ParamType << Param->getSourceRange();
16607 return true;
16608 }
16609
16610 } else if (FnDecl->param_size() == 2) {
16611 FunctionDecl::param_iterator Param = FnDecl->param_begin();
16612
16613 // First, verify that the first parameter is correct.
16614
16615 QualType FirstParamType = (*Param)->getType().getUnqualifiedType();
16616
16617 // Two parameter function must have a pointer to const as a
16618 // first parameter; let's strip those qualifiers.
16619 const PointerType *PT = FirstParamType->getAs<PointerType>();
16620
16621 if (!PT) {
16622 Diag((*Param)->getSourceRange().getBegin(),
16623 diag::err_literal_operator_param)
16624 << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
16625 return true;
16626 }
16627
16628 QualType PointeeType = PT->getPointeeType();
16629 // First parameter must be const
16630 if (!PointeeType.isConstQualified() || PointeeType.isVolatileQualified()) {
16631 Diag((*Param)->getSourceRange().getBegin(),
16632 diag::err_literal_operator_param)
16633 << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
16634 return true;
16635 }
16636
16637 QualType InnerType = PointeeType.getUnqualifiedType();
16638 // Only const char *, const wchar_t*, const char8_t*, const char16_t*, and
16639 // const char32_t* are allowed as the first parameter to a two-parameter
16640 // function
16641 if (!(Context.hasSameType(InnerType, Context.CharTy) ||
16642 Context.hasSameType(InnerType, Context.WideCharTy) ||
16643 Context.hasSameType(InnerType, Context.Char8Ty) ||
16644 Context.hasSameType(InnerType, Context.Char16Ty) ||
16645 Context.hasSameType(InnerType, Context.Char32Ty))) {
16646 Diag((*Param)->getSourceRange().getBegin(),
16647 diag::err_literal_operator_param)
16648 << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
16649 return true;
16650 }
16651
16652 // Move on to the second and final parameter.
16653 ++Param;
16654
16655 // The second parameter must be a std::size_t.
16656 QualType SecondParamType = (*Param)->getType().getUnqualifiedType();
16657 if (!Context.hasSameType(SecondParamType, Context.getSizeType())) {
16658 Diag((*Param)->getSourceRange().getBegin(),
16659 diag::err_literal_operator_param)
16660 << SecondParamType << Context.getSizeType()
16661 << (*Param)->getSourceRange();
16662 return true;
16663 }
16664 } else {
16665 Diag(FnDecl->getLocation(), diag::err_literal_operator_bad_param_count);
16666 return true;
16667 }
16668
16669 // Parameters are good.
16670
16671 // A parameter-declaration-clause containing a default argument is not
16672 // equivalent to any of the permitted forms.
16673 for (auto *Param : FnDecl->parameters()) {
16674 if (Param->hasDefaultArg()) {
16675 Diag(Param->getDefaultArgRange().getBegin(),
16676 diag::err_literal_operator_default_argument)
16677 << Param->getDefaultArgRange();
16678 break;
16679 }
16680 }
16681
16682 const IdentifierInfo *II = FnDecl->getDeclName().getCXXLiteralIdentifier();
16685 !getSourceManager().isInSystemHeader(FnDecl->getLocation())) {
16686 // C++23 [usrlit.suffix]p1:
16687 // Literal suffix identifiers that do not start with an underscore are
16688 // reserved for future standardization. Literal suffix identifiers that
16689 // contain a double underscore __ are reserved for use by C++
16690 // implementations.
16691 Diag(FnDecl->getLocation(), diag::warn_user_literal_reserved)
16692 << static_cast<int>(Status)
16694 }
16695
16696 return false;
16697}
16698
16700 Expr *LangStr,
16701 SourceLocation LBraceLoc) {
16702 StringLiteral *Lit = cast<StringLiteral>(LangStr);
16703 assert(Lit->isUnevaluated() && "Unexpected string literal kind");
16704
16705 StringRef Lang = Lit->getString();
16707 if (Lang == "C")
16709 else if (Lang == "C++")
16711 else {
16712 Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_unknown)
16713 << LangStr->getSourceRange();
16714 return nullptr;
16715 }
16716
16717 // FIXME: Add all the various semantics of linkage specifications
16718
16720 LangStr->getExprLoc(), Language,
16721 LBraceLoc.isValid());
16722
16723 /// C++ [module.unit]p7.2.3
16724 /// - Otherwise, if the declaration
16725 /// - ...
16726 /// - ...
16727 /// - appears within a linkage-specification,
16728 /// it is attached to the global module.
16729 ///
16730 /// If the declaration is already in global module fragment, we don't
16731 /// need to attach it again.
16732 if (getLangOpts().CPlusPlusModules && isCurrentModulePurview()) {
16733 Module *GlobalModule = PushImplicitGlobalModuleFragment(ExternLoc);
16734 D->setLocalOwningModule(GlobalModule);
16735 }
16736
16738 PushDeclContext(S, D);
16739 return D;
16740}
16741
16743 Decl *LinkageSpec,
16744 SourceLocation RBraceLoc) {
16745 if (RBraceLoc.isValid()) {
16746 LinkageSpecDecl* LSDecl = cast<LinkageSpecDecl>(LinkageSpec);
16747 LSDecl->setRBraceLoc(RBraceLoc);
16748 }
16749
16750 // If the current module doesn't has Parent, it implies that the
16751 // LinkageSpec isn't in the module created by itself. So we don't
16752 // need to pop it.
16753 if (getLangOpts().CPlusPlusModules && getCurrentModule() &&
16754 getCurrentModule()->isImplicitGlobalModule() &&
16756 PopImplicitGlobalModuleFragment();
16757
16759 return LinkageSpec;
16760}
16761
16763 const ParsedAttributesView &AttrList,
16764 SourceLocation SemiLoc) {
16765 Decl *ED = EmptyDecl::Create(Context, CurContext, SemiLoc);
16766 // Attribute declarations appertain to empty declaration so we handle
16767 // them here.
16768 ProcessDeclAttributeList(S, ED, AttrList);
16769
16770 CurContext->addDecl(ED);
16771 return ED;
16772}
16773
16775 SourceLocation StartLoc,
16777 const IdentifierInfo *Name) {
16778 bool Invalid = false;
16779 QualType ExDeclType = TInfo->getType();
16780
16781 // Arrays and functions decay.
16782 if (ExDeclType->isArrayType())
16783 ExDeclType = Context.getArrayDecayedType(ExDeclType);
16784 else if (ExDeclType->isFunctionType())
16785 ExDeclType = Context.getPointerType(ExDeclType);
16786
16787 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
16788 // The exception-declaration shall not denote a pointer or reference to an
16789 // incomplete type, other than [cv] void*.
16790 // N2844 forbids rvalue references.
16791 if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
16792 Diag(Loc, diag::err_catch_rvalue_ref);
16793 Invalid = true;
16794 }
16795
16796 if (ExDeclType->isVariablyModifiedType()) {
16797 Diag(Loc, diag::err_catch_variably_modified) << ExDeclType;
16798 Invalid = true;
16799 }
16800
16801 QualType BaseType = ExDeclType;
16802 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
16803 unsigned DK = diag::err_catch_incomplete;
16804 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
16805 BaseType = Ptr->getPointeeType();
16806 Mode = 1;
16807 DK = diag::err_catch_incomplete_ptr;
16808 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
16809 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
16810 BaseType = Ref->getPointeeType();
16811 Mode = 2;
16812 DK = diag::err_catch_incomplete_ref;
16813 }
16814 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
16815 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
16816 Invalid = true;
16817
16818 if (!Invalid && BaseType.isWebAssemblyReferenceType()) {
16819 Diag(Loc, diag::err_wasm_reftype_tc) << 1;
16820 Invalid = true;
16821 }
16822
16823 if (!Invalid && Mode != 1 && BaseType->isSizelessType()) {
16824 Diag(Loc, diag::err_catch_sizeless) << (Mode == 2 ? 1 : 0) << BaseType;
16825 Invalid = true;
16826 }
16827
16828 if (!Invalid && !ExDeclType->isDependentType() &&
16829 RequireNonAbstractType(Loc, ExDeclType,
16830 diag::err_abstract_type_in_decl,
16832 Invalid = true;
16833
16834 // Only the non-fragile NeXT runtime currently supports C++ catches
16835 // of ObjC types, and no runtime supports catching ObjC types by value.
16836 if (!Invalid && getLangOpts().ObjC) {
16837 QualType T = ExDeclType;
16838 if (const ReferenceType *RT = T->getAs<ReferenceType>())
16839 T = RT->getPointeeType();
16840
16841 if (T->isObjCObjectType()) {
16842 Diag(Loc, diag::err_objc_object_catch);
16843 Invalid = true;
16844 } else if (T->isObjCObjectPointerType()) {
16845 // FIXME: should this be a test for macosx-fragile specifically?
16847 Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
16848 }
16849 }
16850
16851 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
16852 ExDeclType, TInfo, SC_None);
16853 ExDecl->setExceptionVariable(true);
16854
16855 // In ARC, infer 'retaining' for variables of retainable type.
16856 if (getLangOpts().ObjCAutoRefCount && ObjC().inferObjCARCLifetime(ExDecl))
16857 Invalid = true;
16858
16859 if (!Invalid && !ExDeclType->isDependentType()) {
16860 if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) {
16861 // Insulate this from anything else we might currently be parsing.
16864
16865 // C++ [except.handle]p16:
16866 // The object declared in an exception-declaration or, if the
16867 // exception-declaration does not specify a name, a temporary (12.2) is
16868 // copy-initialized (8.5) from the exception object. [...]
16869 // The object is destroyed when the handler exits, after the destruction
16870 // of any automatic objects initialized within the handler.
16871 //
16872 // We just pretend to initialize the object with itself, then make sure
16873 // it can be destroyed later.
16874 QualType initType = Context.getExceptionObjectType(ExDeclType);
16875
16876 InitializedEntity entity =
16878 InitializationKind initKind =
16880
16881 Expr *opaqueValue =
16882 new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary);
16883 InitializationSequence sequence(*this, entity, initKind, opaqueValue);
16884 ExprResult result = sequence.Perform(*this, entity, initKind, opaqueValue);
16885 if (result.isInvalid())
16886 Invalid = true;
16887 else {
16888 // If the constructor used was non-trivial, set this as the
16889 // "initializer".
16890 CXXConstructExpr *construct = result.getAs<CXXConstructExpr>();
16891 if (!construct->getConstructor()->isTrivial()) {
16892 Expr *init = MaybeCreateExprWithCleanups(construct);
16893 ExDecl->setInit(init);
16894 }
16895
16896 // And make sure it's destructable.
16898 }
16899 }
16900 }
16901
16902 if (Invalid)
16903 ExDecl->setInvalidDecl();
16904
16905 return ExDecl;
16906}
16907
16910 bool Invalid = D.isInvalidType();
16911
16912 // Check for unexpanded parameter packs.
16913 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
16916 D.getIdentifierLoc());
16917 Invalid = true;
16918 }
16919
16920 const IdentifierInfo *II = D.getIdentifier();
16921 if (NamedDecl *PrevDecl =
16922 LookupSingleName(S, II, D.getIdentifierLoc(), LookupOrdinaryName,
16923 RedeclarationKind::ForVisibleRedeclaration)) {
16924 // The scope should be freshly made just for us. There is just no way
16925 // it contains any previous declaration, except for function parameters in
16926 // a function-try-block's catch statement.
16927 assert(!S->isDeclScope(PrevDecl));
16928 if (isDeclInScope(PrevDecl, CurContext, S)) {
16929 Diag(D.getIdentifierLoc(), diag::err_redefinition)
16930 << D.getIdentifier();
16931 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
16932 Invalid = true;
16933 } else if (PrevDecl->isTemplateParameter())
16934 // Maybe we will complain about the shadowed template parameter.
16935 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
16936 }
16937
16938 if (D.getCXXScopeSpec().isSet() && !Invalid) {
16939 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
16940 << D.getCXXScopeSpec().getRange();
16941 Invalid = true;
16942 }
16943
16945 S, TInfo, D.getBeginLoc(), D.getIdentifierLoc(), D.getIdentifier());
16946 if (Invalid)
16947 ExDecl->setInvalidDecl();
16948
16949 // Add the exception declaration into this scope.
16950 if (II)
16951 PushOnScopeChains(ExDecl, S);
16952 else
16953 CurContext->addDecl(ExDecl);
16954
16955 ProcessDeclAttributes(S, ExDecl, D);
16956 return ExDecl;
16957}
16958
16960 Expr *AssertExpr,
16961 Expr *AssertMessageExpr,
16962 SourceLocation RParenLoc) {
16964 return nullptr;
16965
16966 return BuildStaticAssertDeclaration(StaticAssertLoc, AssertExpr,
16967 AssertMessageExpr, RParenLoc, false);
16968}
16969
16970static void WriteCharTypePrefix(BuiltinType::Kind BTK, llvm::raw_ostream &OS) {
16971 switch (BTK) {
16972 case BuiltinType::Char_S:
16973 case BuiltinType::Char_U:
16974 break;
16975 case BuiltinType::Char8:
16976 OS << "u8";
16977 break;
16978 case BuiltinType::Char16:
16979 OS << 'u';
16980 break;
16981 case BuiltinType::Char32:
16982 OS << 'U';
16983 break;
16984 case BuiltinType::WChar_S:
16985 case BuiltinType::WChar_U:
16986 OS << 'L';
16987 break;
16988 default:
16989 llvm_unreachable("Non-character type");
16990 }
16991}
16992
16993/// Convert character's value, interpreted as a code unit, to a string.
16994/// The value needs to be zero-extended to 32-bits.
16995/// FIXME: This assumes Unicode literal encodings
16996static void WriteCharValueForDiagnostic(uint32_t Value, const BuiltinType *BTy,
16997 unsigned TyWidth,
16998 SmallVectorImpl<char> &Str) {
16999 char Arr[UNI_MAX_UTF8_BYTES_PER_CODE_POINT];
17000 char *Ptr = Arr;
17001 BuiltinType::Kind K = BTy->getKind();
17002 llvm::raw_svector_ostream OS(Str);
17003
17004 // This should catch Char_S, Char_U, Char8, and use of escaped characters in
17005 // other types.
17006 if (K == BuiltinType::Char_S || K == BuiltinType::Char_U ||
17007 K == BuiltinType::Char8 || Value <= 0x7F) {
17008 StringRef Escaped = escapeCStyle<EscapeChar::Single>(Value);
17009 if (!Escaped.empty())
17010 EscapeStringForDiagnostic(Escaped, Str);
17011 else
17012 OS << static_cast<char>(Value);
17013 return;
17014 }
17015
17016 switch (K) {
17017 case BuiltinType::Char16:
17018 case BuiltinType::Char32:
17019 case BuiltinType::WChar_S:
17020 case BuiltinType::WChar_U: {
17021 if (llvm::ConvertCodePointToUTF8(Value, Ptr))
17022 EscapeStringForDiagnostic(StringRef(Arr, Ptr - Arr), Str);
17023 else
17024 OS << "\\x"
17025 << llvm::format_hex_no_prefix(Value, TyWidth / 4, /*Upper=*/true);
17026 break;
17027 }
17028 default:
17029 llvm_unreachable("Non-character type is passed");
17030 }
17031}
17032
17033/// Convert \V to a string we can present to the user in a diagnostic
17034/// \T is the type of the expression that has been evaluated into \V
17038 if (!V.hasValue())
17039 return false;
17040
17041 switch (V.getKind()) {
17043 if (T->isBooleanType()) {
17044 // Bools are reduced to ints during evaluation, but for
17045 // diagnostic purposes we want to print them as
17046 // true or false.
17047 int64_t BoolValue = V.getInt().getExtValue();
17048 assert((BoolValue == 0 || BoolValue == 1) &&
17049 "Bool type, but value is not 0 or 1");
17050 llvm::raw_svector_ostream OS(Str);
17051 OS << (BoolValue ? "true" : "false");
17052 } else {
17053 llvm::raw_svector_ostream OS(Str);
17054 // Same is true for chars.
17055 // We want to print the character representation for textual types
17056 const auto *BTy = T->getAs<BuiltinType>();
17057 if (BTy) {
17058 switch (BTy->getKind()) {
17059 case BuiltinType::Char_S:
17060 case BuiltinType::Char_U:
17061 case BuiltinType::Char8:
17062 case BuiltinType::Char16:
17063 case BuiltinType::Char32:
17064 case BuiltinType::WChar_S:
17065 case BuiltinType::WChar_U: {
17066 unsigned TyWidth = Context.getIntWidth(T);
17067 assert(8 <= TyWidth && TyWidth <= 32 && "Unexpected integer width");
17068 uint32_t CodeUnit = static_cast<uint32_t>(V.getInt().getZExtValue());
17069 WriteCharTypePrefix(BTy->getKind(), OS);
17070 OS << '\'';
17071 WriteCharValueForDiagnostic(CodeUnit, BTy, TyWidth, Str);
17072 OS << "' (0x"
17073 << llvm::format_hex_no_prefix(CodeUnit, /*Width=*/2,
17074 /*Upper=*/true)
17075 << ", " << V.getInt() << ')';
17076 return true;
17077 }
17078 default:
17079 break;
17080 }
17081 }
17082 V.getInt().toString(Str);
17083 }
17084
17085 break;
17086
17088 V.getFloat().toString(Str);
17089 break;
17090
17092 if (V.isNullPointer()) {
17093 llvm::raw_svector_ostream OS(Str);
17094 OS << "nullptr";
17095 } else
17096 return false;
17097 break;
17098
17100 llvm::raw_svector_ostream OS(Str);
17101 OS << '(';
17102 V.getComplexFloatReal().toString(Str);
17103 OS << " + ";
17104 V.getComplexFloatImag().toString(Str);
17105 OS << "i)";
17106 } break;
17107
17109 llvm::raw_svector_ostream OS(Str);
17110 OS << '(';
17111 V.getComplexIntReal().toString(Str);
17112 OS << " + ";
17113 V.getComplexIntImag().toString(Str);
17114 OS << "i)";
17115 } break;
17116
17117 default:
17118 return false;
17119 }
17120
17121 return true;
17122}
17123
17124/// Some Expression types are not useful to print notes about,
17125/// e.g. literals and values that have already been expanded
17126/// before such as int-valued template parameters.
17127static bool UsefulToPrintExpr(const Expr *E) {
17128 E = E->IgnoreParenImpCasts();
17129 // Literals are pretty easy for humans to understand.
17132 return false;
17133
17134 // These have been substituted from template parameters
17135 // and appear as literals in the static assert error.
17136 if (isa<SubstNonTypeTemplateParmExpr>(E))
17137 return false;
17138
17139 // -5 is also simple to understand.
17140 if (const auto *UnaryOp = dyn_cast<UnaryOperator>(E))
17141 return UsefulToPrintExpr(UnaryOp->getSubExpr());
17142
17143 // Only print nested arithmetic operators.
17144 if (const auto *BO = dyn_cast<BinaryOperator>(E))
17145 return (BO->isShiftOp() || BO->isAdditiveOp() || BO->isMultiplicativeOp() ||
17146 BO->isBitwiseOp());
17147
17148 return true;
17149}
17150
17152 if (const auto *Op = dyn_cast<BinaryOperator>(E);
17153 Op && Op->getOpcode() != BO_LOr) {
17154 const Expr *LHS = Op->getLHS()->IgnoreParenImpCasts();
17155 const Expr *RHS = Op->getRHS()->IgnoreParenImpCasts();
17156
17157 // Ignore comparisons of boolean expressions with a boolean literal.
17158 if ((isa<CXXBoolLiteralExpr>(LHS) && RHS->getType()->isBooleanType()) ||
17159 (isa<CXXBoolLiteralExpr>(RHS) && LHS->getType()->isBooleanType()))
17160 return;
17161
17162 // Don't print obvious expressions.
17163 if (!UsefulToPrintExpr(LHS) && !UsefulToPrintExpr(RHS))
17164 return;
17165
17166 struct {
17167 const clang::Expr *Cond;
17169 SmallString<12> ValueString;
17170 bool Print;
17171 } DiagSide[2] = {{LHS, Expr::EvalResult(), {}, false},
17172 {RHS, Expr::EvalResult(), {}, false}};
17173 for (unsigned I = 0; I < 2; I++) {
17174 const Expr *Side = DiagSide[I].Cond;
17175
17176 Side->EvaluateAsRValue(DiagSide[I].Result, Context, true);
17177
17178 DiagSide[I].Print =
17179 ConvertAPValueToString(DiagSide[I].Result.Val, Side->getType(),
17180 DiagSide[I].ValueString, Context);
17181 }
17182 if (DiagSide[0].Print && DiagSide[1].Print) {
17183 Diag(Op->getExprLoc(), diag::note_expr_evaluates_to)
17184 << DiagSide[0].ValueString << Op->getOpcodeStr()
17185 << DiagSide[1].ValueString << Op->getSourceRange();
17186 }
17187 }
17188}
17189
17191 std::string &Result,
17192 ASTContext &Ctx,
17193 bool ErrorOnInvalidMessage) {
17194 assert(Message);
17195 assert(!Message->isTypeDependent() && !Message->isValueDependent() &&
17196 "can't evaluate a dependant static assert message");
17197
17198 if (const auto *SL = dyn_cast<StringLiteral>(Message)) {
17199 assert(SL->isUnevaluated() && "expected an unevaluated string");
17200 Result.assign(SL->getString().begin(), SL->getString().end());
17201 return true;
17202 }
17203
17204 SourceLocation Loc = Message->getBeginLoc();
17205 QualType T = Message->getType().getNonReferenceType();
17206 auto *RD = T->getAsCXXRecordDecl();
17207 if (!RD) {
17208 Diag(Loc, diag::err_static_assert_invalid_message);
17209 return false;
17210 }
17211
17212 auto FindMember = [&](StringRef Member, bool &Empty,
17213 bool Diag = false) -> std::optional<LookupResult> {
17215 LookupResult MemberLookup(*this, DN, Loc, Sema::LookupMemberName);
17216 LookupQualifiedName(MemberLookup, RD);
17217 Empty = MemberLookup.empty();
17218 OverloadCandidateSet Candidates(MemberLookup.getNameLoc(),
17220 if (MemberLookup.empty())
17221 return std::nullopt;
17222 return std::move(MemberLookup);
17223 };
17224
17225 bool SizeNotFound, DataNotFound;
17226 std::optional<LookupResult> SizeMember = FindMember("size", SizeNotFound);
17227 std::optional<LookupResult> DataMember = FindMember("data", DataNotFound);
17228 if (SizeNotFound || DataNotFound) {
17229 Diag(Loc, diag::err_static_assert_missing_member_function)
17230 << ((SizeNotFound && DataNotFound) ? 2
17231 : SizeNotFound ? 0
17232 : 1);
17233 return false;
17234 }
17235
17236 if (!SizeMember || !DataMember) {
17237 if (!SizeMember)
17238 FindMember("size", SizeNotFound, /*Diag=*/true);
17239 if (!DataMember)
17240 FindMember("data", DataNotFound, /*Diag=*/true);
17241 return false;
17242 }
17243
17244 auto BuildExpr = [&](LookupResult &LR) {
17246 Message, Message->getType(), Message->getBeginLoc(), false,
17247 CXXScopeSpec(), SourceLocation(), nullptr, LR, nullptr, nullptr);
17248 if (Res.isInvalid())
17249 return ExprError();
17250 Res = BuildCallExpr(nullptr, Res.get(), Loc, {}, Loc, nullptr, false, true);
17251 if (Res.isInvalid())
17252 return ExprError();
17253 if (Res.get()->isTypeDependent() || Res.get()->isValueDependent())
17254 return ExprError();
17256 };
17257
17258 ExprResult SizeE = BuildExpr(*SizeMember);
17259 ExprResult DataE = BuildExpr(*DataMember);
17260
17261 QualType SizeT = Context.getSizeType();
17262 QualType ConstCharPtr =
17264
17265 ExprResult EvaluatedSize =
17266 SizeE.isInvalid() ? ExprError()
17268 SizeE.get(), SizeT, CCEK_StaticAssertMessageSize);
17269 if (EvaluatedSize.isInvalid()) {
17270 Diag(Loc, diag::err_static_assert_invalid_mem_fn_ret_ty) << /*size*/ 0;
17271 return false;
17272 }
17273
17274 ExprResult EvaluatedData =
17275 DataE.isInvalid()
17276 ? ExprError()
17277 : BuildConvertedConstantExpression(DataE.get(), ConstCharPtr,
17279 if (EvaluatedData.isInvalid()) {
17280 Diag(Loc, diag::err_static_assert_invalid_mem_fn_ret_ty) << /*data*/ 1;
17281 return false;
17282 }
17283
17284 if (!ErrorOnInvalidMessage &&
17285 Diags.isIgnored(diag::warn_static_assert_message_constexpr, Loc))
17286 return true;
17287
17288 Expr::EvalResult Status;
17290 Status.Diag = &Notes;
17291 if (!Message->EvaluateCharRangeAsString(Result, EvaluatedSize.get(),
17292 EvaluatedData.get(), Ctx, Status) ||
17293 !Notes.empty()) {
17294 Diag(Message->getBeginLoc(),
17295 ErrorOnInvalidMessage ? diag::err_static_assert_message_constexpr
17296 : diag::warn_static_assert_message_constexpr);
17297 for (const auto &Note : Notes)
17298 Diag(Note.first, Note.second);
17299 return !ErrorOnInvalidMessage;
17300 }
17301 return true;
17302}
17303
17305 Expr *AssertExpr, Expr *AssertMessage,
17306 SourceLocation RParenLoc,
17307 bool Failed) {
17308 assert(AssertExpr != nullptr && "Expected non-null condition");
17309 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent() &&
17310 (!AssertMessage || (!AssertMessage->isTypeDependent() &&
17311 !AssertMessage->isValueDependent())) &&
17312 !Failed) {
17313 // In a static_assert-declaration, the constant-expression shall be a
17314 // constant expression that can be contextually converted to bool.
17315 ExprResult Converted = PerformContextuallyConvertToBool(AssertExpr);
17316 if (Converted.isInvalid())
17317 Failed = true;
17318
17319 ExprResult FullAssertExpr =
17320 ActOnFinishFullExpr(Converted.get(), StaticAssertLoc,
17321 /*DiscardedValue*/ false,
17322 /*IsConstexpr*/ true);
17323 if (FullAssertExpr.isInvalid())
17324 Failed = true;
17325 else
17326 AssertExpr = FullAssertExpr.get();
17327
17328 llvm::APSInt Cond;
17329 Expr *BaseExpr = AssertExpr;
17330 AllowFoldKind FoldKind = NoFold;
17331
17332 if (!getLangOpts().CPlusPlus) {
17333 // In C mode, allow folding as an extension for better compatibility with
17334 // C++ in terms of expressions like static_assert("test") or
17335 // static_assert(nullptr).
17336 FoldKind = AllowFold;
17337 }
17338
17339 if (!Failed && VerifyIntegerConstantExpression(
17340 BaseExpr, &Cond,
17341 diag::err_static_assert_expression_is_not_constant,
17342 FoldKind).isInvalid())
17343 Failed = true;
17344
17345 // If the static_assert passes, only verify that
17346 // the message is grammatically valid without evaluating it.
17347 if (!Failed && AssertMessage && Cond.getBoolValue()) {
17348 std::string Str;
17349 EvaluateStaticAssertMessageAsString(AssertMessage, Str, Context,
17350 /*ErrorOnInvalidMessage=*/false);
17351 }
17352
17353 // CWG2518
17354 // [dcl.pre]/p10 If [...] the expression is evaluated in the context of a
17355 // template definition, the declaration has no effect.
17356 bool InTemplateDefinition =
17357 getLangOpts().CPlusPlus && CurContext->isDependentContext();
17358
17359 if (!Failed && !Cond && !InTemplateDefinition) {
17360 SmallString<256> MsgBuffer;
17361 llvm::raw_svector_ostream Msg(MsgBuffer);
17362 bool HasMessage = AssertMessage;
17363 if (AssertMessage) {
17364 std::string Str;
17365 HasMessage =
17367 AssertMessage, Str, Context, /*ErrorOnInvalidMessage=*/true) ||
17368 !Str.empty();
17369 Msg << Str;
17370 }
17371 Expr *InnerCond = nullptr;
17372 std::string InnerCondDescription;
17373 std::tie(InnerCond, InnerCondDescription) =
17374 findFailedBooleanCondition(Converted.get());
17375 if (InnerCond && isa<ConceptSpecializationExpr>(InnerCond)) {
17376 // Drill down into concept specialization expressions to see why they
17377 // weren't satisfied.
17378 Diag(AssertExpr->getBeginLoc(), diag::err_static_assert_failed)
17379 << !HasMessage << Msg.str() << AssertExpr->getSourceRange();
17380 ConstraintSatisfaction Satisfaction;
17381 if (!CheckConstraintSatisfaction(InnerCond, Satisfaction))
17382 DiagnoseUnsatisfiedConstraint(Satisfaction);
17383 } else if (InnerCond && !isa<CXXBoolLiteralExpr>(InnerCond)
17384 && !isa<IntegerLiteral>(InnerCond)) {
17385 Diag(InnerCond->getBeginLoc(),
17386 diag::err_static_assert_requirement_failed)
17387 << InnerCondDescription << !HasMessage << Msg.str()
17388 << InnerCond->getSourceRange();
17389 DiagnoseStaticAssertDetails(InnerCond);
17390 } else {
17391 Diag(AssertExpr->getBeginLoc(), diag::err_static_assert_failed)
17392 << !HasMessage << Msg.str() << AssertExpr->getSourceRange();
17394 }
17395 Failed = true;
17396 }
17397 } else {
17398 ExprResult FullAssertExpr = ActOnFinishFullExpr(AssertExpr, StaticAssertLoc,
17399 /*DiscardedValue*/false,
17400 /*IsConstexpr*/true);
17401 if (FullAssertExpr.isInvalid())
17402 Failed = true;
17403 else
17404 AssertExpr = FullAssertExpr.get();
17405 }
17406
17408 AssertExpr, AssertMessage, RParenLoc,
17409 Failed);
17410
17412 return Decl;
17413}
17414
17416 Scope *S, SourceLocation FriendLoc, unsigned TagSpec, SourceLocation TagLoc,
17417 CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
17418 SourceLocation EllipsisLoc, const ParsedAttributesView &Attr,
17419 MultiTemplateParamsArg TempParamLists) {
17421
17422 bool IsMemberSpecialization = false;
17423 bool Invalid = false;
17424
17425 if (TemplateParameterList *TemplateParams =
17427 TagLoc, NameLoc, SS, nullptr, TempParamLists, /*friend*/ true,
17428 IsMemberSpecialization, Invalid)) {
17429 if (TemplateParams->size() > 0) {
17430 // This is a declaration of a class template.
17431 if (Invalid)
17432 return true;
17433
17434 return CheckClassTemplate(S, TagSpec, TagUseKind::Friend, TagLoc, SS,
17435 Name, NameLoc, Attr, TemplateParams, AS_public,
17436 /*ModulePrivateLoc=*/SourceLocation(),
17437 FriendLoc, TempParamLists.size() - 1,
17438 TempParamLists.data())
17439 .get();
17440 } else {
17441 // The "template<>" header is extraneous.
17442 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
17443 << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
17444 IsMemberSpecialization = true;
17445 }
17446 }
17447
17448 if (Invalid) return true;
17449
17450 bool isAllExplicitSpecializations = true;
17451 for (unsigned I = TempParamLists.size(); I-- > 0; ) {
17452 if (TempParamLists[I]->size()) {
17453 isAllExplicitSpecializations = false;
17454 break;
17455 }
17456 }
17457
17458 // FIXME: don't ignore attributes.
17459
17460 // If it's explicit specializations all the way down, just forget
17461 // about the template header and build an appropriate non-templated
17462 // friend. TODO: for source fidelity, remember the headers.
17464 if (isAllExplicitSpecializations) {
17465 if (SS.isEmpty()) {
17466 bool Owned = false;
17467 bool IsDependent = false;
17468 return ActOnTag(S, TagSpec, TagUseKind::Friend, TagLoc, SS, Name, NameLoc,
17469 Attr, AS_public,
17470 /*ModulePrivateLoc=*/SourceLocation(),
17471 MultiTemplateParamsArg(), Owned, IsDependent,
17472 /*ScopedEnumKWLoc=*/SourceLocation(),
17473 /*ScopedEnumUsesClassTag=*/false,
17474 /*UnderlyingType=*/TypeResult(),
17475 /*IsTypeSpecifier=*/false,
17476 /*IsTemplateParamOrArg=*/false, /*OOK=*/OOK_Outside);
17477 }
17478
17479 ElaboratedTypeKeyword Keyword
17481 QualType T = CheckTypenameType(Keyword, TagLoc, QualifierLoc,
17482 *Name, NameLoc);
17483 if (T.isNull())
17484 return true;
17485
17487 if (isa<DependentNameType>(T)) {
17490 TL.setElaboratedKeywordLoc(TagLoc);
17491 TL.setQualifierLoc(QualifierLoc);
17492 TL.setNameLoc(NameLoc);
17493 } else {
17495 TL.setElaboratedKeywordLoc(TagLoc);
17496 TL.setQualifierLoc(QualifierLoc);
17497 TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(NameLoc);
17498 }
17499
17501 FriendDecl::Create(Context, CurContext, NameLoc, TSI, FriendLoc,
17502 EllipsisLoc, TempParamLists);
17503 Friend->setAccess(AS_public);
17505 return Friend;
17506 }
17507
17508 assert(SS.isNotEmpty() && "valid templated tag with no SS and no direct?");
17509
17510 // CWG 2917: if it (= the friend-type-specifier) is a pack expansion
17511 // (13.7.4 [temp.variadic]), any packs expanded by that pack expansion
17512 // shall not have been introduced by the template-declaration.
17514 collectUnexpandedParameterPacks(QualifierLoc, Unexpanded);
17515 unsigned FriendDeclDepth = TempParamLists.front()->getDepth();
17516 for (UnexpandedParameterPack &U : Unexpanded) {
17517 if (getDepthAndIndex(U).first >= FriendDeclDepth) {
17518 auto *ND = U.first.dyn_cast<NamedDecl *>();
17519 if (!ND)
17520 ND = cast<const TemplateTypeParmType *>(U.first)->getDecl();
17521 Diag(U.second, diag::friend_template_decl_malformed_pack_expansion)
17522 << ND->getDeclName() << SourceRange(SS.getBeginLoc(), EllipsisLoc);
17523 return true;
17524 }
17525 }
17526
17527 // Handle the case of a templated-scope friend class. e.g.
17528 // template <class T> class A<T>::B;
17529 // FIXME: we don't support these right now.
17530 Diag(NameLoc, diag::warn_template_qualified_friend_unsupported)
17531 << SS.getScopeRep() << SS.getRange() << cast<CXXRecordDecl>(CurContext);
17536 TL.setElaboratedKeywordLoc(TagLoc);
17538 TL.setNameLoc(NameLoc);
17539
17541 FriendDecl::Create(Context, CurContext, NameLoc, TSI, FriendLoc,
17542 EllipsisLoc, TempParamLists);
17543 Friend->setAccess(AS_public);
17544 Friend->setUnsupportedFriend(true);
17546 return Friend;
17547}
17548
17550 MultiTemplateParamsArg TempParams,
17551 SourceLocation EllipsisLoc) {
17553 SourceLocation FriendLoc = DS.getFriendSpecLoc();
17554
17555 assert(DS.isFriendSpecified());
17557
17558 // C++ [class.friend]p3:
17559 // A friend declaration that does not declare a function shall have one of
17560 // the following forms:
17561 // friend elaborated-type-specifier ;
17562 // friend simple-type-specifier ;
17563 // friend typename-specifier ;
17564 //
17565 // If the friend keyword isn't first, or if the declarations has any type
17566 // qualifiers, then the declaration doesn't have that form.
17568 Diag(FriendLoc, diag::err_friend_not_first_in_declaration);
17569 if (DS.getTypeQualifiers()) {
17571 Diag(DS.getConstSpecLoc(), diag::err_friend_decl_spec) << "const";
17573 Diag(DS.getVolatileSpecLoc(), diag::err_friend_decl_spec) << "volatile";
17575 Diag(DS.getRestrictSpecLoc(), diag::err_friend_decl_spec) << "restrict";
17577 Diag(DS.getAtomicSpecLoc(), diag::err_friend_decl_spec) << "_Atomic";
17579 Diag(DS.getUnalignedSpecLoc(), diag::err_friend_decl_spec) << "__unaligned";
17580 }
17581
17582 // Try to convert the decl specifier to a type. This works for
17583 // friend templates because ActOnTag never produces a ClassTemplateDecl
17584 // for a TagUseKind::Friend.
17585 Declarator TheDeclarator(DS, ParsedAttributesView::none(),
17587 TypeSourceInfo *TSI = GetTypeForDeclarator(TheDeclarator);
17588 QualType T = TSI->getType();
17589 if (TheDeclarator.isInvalidType())
17590 return nullptr;
17591
17592 // If '...' is present, the type must contain an unexpanded parameter
17593 // pack, and vice versa.
17594 bool Invalid = false;
17595 if (EllipsisLoc.isInvalid() &&
17597 return nullptr;
17598 if (EllipsisLoc.isValid() &&
17600 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
17601 << TSI->getTypeLoc().getSourceRange();
17602 Invalid = true;
17603 }
17604
17605 if (!T->isElaboratedTypeSpecifier()) {
17606 if (TempParams.size()) {
17607 // C++23 [dcl.pre]p5:
17608 // In a simple-declaration, the optional init-declarator-list can be
17609 // omitted only when declaring a class or enumeration, that is, when
17610 // the decl-specifier-seq contains either a class-specifier, an
17611 // elaborated-type-specifier with a class-key, or an enum-specifier.
17612 //
17613 // The declaration of a template-declaration or explicit-specialization
17614 // is never a member-declaration, so this must be a simple-declaration
17615 // with no init-declarator-list. Therefore, this is ill-formed.
17616 Diag(Loc, diag::err_tagless_friend_type_template) << DS.getSourceRange();
17617 return nullptr;
17618 } else if (const RecordDecl *RD = T->getAsRecordDecl()) {
17619 SmallString<16> InsertionText(" ");
17620 InsertionText += RD->getKindName();
17621
17623 ? diag::warn_cxx98_compat_unelaborated_friend_type
17624 : diag::ext_unelaborated_friend_type)
17625 << (unsigned)RD->getTagKind() << T
17627 InsertionText);
17628 } else {
17629 Diag(FriendLoc, getLangOpts().CPlusPlus11
17630 ? diag::warn_cxx98_compat_nonclass_type_friend
17631 : diag::ext_nonclass_type_friend)
17632 << T << DS.getSourceRange();
17633 }
17634 }
17635
17636 // C++98 [class.friend]p1: A friend of a class is a function
17637 // or class that is not a member of the class . . .
17638 // This is fixed in DR77, which just barely didn't make the C++03
17639 // deadline. It's also a very silly restriction that seriously
17640 // affects inner classes and which nobody else seems to implement;
17641 // thus we never diagnose it, not even in -pedantic.
17642 //
17643 // But note that we could warn about it: it's always useless to
17644 // friend one of your own members (it's not, however, worthless to
17645 // friend a member of an arbitrary specialization of your template).
17646
17647 Decl *D;
17648 if (!TempParams.empty())
17649 // TODO: Support variadic friend template decls?
17650 D = FriendTemplateDecl::Create(Context, CurContext, Loc, TempParams, TSI,
17651 FriendLoc);
17652 else
17654 TSI, FriendLoc, EllipsisLoc);
17655
17656 if (!D)
17657 return nullptr;
17658
17661
17662 if (Invalid)
17663 D->setInvalidDecl();
17664
17665 return D;
17666}
17667
17669 MultiTemplateParamsArg TemplateParams) {
17670 const DeclSpec &DS = D.getDeclSpec();
17671
17672 assert(DS.isFriendSpecified());
17674
17675 SourceLocation Loc = D.getIdentifierLoc();
17677
17678 // C++ [class.friend]p1
17679 // A friend of a class is a function or class....
17680 // Note that this sees through typedefs, which is intended.
17681 // It *doesn't* see through dependent types, which is correct
17682 // according to [temp.arg.type]p3:
17683 // If a declaration acquires a function type through a
17684 // type dependent on a template-parameter and this causes
17685 // a declaration that does not use the syntactic form of a
17686 // function declarator to have a function type, the program
17687 // is ill-formed.
17688 if (!TInfo->getType()->isFunctionType()) {
17689 Diag(Loc, diag::err_unexpected_friend);
17690
17691 // It might be worthwhile to try to recover by creating an
17692 // appropriate declaration.
17693 return nullptr;
17694 }
17695
17696 // C++ [namespace.memdef]p3
17697 // - If a friend declaration in a non-local class first declares a
17698 // class or function, the friend class or function is a member
17699 // of the innermost enclosing namespace.
17700 // - The name of the friend is not found by simple name lookup
17701 // until a matching declaration is provided in that namespace
17702 // scope (either before or after the class declaration granting
17703 // friendship).
17704 // - If a friend function is called, its name may be found by the
17705 // name lookup that considers functions from namespaces and
17706 // classes associated with the types of the function arguments.
17707 // - When looking for a prior declaration of a class or a function
17708 // declared as a friend, scopes outside the innermost enclosing
17709 // namespace scope are not considered.
17710
17711 CXXScopeSpec &SS = D.getCXXScopeSpec();
17713 assert(NameInfo.getName());
17714
17715 // Check for unexpanded parameter packs.
17719 return nullptr;
17720
17721 // The context we found the declaration in, or in which we should
17722 // create the declaration.
17723 DeclContext *DC;
17724 Scope *DCScope = S;
17725 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
17726 RedeclarationKind::ForExternalRedeclaration);
17727
17728 bool isTemplateId = D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId;
17729
17730 // There are five cases here.
17731 // - There's no scope specifier and we're in a local class. Only look
17732 // for functions declared in the immediately-enclosing block scope.
17733 // We recover from invalid scope qualifiers as if they just weren't there.
17734 FunctionDecl *FunctionContainingLocalClass = nullptr;
17735 if ((SS.isInvalid() || !SS.isSet()) &&
17736 (FunctionContainingLocalClass =
17737 cast<CXXRecordDecl>(CurContext)->isLocalClass())) {
17738 // C++11 [class.friend]p11:
17739 // If a friend declaration appears in a local class and the name
17740 // specified is an unqualified name, a prior declaration is
17741 // looked up without considering scopes that are outside the
17742 // innermost enclosing non-class scope. For a friend function
17743 // declaration, if there is no prior declaration, the program is
17744 // ill-formed.
17745
17746 // Find the innermost enclosing non-class scope. This is the block
17747 // scope containing the local class definition (or for a nested class,
17748 // the outer local class).
17749 DCScope = S->getFnParent();
17750
17751 // Look up the function name in the scope.
17753 LookupName(Previous, S, /*AllowBuiltinCreation*/false);
17754
17755 if (!Previous.empty()) {
17756 // All possible previous declarations must have the same context:
17757 // either they were declared at block scope or they are members of
17758 // one of the enclosing local classes.
17759 DC = Previous.getRepresentativeDecl()->getDeclContext();
17760 } else {
17761 // This is ill-formed, but provide the context that we would have
17762 // declared the function in, if we were permitted to, for error recovery.
17763 DC = FunctionContainingLocalClass;
17764 }
17766
17767 // - There's no scope specifier, in which case we just go to the
17768 // appropriate scope and look for a function or function template
17769 // there as appropriate.
17770 } else if (SS.isInvalid() || !SS.isSet()) {
17771 // C++11 [namespace.memdef]p3:
17772 // If the name in a friend declaration is neither qualified nor
17773 // a template-id and the declaration is a function or an
17774 // elaborated-type-specifier, the lookup to determine whether
17775 // the entity has been previously declared shall not consider
17776 // any scopes outside the innermost enclosing namespace.
17777
17778 // Find the appropriate context according to the above.
17779 DC = CurContext;
17780
17781 // Skip class contexts. If someone can cite chapter and verse
17782 // for this behavior, that would be nice --- it's what GCC and
17783 // EDG do, and it seems like a reasonable intent, but the spec
17784 // really only says that checks for unqualified existing
17785 // declarations should stop at the nearest enclosing namespace,
17786 // not that they should only consider the nearest enclosing
17787 // namespace.
17788 while (DC->isRecord())
17789 DC = DC->getParent();
17790
17791 DeclContext *LookupDC = DC->getNonTransparentContext();
17792 while (true) {
17793 LookupQualifiedName(Previous, LookupDC);
17794
17795 if (!Previous.empty()) {
17796 DC = LookupDC;
17797 break;
17798 }
17799
17800 if (isTemplateId) {
17801 if (isa<TranslationUnitDecl>(LookupDC)) break;
17802 } else {
17803 if (LookupDC->isFileContext()) break;
17804 }
17805 LookupDC = LookupDC->getParent();
17806 }
17807
17808 DCScope = getScopeForDeclContext(S, DC);
17809
17810 // - There's a non-dependent scope specifier, in which case we
17811 // compute it and do a previous lookup there for a function
17812 // or function template.
17813 } else if (!SS.getScopeRep()->isDependent()) {
17814 DC = computeDeclContext(SS);
17815 if (!DC) return nullptr;
17816
17817 if (RequireCompleteDeclContext(SS, DC)) return nullptr;
17818
17820
17821 // C++ [class.friend]p1: A friend of a class is a function or
17822 // class that is not a member of the class . . .
17823 if (DC->Equals(CurContext))
17826 diag::warn_cxx98_compat_friend_is_member :
17827 diag::err_friend_is_member);
17828
17829 // - There's a scope specifier that does not match any template
17830 // parameter lists, in which case we use some arbitrary context,
17831 // create a method or method template, and wait for instantiation.
17832 // - There's a scope specifier that does match some template
17833 // parameter lists, which we don't handle right now.
17834 } else {
17835 DC = CurContext;
17836 assert(isa<CXXRecordDecl>(DC) && "friend declaration not in class?");
17837 }
17838
17839 if (!DC->isRecord()) {
17840 int DiagArg = -1;
17841 switch (D.getName().getKind()) {
17844 DiagArg = 0;
17845 break;
17847 DiagArg = 1;
17848 break;
17850 DiagArg = 2;
17851 break;
17853 DiagArg = 3;
17854 break;
17860 break;
17861 }
17862 // This implies that it has to be an operator or function.
17863 if (DiagArg >= 0) {
17864 Diag(Loc, diag::err_introducing_special_friend) << DiagArg;
17865 return nullptr;
17866 }
17867 }
17868
17869 // FIXME: This is an egregious hack to cope with cases where the scope stack
17870 // does not contain the declaration context, i.e., in an out-of-line
17871 // definition of a class.
17872 Scope FakeDCScope(S, Scope::DeclScope, Diags);
17873 if (!DCScope) {
17874 FakeDCScope.setEntity(DC);
17875 DCScope = &FakeDCScope;
17876 }
17877
17878 bool AddToScope = true;
17879 NamedDecl *ND = ActOnFunctionDeclarator(DCScope, D, DC, TInfo, Previous,
17880 TemplateParams, AddToScope);
17881 if (!ND) return nullptr;
17882
17883 assert(ND->getLexicalDeclContext() == CurContext);
17884
17885 // If we performed typo correction, we might have added a scope specifier
17886 // and changed the decl context.
17887 DC = ND->getDeclContext();
17888
17889 // Add the function declaration to the appropriate lookup tables,
17890 // adjusting the redeclarations list as necessary. We don't
17891 // want to do this yet if the friending class is dependent.
17892 //
17893 // Also update the scope-based lookup if the target context's
17894 // lookup context is in lexical scope.
17896 DC = DC->getRedeclContext();
17898 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
17899 PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
17900 }
17901
17903 D.getIdentifierLoc(), ND,
17904 DS.getFriendSpecLoc());
17905 FrD->setAccess(AS_public);
17906 CurContext->addDecl(FrD);
17907
17908 if (ND->isInvalidDecl()) {
17909 FrD->setInvalidDecl();
17910 } else {
17911 if (DC->isRecord()) CheckFriendAccess(ND);
17912
17913 FunctionDecl *FD;
17914 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
17915 FD = FTD->getTemplatedDecl();
17916 else
17917 FD = cast<FunctionDecl>(ND);
17918
17919 // C++ [class.friend]p6:
17920 // A function may be defined in a friend declaration of a class if and
17921 // only if the class is a non-local class, and the function name is
17922 // unqualified.
17923 if (D.isFunctionDefinition()) {
17924 // Qualified friend function definition.
17925 if (SS.isNotEmpty()) {
17926 // FIXME: We should only do this if the scope specifier names the
17927 // innermost enclosing namespace; otherwise the fixit changes the
17928 // meaning of the code.
17930 Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def);
17931
17932 DB << SS.getScopeRep();
17933 if (DC->isFileContext())
17935
17936 // Friend function defined in a local class.
17937 } else if (FunctionContainingLocalClass) {
17938 Diag(NameInfo.getBeginLoc(), diag::err_friend_def_in_local_class);
17939
17940 // Per [basic.pre]p4, a template-id is not a name. Therefore, if we have
17941 // a template-id, the function name is not unqualified because these is
17942 // no name. While the wording requires some reading in-between the
17943 // lines, GCC, MSVC, and EDG all consider a friend function
17944 // specialization definitions // to be de facto explicit specialization
17945 // and diagnose them as such.
17946 } else if (isTemplateId) {
17947 Diag(NameInfo.getBeginLoc(), diag::err_friend_specialization_def);
17948 }
17949 }
17950
17951 // C++11 [dcl.fct.default]p4: If a friend declaration specifies a
17952 // default argument expression, that declaration shall be a definition
17953 // and shall be the only declaration of the function or function
17954 // template in the translation unit.
17956 // We can't look at FD->getPreviousDecl() because it may not have been set
17957 // if we're in a dependent context. If the function is known to be a
17958 // redeclaration, we will have narrowed Previous down to the right decl.
17959 if (D.isRedeclaration()) {
17960 Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
17961 Diag(Previous.getRepresentativeDecl()->getLocation(),
17962 diag::note_previous_declaration);
17963 } else if (!D.isFunctionDefinition())
17964 Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_must_be_def);
17965 }
17966
17967 // Mark templated-scope function declarations as unsupported.
17968 if (FD->getNumTemplateParameterLists() && SS.isValid()) {
17969 Diag(FD->getLocation(), diag::warn_template_qualified_friend_unsupported)
17970 << SS.getScopeRep() << SS.getRange()
17971 << cast<CXXRecordDecl>(CurContext);
17972 FrD->setUnsupportedFriend(true);
17973 }
17974 }
17975
17977
17978 return ND;
17979}
17980
17982 StringLiteral *Message) {
17984
17985 FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Dcl);
17986 if (!Fn) {
17987 Diag(DelLoc, diag::err_deleted_non_function);
17988 return;
17989 }
17990
17991 // Deleted function does not have a body.
17992 Fn->setWillHaveBody(false);
17993
17994 if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
17995 // Don't consider the implicit declaration we generate for explicit
17996 // specializations. FIXME: Do not generate these implicit declarations.
17997 if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization ||
17998 Prev->getPreviousDecl()) &&
17999 !Prev->isDefined()) {
18000 Diag(DelLoc, diag::err_deleted_decl_not_first);
18001 Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
18002 Prev->isImplicit() ? diag::note_previous_implicit_declaration
18003 : diag::note_previous_declaration);
18004 // We can't recover from this; the declaration might have already
18005 // been used.
18006 Fn->setInvalidDecl();
18007 return;
18008 }
18009
18010 // To maintain the invariant that functions are only deleted on their first
18011 // declaration, mark the implicitly-instantiated declaration of the
18012 // explicitly-specialized function as deleted instead of marking the
18013 // instantiated redeclaration.
18014 Fn = Fn->getCanonicalDecl();
18015 }
18016
18017 // dllimport/dllexport cannot be deleted.
18018 if (const InheritableAttr *DLLAttr = getDLLAttr(Fn)) {
18019 Diag(Fn->getLocation(), diag::err_attribute_dll_deleted) << DLLAttr;
18020 Fn->setInvalidDecl();
18021 }
18022
18023 // C++11 [basic.start.main]p3:
18024 // A program that defines main as deleted [...] is ill-formed.
18025 if (Fn->isMain())
18026 Diag(DelLoc, diag::err_deleted_main);
18027
18028 // C++11 [dcl.fct.def.delete]p4:
18029 // A deleted function is implicitly inline.
18030 Fn->setImplicitlyInline();
18031 Fn->setDeletedAsWritten(true, Message);
18032}
18033
18035 if (!Dcl || Dcl->isInvalidDecl())
18036 return;
18037
18038 auto *FD = dyn_cast<FunctionDecl>(Dcl);
18039 if (!FD) {
18040 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(Dcl)) {
18041 if (getDefaultedFunctionKind(FTD->getTemplatedDecl()).isComparison()) {
18042 Diag(DefaultLoc, diag::err_defaulted_comparison_template);
18043 return;
18044 }
18045 }
18046
18047 Diag(DefaultLoc, diag::err_default_special_members)
18048 << getLangOpts().CPlusPlus20;
18049 return;
18050 }
18051
18052 // Reject if this can't possibly be a defaultable function.
18054 if (!DefKind &&
18055 // A dependent function that doesn't locally look defaultable can
18056 // still instantiate to a defaultable function if it's a constructor
18057 // or assignment operator.
18058 (!FD->isDependentContext() ||
18059 (!isa<CXXConstructorDecl>(FD) &&
18060 FD->getDeclName().getCXXOverloadedOperator() != OO_Equal))) {
18061 Diag(DefaultLoc, diag::err_default_special_members)
18062 << getLangOpts().CPlusPlus20;
18063 return;
18064 }
18065
18066 // Issue compatibility warning. We already warned if the operator is
18067 // 'operator<=>' when parsing the '<=>' token.
18068 if (DefKind.isComparison() &&
18070 Diag(DefaultLoc, getLangOpts().CPlusPlus20
18071 ? diag::warn_cxx17_compat_defaulted_comparison
18072 : diag::ext_defaulted_comparison);
18073 }
18074
18075 FD->setDefaulted();
18076 FD->setExplicitlyDefaulted();
18077 FD->setDefaultLoc(DefaultLoc);
18078
18079 // Defer checking functions that are defaulted in a dependent context.
18080 if (FD->isDependentContext())
18081 return;
18082
18083 // Unset that we will have a body for this function. We might not,
18084 // if it turns out to be trivial, and we don't need this marking now
18085 // that we've marked it as defaulted.
18086 FD->setWillHaveBody(false);
18087
18088 if (DefKind.isComparison()) {
18089 // If this comparison's defaulting occurs within the definition of its
18090 // lexical class context, we have to do the checking when complete.
18091 if (auto const *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalDeclContext()))
18092 if (!RD->isCompleteDefinition())
18093 return;
18094 }
18095
18096 // If this member fn was defaulted on its first declaration, we will have
18097 // already performed the checking in CheckCompletedCXXClass. Such a
18098 // declaration doesn't trigger an implicit definition.
18099 if (isa<CXXMethodDecl>(FD)) {
18100 const FunctionDecl *Primary = FD;
18101 if (const FunctionDecl *Pattern = FD->getTemplateInstantiationPattern())
18102 // Ask the template instantiation pattern that actually had the
18103 // '= default' on it.
18104 Primary = Pattern;
18105 if (Primary->getCanonicalDecl()->isDefaulted())
18106 return;
18107 }
18108
18109 if (DefKind.isComparison()) {
18110 if (CheckExplicitlyDefaultedComparison(nullptr, FD, DefKind.asComparison()))
18111 FD->setInvalidDecl();
18112 else
18113 DefineDefaultedComparison(DefaultLoc, FD, DefKind.asComparison());
18114 } else {
18115 auto *MD = cast<CXXMethodDecl>(FD);
18116
18118 DefaultLoc))
18119 MD->setInvalidDecl();
18120 else
18121 DefineDefaultedFunction(*this, MD, DefaultLoc);
18122 }
18123}
18124
18126 for (Stmt *SubStmt : S->children()) {
18127 if (!SubStmt)
18128 continue;
18129 if (isa<ReturnStmt>(SubStmt))
18130 Self.Diag(SubStmt->getBeginLoc(),
18131 diag::err_return_in_constructor_handler);
18132 if (!isa<Expr>(SubStmt))
18133 SearchForReturnInStmt(Self, SubStmt);
18134 }
18135}
18136
18138 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
18139 CXXCatchStmt *Handler = TryBlock->getHandler(I);
18140 SearchForReturnInStmt(*this, Handler);
18141 }
18142}
18143
18145 StringLiteral *DeletedMessage) {
18146 switch (BodyKind) {
18147 case FnBodyKind::Delete:
18148 SetDeclDeleted(D, Loc, DeletedMessage);
18149 break;
18152 break;
18153 case FnBodyKind::Other:
18154 llvm_unreachable(
18155 "Parsed function body should be '= delete;' or '= default;'");
18156 }
18157}
18158
18160 const CXXMethodDecl *Old) {
18161 const auto *NewFT = New->getType()->castAs<FunctionProtoType>();
18162 const auto *OldFT = Old->getType()->castAs<FunctionProtoType>();
18163
18164 if (OldFT->hasExtParameterInfos()) {
18165 for (unsigned I = 0, E = OldFT->getNumParams(); I != E; ++I)
18166 // A parameter of the overriding method should be annotated with noescape
18167 // if the corresponding parameter of the overridden method is annotated.
18168 if (OldFT->getExtParameterInfo(I).isNoEscape() &&
18169 !NewFT->getExtParameterInfo(I).isNoEscape()) {
18170 Diag(New->getParamDecl(I)->getLocation(),
18171 diag::warn_overriding_method_missing_noescape);
18172 Diag(Old->getParamDecl(I)->getLocation(),
18173 diag::note_overridden_marked_noescape);
18174 }
18175 }
18176
18177 // SME attributes must match when overriding a function declaration.
18178 if (IsInvalidSMECallConversion(Old->getType(), New->getType())) {
18179 Diag(New->getLocation(), diag::err_conflicting_overriding_attributes)
18180 << New << New->getType() << Old->getType();
18181 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
18182 return true;
18183 }
18184
18185 // Virtual overrides must have the same code_seg.
18186 const auto *OldCSA = Old->getAttr<CodeSegAttr>();
18187 const auto *NewCSA = New->getAttr<CodeSegAttr>();
18188 if ((NewCSA || OldCSA) &&
18189 (!OldCSA || !NewCSA || NewCSA->getName() != OldCSA->getName())) {
18190 Diag(New->getLocation(), diag::err_mismatched_code_seg_override);
18191 Diag(Old->getLocation(), diag::note_previous_declaration);
18192 return true;
18193 }
18194
18195 // Virtual overrides: check for matching effects.
18197 const auto OldFX = Old->getFunctionEffects();
18198 const auto NewFXOrig = New->getFunctionEffects();
18199
18200 if (OldFX != NewFXOrig) {
18201 FunctionEffectSet NewFX(NewFXOrig);
18202 const auto Diffs = FunctionEffectDiffVector(OldFX, NewFX);
18204 for (const auto &Diff : Diffs) {
18205 switch (Diff.shouldDiagnoseMethodOverride(*Old, OldFX, *New, NewFX)) {
18207 break;
18209 Diag(New->getLocation(), diag::warn_mismatched_func_effect_override)
18210 << Diff.effectName();
18211 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
18212 << Old->getReturnTypeSourceRange();
18213 break;
18215 NewFX.insert(Diff.Old.value(), Errs);
18216 const auto *NewFT = New->getType()->castAs<FunctionProtoType>();
18217 FunctionProtoType::ExtProtoInfo EPI = NewFT->getExtProtoInfo();
18219 QualType ModQT = Context.getFunctionType(NewFT->getReturnType(),
18220 NewFT->getParamTypes(), EPI);
18221 New->setType(ModQT);
18222 break;
18223 }
18224 }
18225 }
18226 if (!Errs.empty())
18228 Old->getLocation());
18229 }
18230 }
18231
18232 CallingConv NewCC = NewFT->getCallConv(), OldCC = OldFT->getCallConv();
18233
18234 // If the calling conventions match, everything is fine
18235 if (NewCC == OldCC)
18236 return false;
18237
18238 // If the calling conventions mismatch because the new function is static,
18239 // suppress the calling convention mismatch error; the error about static
18240 // function override (err_static_overrides_virtual from
18241 // Sema::CheckFunctionDeclaration) is more clear.
18242 if (New->getStorageClass() == SC_Static)
18243 return false;
18244
18245 Diag(New->getLocation(),
18246 diag::err_conflicting_overriding_cc_attributes)
18247 << New->getDeclName() << New->getType() << Old->getType();
18248 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
18249 return true;
18250}
18251
18253 const CXXMethodDecl *Old) {
18254 // CWG2553
18255 // A virtual function shall not be an explicit object member function.
18257 return true;
18258 Diag(New->getParamDecl(0)->getBeginLoc(),
18259 diag::err_explicit_object_parameter_nonmember)
18260 << New->getSourceRange() << /*virtual*/ 1 << /*IsLambda*/ false;
18261 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
18262 New->setInvalidDecl();
18263 return false;
18264}
18265
18267 const CXXMethodDecl *Old) {
18268 QualType NewTy = New->getType()->castAs<FunctionType>()->getReturnType();
18269 QualType OldTy = Old->getType()->castAs<FunctionType>()->getReturnType();
18270
18271 if (Context.hasSameType(NewTy, OldTy) ||
18272 NewTy->isDependentType() || OldTy->isDependentType())
18273 return false;
18274
18275 // Check if the return types are covariant
18276 QualType NewClassTy, OldClassTy;
18277
18278 /// Both types must be pointers or references to classes.
18279 if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
18280 if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
18281 NewClassTy = NewPT->getPointeeType();
18282 OldClassTy = OldPT->getPointeeType();
18283 }
18284 } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
18285 if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
18286 if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
18287 NewClassTy = NewRT->getPointeeType();
18288 OldClassTy = OldRT->getPointeeType();
18289 }
18290 }
18291 }
18292
18293 // The return types aren't either both pointers or references to a class type.
18294 if (NewClassTy.isNull() || !NewClassTy->isStructureOrClassType()) {
18295 Diag(New->getLocation(),
18296 diag::err_different_return_type_for_overriding_virtual_function)
18297 << New->getDeclName() << NewTy << OldTy
18298 << New->getReturnTypeSourceRange();
18299 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
18300 << Old->getReturnTypeSourceRange();
18301
18302 return true;
18303 }
18304
18305 if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
18306 // C++14 [class.virtual]p8:
18307 // If the class type in the covariant return type of D::f differs from
18308 // that of B::f, the class type in the return type of D::f shall be
18309 // complete at the point of declaration of D::f or shall be the class
18310 // type D.
18311 if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
18312 if (!RT->isBeingDefined() &&
18313 RequireCompleteType(New->getLocation(), NewClassTy,
18314 diag::err_covariant_return_incomplete,
18315 New->getDeclName()))
18316 return true;
18317 }
18318
18319 // Check if the new class derives from the old class.
18320 if (!IsDerivedFrom(New->getLocation(), NewClassTy, OldClassTy)) {
18321 Diag(New->getLocation(), diag::err_covariant_return_not_derived)
18322 << New->getDeclName() << NewTy << OldTy
18323 << New->getReturnTypeSourceRange();
18324 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
18325 << Old->getReturnTypeSourceRange();
18326 return true;
18327 }
18328
18329 // Check if we the conversion from derived to base is valid.
18331 NewClassTy, OldClassTy,
18332 diag::err_covariant_return_inaccessible_base,
18333 diag::err_covariant_return_ambiguous_derived_to_base_conv,
18335 New->getDeclName(), nullptr)) {
18336 // FIXME: this note won't trigger for delayed access control
18337 // diagnostics, and it's impossible to get an undelayed error
18338 // here from access control during the original parse because
18339 // the ParsingDeclSpec/ParsingDeclarator are still in scope.
18340 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
18341 << Old->getReturnTypeSourceRange();
18342 return true;
18343 }
18344 }
18345
18346 // The qualifiers of the return types must be the same.
18347 if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
18348 Diag(New->getLocation(),
18349 diag::err_covariant_return_type_different_qualifications)
18350 << New->getDeclName() << NewTy << OldTy
18351 << New->getReturnTypeSourceRange();
18352 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
18353 << Old->getReturnTypeSourceRange();
18354 return true;
18355 }
18356
18357
18358 // The new class type must have the same or less qualifiers as the old type.
18359 if (!OldClassTy.isAtLeastAsQualifiedAs(NewClassTy, getASTContext())) {
18360 Diag(New->getLocation(),
18361 diag::err_covariant_return_type_class_type_not_same_or_less_qualified)
18362 << New->getDeclName() << NewTy << OldTy
18363 << New->getReturnTypeSourceRange();
18364 Diag(Old->getLocation(), diag::note_overridden_virtual_function)
18365 << Old->getReturnTypeSourceRange();
18366 return true;
18367 }
18368
18369 return false;
18370}
18371
18373 SourceLocation EndLoc = InitRange.getEnd();
18374 if (EndLoc.isValid())
18375 Method->setRangeEnd(EndLoc);
18376
18377 if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
18378 Method->setIsPureVirtual();
18379 return false;
18380 }
18381
18382 if (!Method->isInvalidDecl())
18383 Diag(Method->getLocation(), diag::err_non_virtual_pure)
18384 << Method->getDeclName() << InitRange;
18385 return true;
18386}
18387
18389 if (D->getFriendObjectKind())
18390 Diag(D->getLocation(), diag::err_pure_friend);
18391 else if (auto *M = dyn_cast<CXXMethodDecl>(D))
18392 CheckPureMethod(M, ZeroLoc);
18393 else
18394 Diag(D->getLocation(), diag::err_illegal_initializer);
18395}
18396
18397/// Invoked when we are about to parse an initializer for the declaration
18398/// 'Dcl'.
18399///
18400/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
18401/// static data member of class X, names should be looked up in the scope of
18402/// class X. If the declaration had a scope specifier, a scope will have
18403/// been created and passed in for this purpose. Otherwise, S will be null.
18405 assert(D && !D->isInvalidDecl());
18406
18407 // We will always have a nested name specifier here, but this declaration
18408 // might not be out of line if the specifier names the current namespace:
18409 // extern int n;
18410 // int ::n = 0;
18411 if (S && D->isOutOfLine())
18413
18416}
18417
18419 assert(D);
18420
18421 if (S && D->isOutOfLine())
18423
18424 if (getLangOpts().CPlusPlus23) {
18425 // An expression or conversion is 'manifestly constant-evaluated' if it is:
18426 // [...]
18427 // - the initializer of a variable that is usable in constant expressions or
18428 // has constant initialization.
18429 if (auto *VD = dyn_cast<VarDecl>(D);
18432 // An expression or conversion is in an 'immediate function context' if it
18433 // is potentially evaluated and either:
18434 // [...]
18435 // - it is a subexpression of a manifestly constant-evaluated expression
18436 // or conversion.
18437 ExprEvalContexts.back().InImmediateFunctionContext = true;
18438 }
18439 }
18440
18441 // Unless the initializer is in an immediate function context (as determined
18442 // above), this will evaluate all contained immediate function calls as
18443 // constant expressions. If the initializer IS an immediate function context,
18444 // the initializer has been determined to be a constant expression, and all
18445 // such evaluations will be elided (i.e., as if we "knew the whole time" that
18446 // it was a constant expression).
18448}
18449
18451 // C++ 6.4p2:
18452 // The declarator shall not specify a function or an array.
18453 // The type-specifier-seq shall not contain typedef and shall not declare a
18454 // new class or enumeration.
18455 assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
18456 "Parser allowed 'typedef' as storage class of condition decl.");
18457
18458 Decl *Dcl = ActOnDeclarator(S, D);
18459 if (!Dcl)
18460 return true;
18461
18462 if (isa<FunctionDecl>(Dcl)) { // The declarator shall not specify a function.
18463 Diag(Dcl->getLocation(), diag::err_invalid_use_of_function_type)
18464 << D.getSourceRange();
18465 return true;
18466 }
18467
18468 if (auto *VD = dyn_cast<VarDecl>(Dcl))
18469 VD->setCXXCondDecl();
18470
18471 return Dcl;
18472}
18473
18475 if (!ExternalSource)
18476 return;
18477
18479 ExternalSource->ReadUsedVTables(VTables);
18481 for (unsigned I = 0, N = VTables.size(); I != N; ++I) {
18482 llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
18483 = VTablesUsed.find(VTables[I].Record);
18484 // Even if a definition wasn't required before, it may be required now.
18485 if (Pos != VTablesUsed.end()) {
18486 if (!Pos->second && VTables[I].DefinitionRequired)
18487 Pos->second = true;
18488 continue;
18489 }
18490
18491 VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
18492 NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location));
18493 }
18494
18495 VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end());
18496}
18497
18499 bool DefinitionRequired) {
18500 // Ignore any vtable uses in unevaluated operands or for classes that do
18501 // not have a vtable.
18502 if (!Class->isDynamicClass() || Class->isDependentContext() ||
18504 return;
18505 // Do not mark as used if compiling for the device outside of the target
18506 // region.
18507 if (TUKind != TU_Prefix && LangOpts.OpenMP && LangOpts.OpenMPIsTargetDevice &&
18508 !OpenMP().isInOpenMPDeclareTargetContext() &&
18509 !OpenMP().isInOpenMPTargetExecutionDirective()) {
18510 if (!DefinitionRequired)
18512 return;
18513 }
18514
18515 // Try to insert this class into the map.
18517 Class = Class->getCanonicalDecl();
18518 std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator, bool>
18519 Pos = VTablesUsed.insert(std::make_pair(Class, DefinitionRequired));
18520 if (!Pos.second) {
18521 // If we already had an entry, check to see if we are promoting this vtable
18522 // to require a definition. If so, we need to reappend to the VTableUses
18523 // list, since we may have already processed the first entry.
18524 if (DefinitionRequired && !Pos.first->second) {
18525 Pos.first->second = true;
18526 } else {
18527 // Otherwise, we can early exit.
18528 return;
18529 }
18530 } else {
18531 // The Microsoft ABI requires that we perform the destructor body
18532 // checks (i.e. operator delete() lookup) when the vtable is marked used, as
18533 // the deleting destructor is emitted with the vtable, not with the
18534 // destructor definition as in the Itanium ABI.
18536 CXXDestructorDecl *DD = Class->getDestructor();
18537 if (DD && DD->isVirtual() && !DD->isDeleted()) {
18538 if (Class->hasUserDeclaredDestructor() && !DD->isDefined()) {
18539 // If this is an out-of-line declaration, marking it referenced will
18540 // not do anything. Manually call CheckDestructor to look up operator
18541 // delete().
18542 ContextRAII SavedContext(*this, DD);
18543 CheckDestructor(DD);
18544 } else {
18545 MarkFunctionReferenced(Loc, Class->getDestructor());
18546 }
18547 }
18548 }
18549 }
18550
18551 // Local classes need to have their virtual members marked
18552 // immediately. For all other classes, we mark their virtual members
18553 // at the end of the translation unit.
18554 if (Class->isLocalClass())
18555 MarkVirtualMembersReferenced(Loc, Class->getDefinition());
18556 else
18557 VTableUses.push_back(std::make_pair(Class, Loc));
18558}
18559
18562 if (VTableUses.empty())
18563 return false;
18564
18565 // Note: The VTableUses vector could grow as a result of marking
18566 // the members of a class as "used", so we check the size each
18567 // time through the loop and prefer indices (which are stable) to
18568 // iterators (which are not).
18569 bool DefinedAnything = false;
18570 for (unsigned I = 0; I != VTableUses.size(); ++I) {
18571 CXXRecordDecl *Class = VTableUses[I].first->getDefinition();
18572 if (!Class)
18573 continue;
18575 Class->getTemplateSpecializationKind();
18576
18577 SourceLocation Loc = VTableUses[I].second;
18578
18579 bool DefineVTable = true;
18580
18581 const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(Class);
18582 // V-tables for non-template classes with an owning module are always
18583 // uniquely emitted in that module.
18584 if (Class->isInCurrentModuleUnit()) {
18585 DefineVTable = true;
18586 } else if (KeyFunction && !KeyFunction->hasBody()) {
18587 // If this class has a key function, but that key function is
18588 // defined in another translation unit, we don't need to emit the
18589 // vtable even though we're using it.
18590 // The key function is in another translation unit.
18591 DefineVTable = false;
18593 KeyFunction->getTemplateSpecializationKind();
18596 "Instantiations don't have key functions");
18597 (void)TSK;
18598 } else if (!KeyFunction) {
18599 // If we have a class with no key function that is the subject
18600 // of an explicit instantiation declaration, suppress the
18601 // vtable; it will live with the explicit instantiation
18602 // definition.
18603 bool IsExplicitInstantiationDeclaration =
18605 for (auto *R : Class->redecls()) {
18607 = cast<CXXRecordDecl>(R)->getTemplateSpecializationKind();
18609 IsExplicitInstantiationDeclaration = true;
18610 else if (TSK == TSK_ExplicitInstantiationDefinition) {
18611 IsExplicitInstantiationDeclaration = false;
18612 break;
18613 }
18614 }
18615
18616 if (IsExplicitInstantiationDeclaration)
18617 DefineVTable = false;
18618 }
18619
18620 // The exception specifications for all virtual members may be needed even
18621 // if we are not providing an authoritative form of the vtable in this TU.
18622 // We may choose to emit it available_externally anyway.
18623 if (!DefineVTable) {
18625 continue;
18626 }
18627
18628 // Mark all of the virtual members of this class as referenced, so
18629 // that we can build a vtable. Then, tell the AST consumer that a
18630 // vtable for this class is required.
18631 DefinedAnything = true;
18633 CXXRecordDecl *Canonical = Class->getCanonicalDecl();
18634 if (VTablesUsed[Canonical] && !Class->shouldEmitInExternalSource())
18636
18637 // Warn if we're emitting a weak vtable. The vtable will be weak if there is
18638 // no key function or the key function is inlined. Don't warn in C++ ABIs
18639 // that lack key functions, since the user won't be able to make one.
18641 Class->isExternallyVisible() && ClassTSK != TSK_ImplicitInstantiation &&
18643 const FunctionDecl *KeyFunctionDef = nullptr;
18644 if (!KeyFunction || (KeyFunction->hasBody(KeyFunctionDef) &&
18645 KeyFunctionDef->isInlined()))
18646 Diag(Class->getLocation(), diag::warn_weak_vtable) << Class;
18647 }
18648 }
18649 VTableUses.clear();
18650
18651 return DefinedAnything;
18652}
18653
18655 const CXXRecordDecl *RD) {
18656 for (const auto *I : RD->methods())
18657 if (I->isVirtual() && !I->isPureVirtual())
18658 ResolveExceptionSpec(Loc, I->getType()->castAs<FunctionProtoType>());
18659}
18660
18662 const CXXRecordDecl *RD,
18663 bool ConstexprOnly) {
18664 // Mark all functions which will appear in RD's vtable as used.
18665 CXXFinalOverriderMap FinalOverriders;
18666 RD->getFinalOverriders(FinalOverriders);
18667 for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
18668 E = FinalOverriders.end();
18669 I != E; ++I) {
18670 for (OverridingMethods::const_iterator OI = I->second.begin(),
18671 OE = I->second.end();
18672 OI != OE; ++OI) {
18673 assert(OI->second.size() > 0 && "no final overrider");
18674 CXXMethodDecl *Overrider = OI->second.front().Method;
18675
18676 // C++ [basic.def.odr]p2:
18677 // [...] A virtual member function is used if it is not pure. [...]
18678 if (!Overrider->isPureVirtual() &&
18679 (!ConstexprOnly || Overrider->isConstexpr()))
18680 MarkFunctionReferenced(Loc, Overrider);
18681 }
18682 }
18683
18684 // Only classes that have virtual bases need a VTT.
18685 if (RD->getNumVBases() == 0)
18686 return;
18687
18688 for (const auto &I : RD->bases()) {
18689 const auto *Base =
18690 cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
18691 if (Base->getNumVBases() == 0)
18692 continue;
18694 }
18695}
18696
18697static
18702 Sema &S) {
18703 if (Ctor->isInvalidDecl())
18704 return;
18705
18707
18708 // Target may not be determinable yet, for instance if this is a dependent
18709 // call in an uninstantiated template.
18710 if (Target) {
18711 const FunctionDecl *FNTarget = nullptr;
18712 (void)Target->hasBody(FNTarget);
18713 Target = const_cast<CXXConstructorDecl*>(
18714 cast_or_null<CXXConstructorDecl>(FNTarget));
18715 }
18716
18717 CXXConstructorDecl *Canonical = Ctor->getCanonicalDecl(),
18718 // Avoid dereferencing a null pointer here.
18719 *TCanonical = Target? Target->getCanonicalDecl() : nullptr;
18720
18721 if (!Current.insert(Canonical).second)
18722 return;
18723
18724 // We know that beyond here, we aren't chaining into a cycle.
18725 if (!Target || !Target->isDelegatingConstructor() ||
18726 Target->isInvalidDecl() || Valid.count(TCanonical)) {
18727 Valid.insert(Current.begin(), Current.end());
18728 Current.clear();
18729 // We've hit a cycle.
18730 } else if (TCanonical == Canonical || Invalid.count(TCanonical) ||
18731 Current.count(TCanonical)) {
18732 // If we haven't diagnosed this cycle yet, do so now.
18733 if (!Invalid.count(TCanonical)) {
18734 S.Diag((*Ctor->init_begin())->getSourceLocation(),
18735 diag::warn_delegating_ctor_cycle)
18736 << Ctor;
18737
18738 // Don't add a note for a function delegating directly to itself.
18739 if (TCanonical != Canonical)
18740 S.Diag(Target->getLocation(), diag::note_it_delegates_to);
18741
18743 while (C->getCanonicalDecl() != Canonical) {
18744 const FunctionDecl *FNTarget = nullptr;
18745 (void)C->getTargetConstructor()->hasBody(FNTarget);
18746 assert(FNTarget && "Ctor cycle through bodiless function");
18747
18748 C = const_cast<CXXConstructorDecl*>(
18749 cast<CXXConstructorDecl>(FNTarget));
18750 S.Diag(C->getLocation(), diag::note_which_delegates_to);
18751 }
18752 }
18753
18754 Invalid.insert(Current.begin(), Current.end());
18755 Current.clear();
18756 } else {
18757 DelegatingCycleHelper(Target, Valid, Invalid, Current, S);
18758 }
18759}
18760
18761
18764
18765 for (DelegatingCtorDeclsType::iterator
18768 I != E; ++I)
18769 DelegatingCycleHelper(*I, Valid, Invalid, Current, *this);
18770
18771 for (auto CI = Invalid.begin(), CE = Invalid.end(); CI != CE; ++CI)
18772 (*CI)->setInvalidDecl();
18773}
18774
18775namespace {
18776 /// AST visitor that finds references to the 'this' expression.
18777class FindCXXThisExpr : public DynamicRecursiveASTVisitor {
18778 Sema &S;
18779
18780public:
18781 explicit FindCXXThisExpr(Sema &S) : S(S) {}
18782
18783 bool VisitCXXThisExpr(CXXThisExpr *E) override {
18784 S.Diag(E->getLocation(), diag::err_this_static_member_func)
18785 << E->isImplicit();
18786 return false;
18787 }
18788};
18789}
18790
18792 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
18793 if (!TSInfo)
18794 return false;
18795
18796 TypeLoc TL = TSInfo->getTypeLoc();
18798 if (!ProtoTL)
18799 return false;
18800
18801 // C++11 [expr.prim.general]p3:
18802 // [The expression this] shall not appear before the optional
18803 // cv-qualifier-seq and it shall not appear within the declaration of a
18804 // static member function (although its type and value category are defined
18805 // within a static member function as they are within a non-static member
18806 // function). [ Note: this is because declaration matching does not occur
18807 // until the complete declarator is known. - end note ]
18808 const FunctionProtoType *Proto = ProtoTL.getTypePtr();
18809 FindCXXThisExpr Finder(*this);
18810
18811 // If the return type came after the cv-qualifier-seq, check it now.
18812 if (Proto->hasTrailingReturn() &&
18813 !Finder.TraverseTypeLoc(ProtoTL.getReturnLoc()))
18814 return true;
18815
18816 // Check the exception specification.
18818 return true;
18819
18820 // Check the trailing requires clause
18821 if (Expr *E = Method->getTrailingRequiresClause())
18822 if (!Finder.TraverseStmt(E))
18823 return true;
18824
18826}
18827
18829 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
18830 if (!TSInfo)
18831 return false;
18832
18833 TypeLoc TL = TSInfo->getTypeLoc();
18835 if (!ProtoTL)
18836 return false;
18837
18838 const FunctionProtoType *Proto = ProtoTL.getTypePtr();
18839 FindCXXThisExpr Finder(*this);
18840
18841 switch (Proto->getExceptionSpecType()) {
18842 case EST_Unparsed:
18843 case EST_Uninstantiated:
18844 case EST_Unevaluated:
18845 case EST_BasicNoexcept:
18846 case EST_NoThrow:
18847 case EST_DynamicNone:
18848 case EST_MSAny:
18849 case EST_None:
18850 break;
18851
18853 case EST_NoexceptFalse:
18854 case EST_NoexceptTrue:
18855 if (!Finder.TraverseStmt(Proto->getNoexceptExpr()))
18856 return true;
18857 [[fallthrough]];
18858
18859 case EST_Dynamic:
18860 for (const auto &E : Proto->exceptions()) {
18861 if (!Finder.TraverseType(E))
18862 return true;
18863 }
18864 break;
18865 }
18866
18867 return false;
18868}
18869
18871 FindCXXThisExpr Finder(*this);
18872
18873 // Check attributes.
18874 for (const auto *A : Method->attrs()) {
18875 // FIXME: This should be emitted by tblgen.
18876 Expr *Arg = nullptr;
18877 ArrayRef<Expr *> Args;
18878 if (const auto *G = dyn_cast<GuardedByAttr>(A))
18879 Arg = G->getArg();
18880 else if (const auto *G = dyn_cast<PtGuardedByAttr>(A))
18881 Arg = G->getArg();
18882 else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
18883 Args = llvm::ArrayRef(AA->args_begin(), AA->args_size());
18884 else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
18885 Args = llvm::ArrayRef(AB->args_begin(), AB->args_size());
18886 else if (const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
18887 Arg = ETLF->getSuccessValue();
18888 Args = llvm::ArrayRef(ETLF->args_begin(), ETLF->args_size());
18889 } else if (const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
18890 Arg = STLF->getSuccessValue();
18891 Args = llvm::ArrayRef(STLF->args_begin(), STLF->args_size());
18892 } else if (const auto *LR = dyn_cast<LockReturnedAttr>(A))
18893 Arg = LR->getArg();
18894 else if (const auto *LE = dyn_cast<LocksExcludedAttr>(A))
18895 Args = llvm::ArrayRef(LE->args_begin(), LE->args_size());
18896 else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
18897 Args = llvm::ArrayRef(RC->args_begin(), RC->args_size());
18898 else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
18899 Args = llvm::ArrayRef(AC->args_begin(), AC->args_size());
18900 else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
18901 Args = llvm::ArrayRef(AC->args_begin(), AC->args_size());
18902 else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
18903 Args = llvm::ArrayRef(RC->args_begin(), RC->args_size());
18904
18905 if (Arg && !Finder.TraverseStmt(Arg))
18906 return true;
18907
18908 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
18909 if (!Finder.TraverseStmt(Args[I]))
18910 return true;
18911 }
18912 }
18913
18914 return false;
18915}
18916
18918 bool IsTopLevel, ExceptionSpecificationType EST,
18919 ArrayRef<ParsedType> DynamicExceptions,
18920 ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr,
18921 SmallVectorImpl<QualType> &Exceptions,
18923 Exceptions.clear();
18924 ESI.Type = EST;
18925 if (EST == EST_Dynamic) {
18926 Exceptions.reserve(DynamicExceptions.size());
18927 for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
18928 // FIXME: Preserve type source info.
18929 QualType ET = GetTypeFromParser(DynamicExceptions[ei]);
18930
18931 if (IsTopLevel) {
18933 collectUnexpandedParameterPacks(ET, Unexpanded);
18934 if (!Unexpanded.empty()) {
18936 DynamicExceptionRanges[ei].getBegin(), UPPC_ExceptionType,
18937 Unexpanded);
18938 continue;
18939 }
18940 }
18941
18942 // Check that the type is valid for an exception spec, and
18943 // drop it if not.
18944 if (!CheckSpecifiedExceptionType(ET, DynamicExceptionRanges[ei]))
18945 Exceptions.push_back(ET);
18946 }
18947 ESI.Exceptions = Exceptions;
18948 return;
18949 }
18950
18951 if (isComputedNoexcept(EST)) {
18952 assert((NoexceptExpr->isTypeDependent() ||
18953 NoexceptExpr->getType()->getCanonicalTypeUnqualified() ==
18954 Context.BoolTy) &&
18955 "Parser should have made sure that the expression is boolean");
18956 if (IsTopLevel && DiagnoseUnexpandedParameterPack(NoexceptExpr)) {
18957 ESI.Type = EST_BasicNoexcept;
18958 return;
18959 }
18960
18961 ESI.NoexceptExpr = NoexceptExpr;
18962 return;
18963 }
18964}
18965
18967 Decl *D, ExceptionSpecificationType EST, SourceRange SpecificationRange,
18968 ArrayRef<ParsedType> DynamicExceptions,
18969 ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr) {
18970 if (!D)
18971 return;
18972
18973 // Dig out the function we're referring to.
18974 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D))
18975 D = FTD->getTemplatedDecl();
18976
18977 FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
18978 if (!FD)
18979 return;
18980
18981 // Check the exception specification.
18984 checkExceptionSpecification(/*IsTopLevel=*/true, EST, DynamicExceptions,
18985 DynamicExceptionRanges, NoexceptExpr, Exceptions,
18986 ESI);
18987
18988 // Update the exception specification on the function type.
18989 Context.adjustExceptionSpec(FD, ESI, /*AsWritten=*/true);
18990
18991 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
18992 if (MD->isStatic())
18994
18995 if (MD->isVirtual()) {
18996 // Check overrides, which we previously had to delay.
18997 for (const CXXMethodDecl *O : MD->overridden_methods())
18999 }
19000 }
19001}
19002
19003/// HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
19004///
19006 SourceLocation DeclStart, Declarator &D,
19007 Expr *BitWidth,
19008 InClassInitStyle InitStyle,
19009 AccessSpecifier AS,
19010 const ParsedAttr &MSPropertyAttr) {
19011 const IdentifierInfo *II = D.getIdentifier();
19012 if (!II) {
19013 Diag(DeclStart, diag::err_anonymous_property);
19014 return nullptr;
19015 }
19016 SourceLocation Loc = D.getIdentifierLoc();
19017
19019 QualType T = TInfo->getType();
19020 if (getLangOpts().CPlusPlus) {
19022
19023 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
19025 D.setInvalidType();
19026 T = Context.IntTy;
19028 }
19029 }
19030
19031 DiagnoseFunctionSpecifiers(D.getDeclSpec());
19032
19033 if (D.getDeclSpec().isInlineSpecified())
19034 Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
19035 << getLangOpts().CPlusPlus17;
19036 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
19037 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
19038 diag::err_invalid_thread)
19040
19041 // Check to see if this name was declared as a member previously
19042 NamedDecl *PrevDecl = nullptr;
19044 RedeclarationKind::ForVisibleRedeclaration);
19045 LookupName(Previous, S);
19046 switch (Previous.getResultKind()) {
19049 PrevDecl = Previous.getAsSingle<NamedDecl>();
19050 break;
19051
19053 PrevDecl = Previous.getRepresentativeDecl();
19054 break;
19055
19059 break;
19060 }
19061
19062 if (PrevDecl && PrevDecl->isTemplateParameter()) {
19063 // Maybe we will complain about the shadowed template parameter.
19064 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
19065 // Just pretend that we didn't see the previous declaration.
19066 PrevDecl = nullptr;
19067 }
19068
19069 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
19070 PrevDecl = nullptr;
19071
19072 SourceLocation TSSL = D.getBeginLoc();
19073 MSPropertyDecl *NewPD =
19074 MSPropertyDecl::Create(Context, Record, Loc, II, T, TInfo, TSSL,
19075 MSPropertyAttr.getPropertyDataGetter(),
19076 MSPropertyAttr.getPropertyDataSetter());
19078 NewPD->setAccess(AS);
19079
19080 if (NewPD->isInvalidDecl())
19081 Record->setInvalidDecl();
19082
19083 if (D.getDeclSpec().isModulePrivateSpecified())
19084 NewPD->setModulePrivate();
19085
19086 if (NewPD->isInvalidDecl() && PrevDecl) {
19087 // Don't introduce NewFD into scope; there's already something
19088 // with the same name in the same scope.
19089 } else if (II) {
19090 PushOnScopeChains(NewPD, S);
19091 } else
19092 Record->addDecl(NewPD);
19093
19094 return NewPD;
19095}
19096
19098 Declarator &Declarator, unsigned TemplateParameterDepth) {
19099 auto &Info = InventedParameterInfos.emplace_back();
19100 TemplateParameterList *ExplicitParams = nullptr;
19101 ArrayRef<TemplateParameterList *> ExplicitLists =
19103 if (!ExplicitLists.empty()) {
19104 bool IsMemberSpecialization, IsInvalid;
19107 Declarator.getCXXScopeSpec(), /*TemplateId=*/nullptr,
19108 ExplicitLists, /*IsFriend=*/false, IsMemberSpecialization, IsInvalid,
19109 /*SuppressDiagnostic=*/true);
19110 }
19111 // C++23 [dcl.fct]p23:
19112 // An abbreviated function template can have a template-head. The invented
19113 // template-parameters are appended to the template-parameter-list after
19114 // the explicitly declared template-parameters.
19115 //
19116 // A template-head must have one or more template-parameters (read:
19117 // 'template<>' is *not* a template-head). Only append the invented
19118 // template parameters if we matched the nested-name-specifier to a non-empty
19119 // TemplateParameterList.
19120 if (ExplicitParams && !ExplicitParams->empty()) {
19121 Info.AutoTemplateParameterDepth = ExplicitParams->getDepth();
19122 llvm::append_range(Info.TemplateParams, *ExplicitParams);
19123 Info.NumExplicitTemplateParams = ExplicitParams->size();
19124 } else {
19125 Info.AutoTemplateParameterDepth = TemplateParameterDepth;
19126 Info.NumExplicitTemplateParams = 0;
19127 }
19128}
19129
19131 auto &FSI = InventedParameterInfos.back();
19132 if (FSI.TemplateParams.size() > FSI.NumExplicitTemplateParams) {
19133 if (FSI.NumExplicitTemplateParams != 0) {
19134 TemplateParameterList *ExplicitParams =
19138 Context, ExplicitParams->getTemplateLoc(),
19139 ExplicitParams->getLAngleLoc(), FSI.TemplateParams,
19140 ExplicitParams->getRAngleLoc(),
19141 ExplicitParams->getRequiresClause()));
19142 } else {
19145 Context, SourceLocation(), SourceLocation(), FSI.TemplateParams,
19146 SourceLocation(), /*RequiresClause=*/nullptr));
19147 }
19148 }
19149 InventedParameterInfos.pop_back();
19150}
Defines the clang::ASTContext interface.
#define V(N, I)
Definition: ASTContext.h:3453
NodeId Parent
Definition: ASTDiff.cpp:191
DynTypedNode Node
StringRef P
const Decl * D
enum clang::sema::@1724::IndirectLocalPathEntry::EntryKind Kind
IndirectLocalPath & Path
Expr * E
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
static bool CheckLiteralType(EvalInfo &Info, const Expr *E, const LValue *This=nullptr)
Check that this core constant expression is of literal type, and if not, produce an appropriate diagn...
int Category
Definition: Format.cpp:3054
LangStandard::Kind Std
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Target Target
Definition: MachO.h:51
llvm::MachO::Record Record
Definition: MachO.h:31
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
llvm::SmallVector< std::pair< const MemRegion *, SVal >, 4 > Bindings
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file declares semantic analysis for CUDA constructs.
static void checkMoveAssignmentForRepeatedMove(Sema &S, CXXRecordDecl *Class, SourceLocation CurrentLocation)
Check if we're implicitly defining a move assignment operator for a class with virtual bases.
static void checkMethodTypeQualifiers(Sema &S, Declarator &D, unsigned DiagID)
static void DelegatingCycleHelper(CXXConstructorDecl *Ctor, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Valid, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Invalid, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Current, Sema &S)
static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *Body, Sema::CheckConstexprKind Kind)
Check the body for the given constexpr function declaration only contains the permitted types of stat...
llvm::SmallPtrSet< QualType, 4 > IndirectBaseSet
Use small set to collect indirect bases.
static void checkCUDADeviceBuiltinSurfaceClassTemplate(Sema &S, CXXRecordDecl *Class)
static bool checkVectorDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const VectorType *VT)
static void SearchForReturnInStmt(Sema &Self, Stmt *S)
static void extendRight(SourceRange &R, SourceRange After)
static void DiagnoseNamespaceInlineMismatch(Sema &S, SourceLocation KeywordLoc, SourceLocation Loc, IdentifierInfo *II, bool *IsInline, NamespaceDecl *PrevNS)
Diagnose a mismatch in 'inline' qualifiers when a namespace is reopened.
static bool RefersToRValueRef(Expr *MemRef)
static CanQualType RemoveAddressSpaceFromPtr(Sema &SemaRef, const PointerType *PtrTy)
static bool isVirtualDirectBase(CXXRecordDecl *Derived, CXXRecordDecl *Base)
Determine whether a direct base class is a virtual base class.
static IsTupleLike isTupleLike(Sema &S, SourceLocation Loc, QualType T, llvm::APSInt &Size)
#define CheckPolymorphic(Type)
static void WriteCharValueForDiagnostic(uint32_t Value, const BuiltinType *BTy, unsigned TyWidth, SmallVectorImpl< char > &Str)
Convert character's value, interpreted as a code unit, to a string.
static bool checkTrivialSubobjectCall(Sema &S, SourceLocation SubobjLoc, QualType SubType, bool ConstRHS, CXXSpecialMemberKind CSM, TrivialSubobjectKind Kind, Sema::TrivialABIHandling TAH, bool Diagnose)
Check whether the special member selected for a given type would be trivial.
static void CheckAbstractClassUsage(AbstractUsageInfo &Info, FunctionDecl *FD)
Check for invalid uses of an abstract type in a function declaration.
static unsigned getRecordDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for record diagnostic message.
static Expr * CastForMoving(Sema &SemaRef, Expr *E)
static void extendLeft(SourceRange &R, SourceRange Before)
static bool checkTrivialClassMembers(Sema &S, CXXRecordDecl *RD, CXXSpecialMemberKind CSM, bool ConstArg, Sema::TrivialABIHandling TAH, bool Diagnose)
Check whether the members of a class type allow a special member to be trivial.
static bool specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, unsigned Quals, bool ConstRHS, CXXConstructorDecl *InheritedCtor=nullptr, Sema::InheritedConstructorInfo *Inherited=nullptr)
Is the special member function which would be selected to perform the specified operation on the spec...
static void diagnoseInvalidDeclaratorChunks(Sema &S, Declarator &D, unsigned Kind)
static bool canPassInRegisters(Sema &S, CXXRecordDecl *D, TargetInfo::CallingConvKind CCK)
Determine whether a type is permitted to be passed or returned in registers, per C++ [class....
static void lookupOperatorsForDefaultedComparison(Sema &Self, Scope *S, UnresolvedSetImpl &Operators, OverloadedOperatorKind Op)
Perform the unqualified lookups that might be needed to form a defaulted comparison function for the ...
static void WriteCharTypePrefix(BuiltinType::Kind BTK, llvm::raw_ostream &OS)
static bool findTrivialSpecialMember(Sema &S, CXXRecordDecl *RD, CXXSpecialMemberKind CSM, unsigned Quals, bool ConstRHS, Sema::TrivialABIHandling TAH, CXXMethodDecl **Selected)
Perform lookup for a special member of the specified kind, and determine whether it is trivial.
static void diagnoseDeprecatedCopyOperation(Sema &S, CXXMethodDecl *CopyOp)
Diagnose an implicit copy operation for a class which is odr-used, but which is deprecated because th...
static void AddMostOverridenMethods(const CXXMethodDecl *MD, llvm::SmallPtrSetImpl< const CXXMethodDecl * > &Methods)
Add the most overridden methods from MD to Methods.
static bool CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl, CanQualType ExpectedResultType, CanQualType ExpectedFirstParamType, unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag)
static DeclAccessPair findDecomposableBaseClass(Sema &S, SourceLocation Loc, const CXXRecordDecl *RD, CXXCastPath &BasePath)
Find the base class to decompose in a built-in decomposition of a class type.
static const void * GetKeyForBase(ASTContext &Context, QualType BaseType)
static Sema::ImplicitExceptionSpecification ComputeDefaultedComparisonExceptionSpec(Sema &S, SourceLocation Loc, FunctionDecl *FD, Sema::DefaultedComparisonKind DCK)
static StmtResult buildSingleCopyAssignRecursively(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &To, const ExprBuilder &From, bool CopyingBaseSubobject, bool Copying, unsigned Depth=0)
Builds a statement that copies/moves the given entity from From to To.
static void checkCUDADeviceBuiltinTextureClassTemplate(Sema &S, CXXRecordDecl *Class)
static void AddInitializerToDiag(const Sema::SemaDiagnosticBuilder &Diag, const CXXCtorInitializer *Previous, const CXXCtorInitializer *Current)
static bool BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, CXXBaseSpecifier *BaseSpec, bool IsInheritedVirtualBase, CXXCtorInitializer *&CXXBaseInit)
static bool checkTupleLikeDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, VarDecl *Src, QualType DecompType, const llvm::APSInt &TupleSize)
static void NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set, const QualType &Type)
Recursively add the bases of Type. Don't add Type itself.
static bool CheckConstexprMissingReturn(Sema &SemaRef, const FunctionDecl *Dcl)
static bool CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S, SmallVectorImpl< SourceLocation > &ReturnStmts, SourceLocation &Cxx1yLoc, SourceLocation &Cxx2aLoc, SourceLocation &Cxx2bLoc, Sema::CheckConstexprKind Kind)
Check the provided statement is allowed in a constexpr function definition.
static bool functionDeclHasDefaultArgument(const FunctionDecl *FD)
static bool CheckConstexprParameterTypes(Sema &SemaRef, const FunctionDecl *FD, Sema::CheckConstexprKind Kind)
Check whether a function's parameter types are all literal types.
static bool IsUsingDirectiveInToplevelContext(DeclContext *CurContext)
Determine whether a using statement is in a context where it will be apply in all contexts.
static CXXConstructorDecl * findUserDeclaredCtor(CXXRecordDecl *RD)
static bool checkMemberDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const CXXRecordDecl *OrigRD)
static void checkForMultipleExportedDefaultConstructors(Sema &S, CXXRecordDecl *Class)
static bool checkSimpleDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType, llvm::function_ref< ExprResult(SourceLocation, Expr *, unsigned)> GetInit)
static TemplateArgumentLoc getTrivialTypeTemplateArgument(Sema &S, SourceLocation Loc, QualType T)
static void findImplicitlyDeclaredEqualityComparisons(ASTContext &Ctx, CXXRecordDecl *RD, llvm::SmallVectorImpl< FunctionDecl * > &Spaceships)
Find the equality comparison functions that should be implicitly declared in a given class definition...
static void PopulateKeysForFields(FieldDecl *Field, SmallVectorImpl< const void * > &IdealInits)
ImplicitInitializerKind
ImplicitInitializerKind - How an implicit base or member initializer should initialize its base or me...
@ IIK_Default
@ IIK_Move
@ IIK_Inherit
@ IIK_Copy
static bool ConvertAPValueToString(const APValue &V, QualType T, SmallVectorImpl< char > &Str, ASTContext &Context)
Convert \V to a string we can present to the user in a diagnostic \T is the type of the expression th...
static NamespaceDecl * getNamespaceDecl(NamedDecl *D)
getNamespaceDecl - Returns the namespace a decl represents.
static bool checkArrayDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const ConstantArrayType *CAT)
static void ReferenceDllExportedMembers(Sema &S, CXXRecordDecl *Class)
static bool UsefulToPrintExpr(const Expr *E)
Some Expression types are not useful to print notes about, e.g.
static bool FindBaseInitializer(Sema &SemaRef, CXXRecordDecl *ClassDecl, QualType BaseType, const CXXBaseSpecifier *&DirectBaseSpec, const CXXBaseSpecifier *&VirtualBaseSpec)
Find the direct and/or virtual base specifiers that correspond to the given base type,...
static bool checkLiteralOperatorTemplateParameterList(Sema &SemaRef, FunctionTemplateDecl *TpDecl)
static ClassTemplateDecl * LookupStdInitializerList(Sema &S, SourceLocation Loc)
static bool CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl)
static bool ReportOverrides(Sema &S, unsigned DiagID, const CXXMethodDecl *MD, llvm::function_ref< bool(const CXXMethodDecl *)> Report)
Report an error regarding overriding, along with any relevant overridden methods.
static bool CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl)
static const void * GetKeyForMember(ASTContext &Context, CXXCtorInitializer *Member)
static std::string printTemplateArgs(const PrintingPolicy &PrintingPolicy, TemplateArgumentListInfo &Args, const TemplateParameterList *Params)
static bool CheckConstexprReturnType(Sema &SemaRef, const FunctionDecl *FD, Sema::CheckConstexprKind Kind)
Check whether a function's return type is a literal type.
static void DiagnoseBaseOrMemInitializerOrder(Sema &SemaRef, const CXXConstructorDecl *Constructor, ArrayRef< CXXCtorInitializer * > Inits)
static Sema::ImplicitExceptionSpecification computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, FunctionDecl *FD)
static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T)
Determine whether the given type is an incomplete or zero-lenfgth array type.
TrivialSubobjectKind
The kind of subobject we are checking for triviality.
@ TSK_CompleteObject
The object is actually the complete object.
@ TSK_Field
The subobject is a non-static data member.
@ TSK_BaseClass
The subobject is a base class.
static bool hasOneRealArgument(MultiExprArg Args)
Determine whether the given list arguments contains exactly one "real" (non-default) argument.
static StmtResult buildMemcpyForAssignmentOp(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &ToB, const ExprBuilder &FromB)
When generating a defaulted copy or move assignment operator, if a field should be copied with __buil...
static void DefineDefaultedFunction(Sema &S, FunctionDecl *FD, SourceLocation DefaultLoc)
static bool BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, FieldDecl *Field, IndirectFieldDecl *Indirect, CXXCtorInitializer *&CXXMemberInit)
static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info, FieldDecl *Field, IndirectFieldDecl *Indirect=nullptr)
static CXXBaseSpecifier * findDirectBaseWithType(CXXRecordDecl *Derived, QualType DesiredBase, bool &AnyDependentBases)
Find the base specifier for a base class with the given type.
static Sema::SpecialMemberOverloadResult lookupCallFromSpecialMember(Sema &S, CXXRecordDecl *Class, CXXSpecialMemberKind CSM, unsigned FieldQuals, bool ConstRHS)
Look up the special member function that would be called by a special member function for a subobject...
static bool defaultedSpecialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, bool ConstArg, CXXConstructorDecl *InheritedCtor=nullptr, Sema::InheritedConstructorInfo *Inherited=nullptr)
Determine whether the specified special member function would be constexpr if it were implicitly defi...
static bool lookupStdTypeTraitMember(Sema &S, LookupResult &TraitMemberLookup, SourceLocation Loc, StringRef Trait, TemplateArgumentListInfo &Args, unsigned DiagID)
static void DiagnoseInvisibleNamespace(const TypoCorrection &Corrected, Sema &S)
static StmtResult buildSingleCopyAssign(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &To, const ExprBuilder &From, bool CopyingBaseSubobject, bool Copying)
static FunctionProtoType::ExtProtoInfo getImplicitMethodEPI(Sema &S, CXXMethodDecl *MD)
static QualType getTupleLikeElementType(Sema &S, SourceLocation Loc, unsigned I, QualType T)
static Sema::ImplicitExceptionSpecification ComputeDefaultedSpecialMemberExceptionSpec(Sema &S, SourceLocation Loc, CXXMethodDecl *MD, CXXSpecialMemberKind CSM, Sema::InheritedConstructorInfo *ICI)
static bool checkComplexDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const ComplexType *CT)
static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident)
static bool InitializationHasSideEffects(const FieldDecl &FD)
static bool CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef, const FunctionDecl *FnDecl)
static bool checkArrayLikeDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType)
static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl, DeclStmt *DS, SourceLocation &Cxx1yLoc, Sema::CheckConstexprKind Kind)
Check the given declaration statement is legal within a constexpr function body.
static bool IsEquivalentForUsingDecl(ASTContext &Context, NamedDecl *D1, NamedDecl *D2)
Determine whether a using declaration considers the given declarations as "equivalent",...
static TemplateArgumentLoc getTrivialIntegralTemplateArgument(Sema &S, SourceLocation Loc, QualType T, uint64_t I)
static bool CheckConstexprDestructorSubobjects(Sema &SemaRef, const CXXDestructorDecl *DD, Sema::CheckConstexprKind Kind)
Determine whether a destructor cannot be constexpr due to.
static bool CheckConstexprCtorInitializer(Sema &SemaRef, const FunctionDecl *Dcl, FieldDecl *Field, llvm::SmallSet< Decl *, 16 > &Inits, bool &Diagnosed, Sema::CheckConstexprKind Kind)
Check that the given field is initialized within a constexpr constructor.
static bool isProvablyNotDerivedFrom(Sema &SemaRef, CXXRecordDecl *Record, const BaseSet &Bases)
Determines if the given class is provably not derived from all of the prospective base classes.
SourceRange Range
Definition: SemaObjC.cpp:758
SourceLocation Loc
Definition: SemaObjC.cpp:759
bool Indirect
Definition: SemaObjC.cpp:760
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
static bool isInvalid(LocType Loc, bool *Invalid)
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
Defines the clang::TypeLoc interface and its subclasses.
Allows QualTypes to be sorted and hence used in maps and sets.
const NestedNameSpecifier * Specifier
StateNode * Previous
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
__device__ int
std::pair< CXXConstructorDecl *, bool > findConstructorForBase(CXXRecordDecl *Base, CXXConstructorDecl *Ctor) const
Find the constructor to use for inherited construction of a base class, and whether that base class c...
InheritedConstructorInfo(Sema &S, SourceLocation UseLoc, ConstructorUsingShadowDecl *Shadow)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
virtual void HandleVTable(CXXRecordDecl *RD)
Callback involved at the end of a translation unit to notify the consumer that a vtable for the given...
Definition: ASTConsumer.h:124
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
Definition: ASTConsumer.cpp:18
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:188
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1141
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2915
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
unsigned getIntWidth(QualType T) const
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:684
QualType getRecordType(const RecordDecl *Decl) const
unsigned NumImplicitCopyAssignmentOperatorsDeclared
The number of implicitly-declared copy assignment operators for which declarations were built.
Definition: ASTContext.h:3403
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2716
unsigned NumImplicitDestructorsDeclared
The number of implicitly-declared destructors for which declarations were built.
Definition: ASTContext.h:3417
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2732
CanQualType LongDoubleTy
Definition: ASTContext.h:1172
CanQualType Char16Ty
Definition: ASTContext.h:1167
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn't on...
CanQualType VoidPtrTy
Definition: ASTContext.h:1187
void Deallocate(void *Ptr) const
Definition: ASTContext.h:760
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
CanQualType DependentTy
Definition: ASTContext.h:1188
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1703
CanQualType WideCharTy
Definition: ASTContext.h:1164
IdentifierTable & Idents
Definition: ASTContext.h:680
const LangOptions & getLangOpts() const
Definition: ASTContext.h:834
QualType getConstType(QualType T) const
Return the uniqued reference to the type for a const qualified type.
Definition: ASTContext.h:1392
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
ComparisonCategories CompCategories
Types and expressions required to build C++2a three-way comparisons using operator<=>,...
Definition: ASTContext.h:2413
QualType AutoDeductTy
Definition: ASTContext.h:1223
CanQualType BoolTy
Definition: ASTContext.h:1161
unsigned NumImplicitDefaultConstructorsDeclared
The number of implicitly-declared default constructors for which declarations were built.
Definition: ASTContext.h:3382
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
bool hasAnyFunctionEffects() const
Definition: ASTContext.h:3014
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
CanQualType CharTy
Definition: ASTContext.h:1162
unsigned NumImplicitMoveConstructorsDeclared
The number of implicitly-declared move constructors for which declarations were built.
Definition: ASTContext.h:3396
unsigned NumImplicitCopyConstructorsDeclared
The number of implicitly-declared copy constructors for which declarations were built.
Definition: ASTContext.h:3389
CanQualType IntTy
Definition: ASTContext.h:1169
unsigned NumImplicitDestructors
The number of implicitly-declared destructors.
Definition: ASTContext.h:3413
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:2289
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated,...
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:733
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2763
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2482
CanQualType BuiltinFnTy
Definition: ASTContext.h:1190
unsigned NumImplicitDefaultConstructors
The number of implicitly-declared default constructors.
Definition: ASTContext.h:3378
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
unsigned NumImplicitMoveAssignmentOperatorsDeclared
The number of implicitly-declared move assignment operators for which declarations were built.
Definition: ASTContext.h:3410
CanQualType VoidTy
Definition: ASTContext.h:1160
unsigned NumImplicitMoveConstructors
The number of implicitly-declared move constructors.
Definition: ASTContext.h:3392
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
QualType getExceptionObjectType(QualType T) const
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1171
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1681
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const
Make an APSInt of the appropriate width and signedness for the given Value and integer Type.
Definition: ASTContext.h:3175
CanQualType Char32Ty
Definition: ASTContext.h:1168
bool hasSameTemplateName(const TemplateName &X, const TemplateName &Y, bool IgnoreDeduced=false) const
Determine whether the given template names refer to the same template.
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:799
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
unsigned NumImplicitCopyConstructors
The number of implicitly-declared copy constructors.
Definition: ASTContext.h:3385
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
Definition: ASTContext.h:1274
unsigned NumImplicitCopyAssignmentOperators
The number of implicitly-declared copy assignment operators.
Definition: ASTContext.h:3399
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
NestedNameSpecifier * getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
CanQualType Char8Ty
Definition: ASTContext.h:1166
unsigned NumImplicitMoveAssignmentOperators
The number of implicitly-declared move assignment operators.
Definition: ASTContext.h:3406
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
Represents an access specifier followed by colon ':'.
Definition: DeclCXX.h:86
static AccessSpecDecl * Create(ASTContext &C, AccessSpecifier AS, DeclContext *DC, SourceLocation ASLoc, SourceLocation ColonLoc)
Definition: DeclCXX.h:117
bool isUnset() const
Definition: Ownership.h:167
PtrTy get() const
Definition: Ownership.h:170
bool isInvalid() const
Definition: Ownership.h:166
bool isUsable() const
Definition: Ownership.h:168
Wrapper for source info for arrays.
Definition: TypeLoc.h:1592
TypeLoc getElementLoc() const
Definition: TypeLoc.h:1622
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:3577
QualType getElementType() const
Definition: Type.h:3589
Attr - This represents one attribute.
Definition: Attr.h:43
attr::Kind getKind() const
Definition: Attr.h:89
bool isInherited() const
Definition: Attr.h:98
Attr * clone(ASTContext &C) const
SourceLocation getLocation() const
Definition: Attr.h:96
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Definition: Type.h:6561
AutoTypeKeyword getKeyword() const
Definition: Type.h:6592
Represents a C++ declaration that introduces decls from somewhere else.
Definition: DeclCXX.h:3440
unsigned shadow_size() const
Return the number of shadowed declarations associated with this using declaration.
Definition: DeclCXX.h:3518
void addShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:3272
shadow_iterator shadow_begin() const
Definition: DeclCXX.h:3510
void removeShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:3281
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:4324
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3909
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
Definition: Expr.cpp:4902
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
Definition: Expr.cpp:2158
A binding in a decomposition declaration.
Definition: DeclCXX.h:4130
static BindingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id)
Definition: DeclCXX.cpp:3465
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:6414
Wrapper for source info for block pointers.
Definition: TypeLoc.h:1345
This class is used for builtin types like 'int'.
Definition: Type.h:3034
Kind getKind() const
Definition: Type.h:3082
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
AccessSpecifier Access
The access along this inheritance path.
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
std::list< CXXBasePath >::iterator paths_iterator
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclCXX.h:194
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:203
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:249
SourceRange getSourceRange() const LLVM_READONLY
Retrieves the source range that contains the entire base specifier.
Definition: DeclCXX.h:193
AccessSpecifier getAccessSpecifier() const
Returns the access specifier for this base specifier.
Definition: DeclCXX.h:230
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:720
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:28
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1546
static CXXConstructExpr * Create(const ASTContext &Ctx, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, CXXConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Create a C++ construction expression.
Definition: ExprCXX.cpp:1159
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1609
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2553
CXXConstructorDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2795
bool isMoveConstructor(unsigned &TypeQuals) const
Determine whether this constructor is a move constructor (C++11 [class.copy]p3), which can be used to...
Definition: DeclCXX.cpp:2898
ExplicitSpecifier getExplicitSpecifier()
Definition: DeclCXX.h:2624
init_iterator init_begin()
Retrieve an iterator to the first initializer.
Definition: DeclCXX.h:2649
CXXConstructorDecl * getTargetConstructor() const
When this constructor delegates to another, retrieve the target.
Definition: DeclCXX.cpp:2875
bool isCopyConstructor(unsigned &TypeQuals) const
Whether this constructor is a copy constructor (C++ [class.copy]p2, which can be used to copy the cla...
Definition: DeclCXX.cpp:2893
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2884
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Definition: DeclCXX.h:2790
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited=InheritedConstructor(), Expr *TrailingRequiresClause=nullptr)
Definition: DeclCXX.cpp:2854
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2885
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2925
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2318
bool isWritten() const
Determine whether this initializer is explicitly written in the source code.
Definition: DeclCXX.h:2490
SourceRange getSourceRange() const LLVM_READONLY
Determine the source range covering the entire initializer.
Definition: DeclCXX.cpp:2803
SourceLocation getSourceLocation() const
Determine the source location of the initializer.
Definition: DeclCXX.cpp:2790
FieldDecl * getAnyMember() const
Definition: DeclCXX.h:2464
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1375
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2817
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause=nullptr)
Definition: DeclCXX.cpp:2988
A mapping from each virtual member function to its set of final overriders.
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1737
Represents a call to a member function that may be written either with member call syntax (e....
Definition: ExprCXX.h:176
CXXMethodDecl * getMethodDecl() const
Retrieve the declaration of the called method.
Definition: ExprCXX.cpp:722
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2078
bool isExplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An explicit object member function is a non-static member function with an explic...
Definition: DeclCXX.cpp:2588
bool isImplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An implicit object member function is a non-static member function without an exp...
Definition: DeclCXX.cpp:2595
bool isVirtual() const
Definition: DeclCXX.h:2133
unsigned getNumExplicitParams() const
Definition: DeclCXX.h:2232
bool isVolatile() const
Definition: DeclCXX.h:2131
CXXMethodDecl * getMostRecentDecl()
Definition: DeclCXX.h:2181
overridden_method_range overridden_methods() const
Definition: DeclCXX.cpp:2665
unsigned size_overridden_methods() const
Definition: DeclCXX.cpp:2659
QualType getFunctionObjectParameterReferenceType() const
Return the type of the object pointed by this.
Definition: DeclCXX.cpp:2707
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this method.
Definition: DeclCXX.h:2254
method_iterator begin_overridden_methods() const
Definition: DeclCXX.cpp:2649
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Definition: DeclCXX.h:2204
bool isInstance() const
Definition: DeclCXX.h:2105
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:2621
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Definition: DeclCXX.cpp:2407
QualType getFunctionObjectParameterType() const
Definition: DeclCXX.h:2228
bool isStatic() const
Definition: DeclCXX.cpp:2319
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Definition: DeclCXX.cpp:2599
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2174
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:765
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:81
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
bool hasConstexprDefaultConstructor() const
Determine whether this class has a constexpr default constructor.
Definition: DeclCXX.h:1282
friend_range friends() const
Definition: DeclFriend.h:261
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class....
Definition: DeclCXX.h:1353
bool isTriviallyCopyable() const
Determine whether this class is considered trivially copyable per (C++11 [class]p6).
Definition: DeclCXX.cpp:619
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
Definition: DeclCXX.h:1252
bool isGenericLambda() const
Determine whether this class describes a generic lambda function object (i.e.
Definition: DeclCXX.cpp:1641
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1378
bool hasUserDeclaredDestructor() const
Determine whether this class has a user-declared destructor.
Definition: DeclCXX.h:1013
bool implicitCopyConstructorHasConstParam() const
Determine whether an implicit copy constructor for this type would have a parameter with a const-qual...
Definition: DeclCXX.h:832
bool hasInheritedAssignment() const
Determine whether this class has a using-declaration that names a base class assignment operator.
Definition: DeclCXX.h:1432
bool allowConstDefaultInit() const
Determine whether declaring a const variable with this type is ok per core issue 253.
Definition: DeclCXX.h:1403
bool hasTrivialDestructorForCall() const
Definition: DeclCXX.h:1382
bool defaultedMoveConstructorIsDeleted() const
true if a defaulted move constructor for this class would be deleted.
Definition: DeclCXX.h:718
bool isLiteral() const
Determine whether this class is a literal type.
Definition: DeclCXX.cpp:1467
bool hasUserDeclaredMoveAssignment() const
Determine whether this class has had a move assignment declared by the user.
Definition: DeclCXX.h:973
bool defaultedDestructorIsConstexpr() const
Determine whether a defaulted default constructor for this class would be constexpr.
Definition: DeclCXX.h:1368
base_class_range bases()
Definition: DeclCXX.h:620
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation.
Definition: DeclCXX.cpp:612
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1030
bool hasTrivialMoveConstructor() const
Determine whether this class has a trivial move constructor (C++11 [class.copy]p12)
Definition: DeclCXX.h:1313
bool needsImplicitDefaultConstructor() const
Determine if we need to declare a default constructor for this class.
Definition: DeclCXX.h:778
bool needsImplicitMoveConstructor() const
Determine whether this class should get an implicit move constructor or if any existing special membe...
Definition: DeclCXX.h:904
bool hasUserDeclaredCopyAssignment() const
Determine whether this class has a user-declared copy assignment operator.
Definition: DeclCXX.h:922
method_range methods() const
Definition: DeclCXX.h:662
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:565
bool needsOverloadResolutionForCopyAssignment() const
Determine whether we need to eagerly declare a defaulted copy assignment operator for this class.
Definition: DeclCXX.h:943
static AccessSpecifier MergeAccess(AccessSpecifier PathAccess, AccessSpecifier DeclAccess)
Calculates the access of a decl that is reached along a path.
Definition: DeclCXX.h:1738
bool defaultedDefaultConstructorIsConstexpr() const
Determine whether a defaulted default constructor for this class would be constexpr.
Definition: DeclCXX.h:1275
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class....
Definition: DeclCXX.h:1290
void setImplicitMoveAssignmentIsDeleted()
Set that we attempted to declare an implicit move assignment operator, but overload resolution failed...
Definition: DeclCXX.h:985
bool hasConstexprDestructor() const
Determine whether this class has a constexpr destructor.
Definition: DeclCXX.cpp:607
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
Definition: DeclCXX.h:1226
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:614
bool defaultedCopyConstructorIsDeleted() const
true if a defaulted copy constructor for this class would be deleted.
Definition: DeclCXX.h:709
bool hasTrivialCopyConstructorForCall() const
Definition: DeclCXX.h:1294
bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths, bool LookupInDependent=false) const
Look for entities within the base classes of this C++ class, transitively searching all base class su...
bool lambdaIsDefaultConstructibleAndAssignable() const
Determine whether this lambda should have an implicit default constructor and copy and move assignmen...
Definition: DeclCXX.cpp:738
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:2011
bool hasTrivialCopyAssignment() const
Determine whether this class has a trivial copy assignment operator (C++ [class.copy]p11,...
Definition: DeclCXX.h:1340
base_class_range vbases()
Definition: DeclCXX.h:637
base_class_iterator vbases_begin()
Definition: DeclCXX.h:644
ctor_range ctors() const
Definition: DeclCXX.h:682
void setImplicitMoveConstructorIsDeleted()
Set that we attempted to declare an implicit move constructor, but overload resolution failed so we d...
Definition: DeclCXX.h:879
bool isAbstract() const
Determine whether this class has a pure virtual function.
Definition: DeclCXX.h:1233
bool hasVariantMembers() const
Determine whether this class has any variant members.
Definition: DeclCXX.h:1248
void setImplicitCopyConstructorIsDeleted()
Set that we attempted to declare an implicit copy constructor, but overload resolution failed so we d...
Definition: DeclCXX.h:870
bool isDynamicClass() const
Definition: DeclCXX.h:586
bool hasInClassInitializer() const
Whether this class has any in-class initializers for non-static data members (including those in anon...
Definition: DeclCXX.h:1160
bool needsImplicitCopyConstructor() const
Determine whether this class needs an implicit copy constructor to be lazily declared.
Definition: DeclCXX.h:811
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
Definition: DeclCXX.h:1414
bool hasDirectFields() const
Determine whether this class has direct non-static data members.
Definition: DeclCXX.h:1212
bool hasUserDeclaredCopyConstructor() const
Determine whether this class has a user-declared copy constructor.
Definition: DeclCXX.h:805
bool hasDefinition() const
Definition: DeclCXX.h:572
void setImplicitCopyAssignmentIsDeleted()
Set that we attempted to declare an implicit copy assignment operator, but overload resolution failed...
Definition: DeclCXX.h:928
bool needsImplicitDestructor() const
Determine whether this class needs an implicit destructor to be lazily declared.
Definition: DeclCXX.h:1019
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:2003
void getFinalOverriders(CXXFinalOverriderMap &FinaOverriders) const
Retrieve the final overriders for each virtual member function in the class hierarchy where this clas...
bool needsOverloadResolutionForMoveConstructor() const
Determine whether we need to eagerly declare a defaulted move constructor for this class.
Definition: DeclCXX.h:914
bool needsOverloadResolutionForMoveAssignment() const
Determine whether we need to eagerly declare a move assignment operator for this class.
Definition: DeclCXX.h:1006
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:2081
bool needsOverloadResolutionForDestructor() const
Determine whether we need to eagerly declare a destructor for this class.
Definition: DeclCXX.h:1025
bool hasInheritedConstructor() const
Determine whether this class has a using-declaration that names a user-declared base class constructo...
Definition: DeclCXX.h:1426
CXXMethodDecl * getLambdaStaticInvoker() const
Retrieve the lambda static invoker, the address of which is returned by the conversion operator,...
Definition: DeclCXX.cpp:1712
bool needsOverloadResolutionForCopyConstructor() const
Determine whether we need to eagerly declare a defaulted copy constructor for this class.
Definition: DeclCXX.h:817
bool hasUserDeclaredMoveConstructor() const
Determine whether this class has had a move constructor declared by the user.
Definition: DeclCXX.h:858
bool needsImplicitMoveAssignment() const
Determine whether this class should get an implicit move assignment operator or if any existing speci...
Definition: DeclCXX.h:995
bool isInterfaceLike() const
Definition: DeclCXX.cpp:2110
bool needsImplicitCopyAssignment() const
Determine whether this class needs an implicit copy assignment operator to be lazily declared.
Definition: DeclCXX.h:937
bool hasTrivialMoveConstructorForCall() const
Definition: DeclCXX.h:1318
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
Definition: DeclCXX.cpp:1700
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:524
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:635
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
bool implicitCopyAssignmentHasConstParam() const
Determine whether an implicit copy assignment operator for this type would have a parameter with a co...
Definition: DeclCXX.h:958
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:74
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:210
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:215
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition: DeclSpec.cpp:123
SourceRange getRange() const
Definition: DeclSpec.h:80
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:84
bool isSet() const
Deprecated.
Definition: DeclSpec.h:228
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
Definition: DeclSpec.cpp:149
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:95
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:213
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:208
Represents the this expression in C++.
Definition: ExprCXX.h:1152
SourceLocation getBeginLoc() const
Definition: ExprCXX.h:1172
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:69
CXXCatchStmt * getHandler(unsigned i)
Definition: StmtCXX.h:108
unsigned getNumHandlers() const
Definition: StmtCXX.h:107
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2874
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed.
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
Definition: CanonicalType.h:84
static CharSourceRange getTokenRange(SourceRange R)
SourceLocation getBegin() const
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:185
Declaration of a class template.
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
Represents a class template specialization, which refers to a class template with a given set of temp...
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
const ComparisonCategoryInfo * lookupInfoForType(QualType Ty) const
const ComparisonCategoryInfo & getInfoForType(QualType Ty) const
Return the comparison category information as specified by getCategoryForType(Ty).
const ComparisonCategoryInfo * lookupInfo(ComparisonCategoryType Kind) const
Return the cached comparison category information for the specified 'Kind'.
static StringRef getCategoryString(ComparisonCategoryType Kind)
static StringRef getResultString(ComparisonCategoryResult Kind)
static std::vector< ComparisonCategoryResult > getPossibleResultsForType(ComparisonCategoryType Type)
Return the list of results which are valid for the specified comparison category type.
const CXXRecordDecl * Record
The declaration for the comparison category type from the standard library.
const ValueInfo * getValueInfo(ComparisonCategoryResult ValueKind) const
ComparisonCategoryType Kind
The Kind of the comparison category type.
Complex values, per C99 6.2.5p11.
Definition: Type.h:3145
QualType getElementType() const
Definition: Type.h:3155
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1628
body_range body()
Definition: Stmt.h:1691
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt * > Stmts, FPOptionsOverride FPFeatures, SourceLocation LB, SourceLocation RB)
Definition: Stmt.cpp:390
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:4262
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:195
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:3615
llvm::APInt getSize() const
Return the constant array size as an APInt.
Definition: Type.h:3671
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Definition: ASTConcept.h:35
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3621
const CXXRecordDecl * getParent() const
Returns the parent of this using shadow declaration, which is the class in which this is declared.
Definition: DeclCXX.h:3685
static ConstructorUsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, UsingDecl *Using, NamedDecl *Target, bool IsVirtual)
Definition: DeclCXX.cpp:3254
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
NamedDecl * getDecl() const
AccessSpecifier getAccess() const
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1368
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
Definition: DeclBase.h:2380
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1435
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:2100
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
Definition: DeclBase.h:2229
bool isFileContext() const
Definition: DeclBase.h:2171
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:2053
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1334
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1854
bool isTranslationUnit() const
Definition: DeclBase.h:2176
bool isRecord() const
Definition: DeclBase.h:2180
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1998
void removeDecl(Decl *D)
Removes a declaration from this context.
Definition: DeclBase.cpp:1687
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1768
decl_iterator decls_end() const
Definition: DeclBase.h:2362
bool isStdNamespace() const
Definition: DeclBase.cpp:1318
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:2360
bool isFunctionOrMethod() const
Definition: DeclBase.h:2152
const LinkageSpecDecl * getExternCContext() const
Retrieve the nearest enclosing C linkage specification context.
Definition: DeclBase.cpp:1389
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1404
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
Definition: DeclBase.cpp:1742
Decl::Kind getDeclKind() const
Definition: DeclBase.h:2093
DeclContext * getNonTransparentContext()
Definition: DeclBase.cpp:1415
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1624
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1265
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.cpp:550
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
Definition: Expr.cpp:487
ValueDecl * getDecl()
Definition: Expr.h:1333
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
Definition: Expr.h:1457
Captures information about "declaration specifiers".
Definition: DeclSpec.h:247
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
Definition: DeclSpec.h:691
Expr * getPackIndexingExpr() const
Definition: DeclSpec.h:560
TST getTypeSpecType() const
Definition: DeclSpec.h:537
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:510
SCS getStorageClassSpec() const
Definition: DeclSpec.h:501
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:575
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:574
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:616
SourceLocation getExplicitSpecLoc() const
Definition: DeclSpec.h:654
SourceLocation getFriendSpecLoc() const
Definition: DeclSpec.h:827
ParsedType getRepAsType() const
Definition: DeclSpec.h:547
bool isFriendSpecifiedFirst() const
Definition: DeclSpec.h:825
SourceLocation getEllipsisLoc() const
Definition: DeclSpec.h:623
SourceLocation getConstSpecLoc() const
Definition: DeclSpec.h:617
SourceRange getExplicitSpecRange() const
Definition: DeclSpec.h:655
Expr * getRepAsExpr() const
Definition: DeclSpec.h:555
SourceLocation getRestrictSpecLoc() const
Definition: DeclSpec.h:618
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
Definition: DeclSpec.cpp:558
SourceLocation getAtomicSpecLoc() const
Definition: DeclSpec.h:620
SourceLocation getConstexprSpecLoc() const
Definition: DeclSpec.h:836
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:582
void forEachQualifier(llvm::function_ref< void(TQ, StringRef, SourceLocation)> Handle)
This method calls the passed in handler on each qual being set.
Definition: DeclSpec.cpp:453
SourceLocation getUnalignedSpecLoc() const
Definition: DeclSpec.h:621
SourceLocation getVolatileSpecLoc() const
Definition: DeclSpec.h:619
FriendSpecified isFriendSpecified() const
Definition: DeclSpec.h:821
bool hasExplicitSpecifier() const
Definition: DeclSpec.h:651
bool hasConstexprSpecifier() const
Definition: DeclSpec.h:837
static const TST TST_auto
Definition: DeclSpec.h:318
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Definition: Stmt.h:1519
decl_range decls()
Definition: Stmt.h:1567
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.h:1545
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Definition: DeclBase.h:1050
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclBase.h:438
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
Definition: DeclBase.h:1215
T * getAttr() const
Definition: DeclBase.h:576
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:520
void addAttr(Attr *A)
Definition: DeclBase.cpp:1010
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:596
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Definition: Decl.cpp:99
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:151
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:89
void clearIdentifierNamespace()
Clears the namespace of this declaration.
Definition: DeclBase.h:1203
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
Definition: DeclBase.cpp:564
@ FOK_Undeclared
A friend of a previously-undeclared entity.
Definition: DeclBase.h:1208
@ FOK_None
Not a friend object.
Definition: DeclBase.h:1206
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:246
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Definition: DeclBase.h:2780
DeclContext * getNonTransparentDeclContext()
Return the non transparent context.
Definition: DeclBase.cpp:1217
bool isInvalidDecl() const
Definition: DeclBase.h:591
unsigned getIdentifierNamespace() const
Definition: DeclBase.h:878
bool isLocalExternDecl() const
Determine whether this is a block-scope declaration with linkage.
Definition: DeclBase.h:1158
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:505
SourceLocation getLocation() const
Definition: DeclBase.h:442
@ IDNS_Ordinary
Ordinary names.
Definition: DeclBase.h:144
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack.
Definition: DeclBase.cpp:229
void setLocalOwningModule(Module *M)
Definition: DeclBase.h:822
void setImplicit(bool I=true)
Definition: DeclBase.h:597
void setReferenced(bool R=true)
Definition: DeclBase.h:626
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
Definition: DeclBase.cpp:549
DeclContext * getDeclContext()
Definition: DeclBase.h:451
attr_range attrs() const
Definition: DeclBase.h:538
AccessSpecifier getAccess() const
Definition: DeclBase.h:510
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclBase.h:434
void dropAttr()
Definition: DeclBase.h:559
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
Definition: DeclBase.h:907
bool hasAttr() const
Definition: DeclBase.h:580
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:967
@ VisibleWhenImported
This declaration has an owning module, and is visible when that module is imported.
Kind getKind() const
Definition: DeclBase.h:445
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
Definition: DeclBase.h:870
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:430
DeclarationName getCXXDestructorName(CanQualType Ty)
Returns the name of a C++ destructor for the given Type.
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
Get the name of the overloadable C++ operator corresponding to Op.
DeclarationName getCXXConstructorName(CanQualType Ty)
Returns the name of a C++ constructor for the given Type.
The name of a declaration.
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
std::string getAsString() const
Retrieve the human-readable string for this name.
const IdentifierInfo * getCXXLiteralIdentifier() const
If this name is the name of a literal operator, retrieve the identifier associated with it.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
NameKind getNameKind() const
Determine what kind of name this is.
bool isIdentifier() const
Predicate functions for querying what type of name this is.
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:735
SourceLocation getTypeSpecStartLoc() const
Definition: Decl.cpp:1977
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:786
unsigned getNumTemplateParameterLists() const
Definition: Decl.h:822
void setTypeSourceInfo(TypeSourceInfo *TI)
Definition: Decl.h:769
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
Definition: Decl.h:810
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:764
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1903
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:2339
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:2086
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:2065
ArrayRef< TemplateParameterList * > getTemplateParameterLists() const
The template parameter lists that preceded the declarator.
Definition: DeclSpec.h:2652
void setInventedTemplateParameterList(TemplateParameterList *Invented)
Sets the template parameter list generated from the explicit template parameters along with any inven...
Definition: DeclSpec.h:2659
bool isInvalidType() const
Definition: DeclSpec.h:2717
A decomposition declaration.
Definition: DeclCXX.h:4189
ArrayRef< BindingDecl * > bindings() const
Definition: DeclCXX.h:4221
A parsed C++17 decomposition declarator of the form '[' identifier-list ']'.
Definition: DeclSpec.h:1792
SourceRange getSourceRange() const
Definition: DeclSpec.h:1839
SourceLocation getLSquareLoc() const
Definition: DeclSpec.h:1837
Represents a C++17 deduced template specialization type.
Definition: Type.h:6609
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2454
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2434
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2443
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine a...
Definition: Diagnostic.h:1512
bool isLastDiagnosticIgnored() const
Determine whether the previous diagnostic was ignored.
Definition: Diagnostic.h:793
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:939
Recursive AST visitor that supports extension via dynamic dispatch.
virtual bool TraverseConstructorInitializer(CXXCtorInitializer *Init)
Recursively visit a constructor initializer.
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2354
TypeLoc getNamedTypeLoc() const
Definition: TypeLoc.h:2392
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2368
static EmptyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
Definition: Decl.cpp:5655
RAII object that enters a new expression evaluation context.
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:3291
Represents an enum.
Definition: Decl.h:3861
enumerator_range enumerators() const
Definition: Decl.h:3994
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
Definition: Type.h:6103
EvaluatedExprVisitor - This class visits 'Expr *'s.
Store information needed for an explicit specifier.
Definition: DeclCXX.h:1912
const Expr * getExpr() const
Definition: DeclCXX.h:1921
void setExpr(Expr *E)
Definition: DeclCXX.h:1946
void setKind(ExplicitSpecKind Kind)
Definition: DeclCXX.h:1945
This represents one expression.
Definition: Expr.h:110
static bool isPotentialConstantExpr(const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExpr - Return true if this function's definition might be usable in a constant exp...
bool isValueDependent() const
Determines whether the value of this expression depends on.
Definition: Expr.h:175
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Definition: Expr.h:192
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:3097
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:3085
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
Definition: Expr.h:245
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:3093
bool isPRValue() const
Definition: Expr.h:278
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
Definition: Expr.h:277
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const
Determine whether the result of this expression is a temporary object of the given class type.
Definition: Expr.cpp:3231
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:276
QualType getType() const
Definition: Expr.h:142
Represents difference between two FPOptions values.
Definition: LangOptions.h:978
Represents a member of a struct/union/class.
Definition: Decl.h:3033
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
Definition: Decl.cpp:4580
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
Definition: Decl.h:3208
bool isAnonymousStructOrUnion() const
Determines whether this field is a representative for an anonymous struct or union.
Definition: Decl.cpp:4570
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
Definition: Decl.h:3202
void setInClassInitializer(Expr *NewInit)
Set the C++11 in-class initializer for this member.
Definition: Decl.cpp:4590
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
Definition: Decl.h:3118
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
Definition: Decl.h:3264
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
Definition: Decl.h:3275
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:75
static FixItHint CreateInsertionFromRange(SourceLocation InsertionLoc, CharSourceRange FromRange, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code from FromRange at a specific location.
Definition: Diagnostic.h:114
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Definition: Diagnostic.h:138
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:127
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:101
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
Definition: DeclFriend.h:54
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, SourceLocation EllipsisLoc={}, ArrayRef< TemplateParameterList * > FriendTypeTPLists={})
Definition: DeclFriend.cpp:34
void setUnsupportedFriend(bool Unsupported)
Definition: DeclFriend.h:189
static FriendTemplateDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc, MutableArrayRef< TemplateParameterList * > Params, FriendUnion Friend, SourceLocation FriendLoc)
static DefaultedOrDeletedFunctionInfo * Create(ASTContext &Context, ArrayRef< DeclAccessPair > Lookups, StringLiteral *DeletedMessage=nullptr)
Definition: Decl.cpp:3103
Represents a function declaration or definition.
Definition: Decl.h:1935
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2672
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:3243
ExceptionSpecificationType getExceptionSpecType() const
Gets the ExceptionSpecificationType as declared.
Definition: Decl.h:2744
bool isTrivialForCall() const
Definition: Decl.h:2308
ConstexprSpecKind getConstexprKind() const
Definition: Decl.h:2404
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
Definition: Decl.cpp:3723
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Definition: Decl.cpp:4064
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:4052
void setIsPureVirtual(bool P=true)
Definition: Decl.cpp:3262
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
Definition: Decl.h:2249
bool isImmediateFunction() const
Definition: Decl.cpp:3295
void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info)
Definition: Decl.cpp:3124
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
Definition: Decl.cpp:3883
bool isDestroyingOperatorDelete() const
Determine whether this is a destroying operator delete.
Definition: Decl.cpp:3480
bool hasCXXExplicitFunctionObjectParameter() const
Definition: Decl.cpp:3741
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2796
SourceLocation getDefaultLoc() const
Definition: Decl.h:2326
QualType getReturnType() const
Definition: Decl.h:2720
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2649
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
Definition: Decl.h:2317
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2305
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:4172
MutableArrayRef< ParmVarDecl * >::iterator param_iterator
Definition: Decl.h:2657
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3623
FunctionTypeLoc getFunctionTypeLoc() const
Find the source location information for how the type of this function was written.
Definition: Decl.cpp:3877
param_iterator param_begin()
Definition: Decl.h:2661
const ParmVarDecl * getNonObjectParameter(unsigned I) const
Definition: Decl.h:2698
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:3096
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
Definition: Decl.h:2261
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2468
void setBodyContainsImmediateEscalatingExpressions(bool Set)
Definition: Decl.h:2414
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:4188
FunctionEffectsRef getFunctionEffects() const
Definition: Decl.h:3009
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
Definition: Decl.cpp:4116
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2763
bool isStatic() const
Definition: Decl.h:2804
void setTrivial(bool IT)
Definition: Decl.h:2306
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:4003
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2398
bool isPureVirtual() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:2288
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:3498
bool isImmediateEscalating() const
Definition: Decl.cpp:3275
bool isThisDeclarationInstantiatedFromAFriendDefinition() const
Determine whether this specific declaration of the function is a friend declaration that was instanti...
Definition: Decl.cpp:3187
void setRangeEnd(SourceLocation E)
Definition: Decl.h:2153
bool isDefaulted() const
Whether this function is defaulted.
Definition: Decl.h:2313
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4405
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
Definition: Decl.h:2808
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
Definition: Decl.cpp:3989
void setConstexprKind(ConstexprSpecKind CSK)
Definition: Decl.h:2401
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:4276
void setDefaulted(bool D=true)
Definition: Decl.h:2314
bool isConsteval() const
Definition: Decl.h:2410
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration.
Definition: Decl.h:2338
QualType getDeclaredReturnType() const
Get the declared return type, which may differ from the actual return type if the return type is dedu...
Definition: Decl.h:2737
void setBody(Stmt *B)
Definition: Decl.cpp:3255
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:2279
bool hasOneParamOrDefaultArgs() const
Determine whether this function has a single parameter, or multiple parameters where all but the firs...
Definition: Decl.cpp:3755
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:3702
size_t param_size() const
Definition: Decl.h:2665
DeclarationNameInfo getNameInfo() const
Definition: Decl.h:2146
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Definition: Decl.cpp:3163
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
Definition: Decl.cpp:3210
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2774
DefaultedOrDeletedFunctionInfo * getDefalutedOrDeletedInfo() const
Definition: Decl.cpp:3158
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
Definition: Decl.h:2680
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
Definition: Decl.h:2561
A mutable set of FunctionEffects and possibly conditions attached to them.
Definition: Type.h:5044
bool insert(const FunctionEffectWithCondition &NewEC, Conflicts &Errs)
Definition: Type.cpp:5286
An immutable set of FunctionEffects and possibly conditions attached to them.
Definition: Type.h:4908
Represents a prototype with parameter type info, e.g.
Definition: Type.h:5107
ExtParameterInfo getExtParameterInfo(unsigned I) const
Definition: Type.h:5573
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:5387
unsigned getNumParams() const
Definition: Type.h:5360
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
Definition: Type.h:5500
QualType getParamType(unsigned i) const
Definition: Type.h:5362
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:5371
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
Definition: Type.h:5445
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:5367
ArrayRef< QualType > exceptions() const
Definition: Type.h:5530
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type?
Definition: Type.h:5545
Declaration of a template function.
Definition: DeclTemplate.h:959
Wrapper for source info for functions.
Definition: TypeLoc.h:1459
unsigned getNumParams() const
Definition: TypeLoc.h:1531
ParmVarDecl * getParam(unsigned i) const
Definition: TypeLoc.h:1537
void setParam(unsigned i, ParmVarDecl *VD)
Definition: TypeLoc.h:1538
TypeLoc getReturnLoc() const
Definition: TypeLoc.h:1540
ExtInfo withCallingConv(CallingConv cc) const
Definition: Type.h:4547
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:4321
CallingConv getCallConv() const
Definition: Type.h:4659
QualType getReturnType() const
Definition: Type.h:4648
One of these records is kept for each identifier that is lexed.
unsigned getLength() const
Efficiently return the length of this identifier info.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
ReservedLiteralSuffixIdStatus isReservedLiteralSuffixId() const
Determine whether this is a name reserved for future standardization or the implementation (C++ [usrl...
bool isPlaceholder() const
StringRef getName() const
Return the actual identifier string.
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
IfStmt - This represents an if/then/else.
Definition: Stmt.h:2165
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
Definition: Expr.h:1717
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3724
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
Definition: Expr.cpp:2089
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:5841
Represents a field injected from an anonymous union/struct into the parent scope.
Definition: Decl.h:3335
void setInherited(bool I)
Definition: Attr.h:155
Description of a constructor that was inherited from a base class.
Definition: DeclCXX.h:2524
ConstructorUsingShadowDecl * getShadowDecl() const
Definition: DeclCXX.h:2536
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:514
Describes an C or C++ initializer list.
Definition: Expr.h:5088
unsigned getNumInits() const
Definition: Expr.h:5118
const Expr * getInit(unsigned Init) const
Definition: Expr.h:5134
child_range children()
Definition: Expr.h:5280
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static InitializationKind CreateDirectList(SourceLocation InitLoc)
Describes the sequence of initializations required to initialize a given object or reference with a s...
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
Definition: SemaInit.cpp:7637
Describes an entity that is being initialized.
static InitializedEntity InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, bool IsInheritedVirtualBase, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a base class subobject.
Definition: SemaInit.cpp:3605
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
static InitializedEntity InitializeBinding(VarDecl *Binding)
Create the initialization entity for a structured binding.
static InitializedEntity InitializeMemberFromDefaultMemberInitializer(FieldDecl *Member)
Create the initialization entity for a default member initializer.
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
static InitializedEntity InitializeDelegation(QualType Type)
Create the initialization entity for a delegated constructor.
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:6798
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Definition: Expr.cpp:980
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:3483
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:25
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1954
bool isInitCapture(const LambdaCapture *Capture) const
Determine whether one of this lambda's captures is an init-capture.
Definition: ExprCXX.cpp:1339
capture_range captures() const
Retrieve this lambda's captures.
Definition: ExprCXX.cpp:1352
@ Ver4
Attempt to be ABI-compatible with code generated by Clang 4.0.x (SVN r291814).
@ Ver14
Attempt to be ABI-compatible with code generated by Clang 14.0.x.
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
Definition: LangOptions.h:672
void push_back(const T &LocalValue)
iterator begin(Source *source, bool LocalOnly=false)
static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)
Returns a string for the source that the range encompasses.
Definition: Lexer.cpp:1023
Represents a linkage specification.
Definition: DeclCXX.h:2957
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LinkageSpecLanguageIDs Lang, bool HasBraces)
Definition: DeclCXX.cpp:3073
void setRBraceLoc(SourceLocation L)
Definition: DeclCXX.h:2999
bool isLocalPackExpansion(const Decl *D)
Determine whether D is a pack expansion created in this scope.
A class for iterating through a result set and possibly filtering out results.
Definition: Lookup.h:675
void erase()
Erase the last element returned from this iterator.
Definition: Lookup.h:721
bool hasNext() const
Definition: Lookup.h:706
NamedDecl * next()
Definition: Lookup.h:710
Represents the results of name lookup.
Definition: Lookup.h:46
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
Definition: Lookup.h:63
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition: Lookup.h:68
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition: Lookup.h:73
@ NotFound
No entity found met the criteria.
Definition: Lookup.h:50
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition: Lookup.h:55
@ Found
Name lookup found a single declaration that met the criteria.
Definition: Lookup.h:59
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
Definition: Lookup.h:605
void setBaseObjectType(QualType T)
Sets the base object type for this lookup.
Definition: Lookup.h:469
DeclClass * getAsSingle() const
Definition: Lookup.h:558
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Lookup.h:475
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Lookup.h:270
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:362
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
Definition: SemaLookup.cpp:484
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Lookup.h:664
Filter makeFilter()
Create a filter for this result set.
Definition: Lookup.h:749
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Lookup.h:568
void setHideTags(bool Hide)
Sets whether tag declarations should be hidden by non-tag declarations during resolution.
Definition: Lookup.h:311
bool isAmbiguous() const
Definition: Lookup.h:324
NamedDecl * getAcceptableDecl(NamedDecl *D) const
Retrieve the accepted (re)declaration of the given declaration, if there is one.
Definition: Lookup.h:408
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Lookup.h:331
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:275
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Lookup.h:575
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:634
iterator end() const
Definition: Lookup.h:359
static bool isVisible(Sema &SemaRef, NamedDecl *D)
Determine whether the given declaration is visible to the program.
iterator begin() const
Definition: Lookup.h:358
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Lookup.h:255
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:4258
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
Definition: DeclCXX.cpp:3530
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:3236
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:3319
Expr * getBase() const
Definition: Expr.h:3313
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.h:3431
Wrapper for source info for member pointers.
Definition: TypeLoc.h:1363
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:3519
Describes a module or submodule.
Definition: Module.h:115
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:703
bool isExplicitGlobalModule() const
Definition: Module.h:213
This represents a decl that may have a name.
Definition: Decl.h:253
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:466
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:274
bool isPlaceholderVar(const LangOptions &LangOpts) const
Definition: Decl.cpp:1089
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:319
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined.
Definition: DeclBase.h:699
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Definition: Decl.h:376
Represents a C++ namespace alias.
Definition: DeclCXX.h:3143
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
Definition: DeclCXX.cpp:3168
Represent a C++ namespace.
Definition: Decl.h:551
bool isInline() const
Returns true if this is an inline namespace declaration.
Definition: Decl.h:607
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl, bool Nested)
Definition: DeclCXX.cpp:3128
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace that inhabits this namespace, if any.
Definition: Decl.h:634
void setRBraceLoc(SourceLocation L)
Definition: Decl.h:653
Class that aids in the construction of nested-name-specifiers along with source-location information ...
A C++ nested-name-specifier augmented with source location information.
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
@ Global
The global specifier '::'. There is no stored value.
bool containsUnexpandedParameterPack() const
Whether this nested-name-specifier contains an unexpanded parameter pack (for C++11 variadic template...
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:28
bool isFragile() const
The inverse of isNonFragile(): does this runtime follow the set of implied behaviors for a "fragile" ...
Definition: ObjCRuntime.h:97
PtrTy get() const
Definition: Ownership.h:80
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Definition: Expr.h:1173
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
Definition: Overload.h:1008
@ CSK_Normal
Normal lookup.
Definition: Overload.h:1012
@ CSK_Operator
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax.
Definition: Overload.h:1019
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition: Overload.h:1185
MapType::iterator iterator
MapType::const_iterator const_iterator
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
Definition: Attr.h:255
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc)
Create a paren list.
Definition: Expr.cpp:4774
Represents a parameter to a function.
Definition: Decl.h:1725
void setDefaultArg(Expr *defarg)
Definition: Decl.cpp:2987
SourceLocation getExplicitObjectParamThisLoc() const
Definition: Decl.h:1821
void setUnparsedDefaultArg()
Specify that this parameter has an unparsed default argument.
Definition: Decl.h:1866
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
Definition: Decl.h:1854
SourceRange getDefaultArgRange() const
Retrieve the source range that covers the entire default argument.
Definition: Decl.cpp:2992
void setUninstantiatedDefaultArg(Expr *arg)
Definition: Decl.cpp:3012
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1758
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1858
bool hasInheritedDefaultArg() const
Definition: Decl.h:1870
bool isExplicitObjectParameter() const
Definition: Decl.h:1813
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2922
Expr * getDefaultArg()
Definition: Decl.cpp:2975
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:3017
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
Definition: Decl.cpp:3023
void setHasInheritedDefaultArg(bool I=true)
Definition: Decl.h:1874
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2945
ParsedAttr - Represents a syntactic attribute.
Definition: ParsedAttr.h:129
IdentifierInfo * getPropertyDataSetter() const
Definition: ParsedAttr.h:485
IdentifierInfo * getPropertyDataGetter() const
Definition: ParsedAttr.h:479
static const ParsedAttributesView & none()
Definition: ParsedAttr.h:836
bool hasAttribute(ParsedAttr::Kind K) const
Definition: ParsedAttr.h:916
Wrapper for source info for pointers.
Definition: TypeLoc.h:1332
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:3198
QualType getPointeeType() const
Definition: Type.h:3208
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
IdentifierTable & getIdentifierTable()
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:6546
ArrayRef< Expr * > semantics()
Definition: Expr.h:6625
A (possibly-)qualified type.
Definition: Type.h:929
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:8020
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:8025
QualType withConst() const
Definition: Type.h:1154
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Definition: Type.h:1220
void addConst()
Add the const type qualifier to this QualType.
Definition: Type.h:1151
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:996
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:7976
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1433
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:8139
QualType getCanonicalType() const
Definition: Type.h:7988
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:8030
bool isWebAssemblyReferenceType() const
Returns true if it is a WebAssembly Reference Type.
Definition: Type.cpp:2885
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
Definition: Type.h:1081
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:8009
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:7982
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: Type.h:1327
bool hasNonTrivialObjCLifetime() const
Definition: Type.h:1437
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:2641
bool isAtLeastAsQualifiedAs(QualType Other, const ASTContext &Ctx) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
Definition: Type.h:8119
Represents a template name as written in source code.
Definition: TemplateName.h:491
The collection of all-type qualifiers we support.
Definition: Type.h:324
void addAddressSpace(LangAS space)
Definition: Type.h:590
@ OCL_Weak
Reading or writing from this object requires a barrier call.
Definition: Type.h:357
void removeConst()
Definition: Type.h:452
void removeAddressSpace()
Definition: Type.h:589
void addConst()
Definition: Type.h:453
void removeVolatile()
Definition: Type.h:462
LangAS getAddressSpace() const
Definition: Type.h:564
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:3501
Represents a struct/union/class.
Definition: Decl.h:4162
bool hasFlexibleArrayMember() const
Definition: Decl.h:4195
field_iterator field_end() const
Definition: Decl.h:4379
field_range fields() const
Definition: Decl.h:4376
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
Definition: Decl.cpp:5061
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
Definition: Decl.h:4214
bool field_empty() const
Definition: Decl.h:4384
field_iterator field_begin() const
Definition: Decl.cpp:5095
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:6077
RecordDecl * getDecl() const
Definition: Type.h:6087
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:215
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:203
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:225
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:5003
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:295
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:3439
QualType getPointeeType() const
Definition: Type.h:3457
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
Definition: Stmt.h:3046
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:41
void setEntity(DeclContext *E)
Definition: Scope.h:393
void AddDecl(Decl *D)
Definition: Scope.h:346
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:271
@ DeclScope
This is a scope that can contain a declaration.
Definition: Scope.h:63
A generic diagnostic builder for errors which may or may not be deferred.
Definition: SemaBase.h:110
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
Definition: SemaBase.cpp:60
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaBase.cpp:32
Sema & SemaRef
Definition: SemaBase.h:40
bool inferTargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, CXXMethodDecl *MemberDecl, bool ConstRHS, bool Diagnose)
Given a implicit special member, infer its CUDA target from the calls it needs to make to underlying ...
Definition: SemaCUDA.cpp:370
void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, SourceLocation IdLoc=SourceLocation())
Check declaration inside target region.
A RAII object to enter scope of a compound statement.
Definition: Sema.h:916
bool isInvalid() const
Definition: Sema.h:7331
A RAII object to temporarily push a declaration context.
Definition: Sema.h:3010
For a defaulted function, the kind of defaulted function that it is.
Definition: Sema.h:5891
DefaultedComparisonKind asComparison() const
Definition: Sema.h:5923
CXXSpecialMemberKind asSpecialMember() const
Definition: Sema.h:5920
Helper class that collects exception specifications for implicitly-declared special member functions.
Definition: Sema.h:4995
void CalledStmt(Stmt *S)
Integrate an invoked statement into the collected data.
void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method)
Integrate another called method into the collected data.
SpecialMemberOverloadResult - The overloading result for a special member function.
Definition: Sema.h:8942
CXXMethodDecl * getMethod() const
Definition: Sema.h:8954
RAII object to handle the state changes required to synthesize a function body.
Definition: Sema.h:13078
Abstract base class used for diagnosing integer constant expression violations.
Definition: Sema.h:7229
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:464
void DefineImplicitLambdaToFunctionPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a function pointer.
QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
CXXConstructorDecl * DeclareImplicitDefaultConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit default constructor for the given class.
bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S)
MergeCXXFunctionDecl - Merge two declarations of the same C++ function, once we already know that the...
Attr * getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD, bool IsDefinition)
Returns an implicit CodeSegAttr if a __declspec(code_seg) is found on a containing class.
Definition: SemaDecl.cpp:11046
MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, CXXRecordDecl *ClassDecl)
void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D)
Definition: SemaDecl.cpp:6716
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
bool EvaluateStaticAssertMessageAsString(Expr *Message, std::string &Result, ASTContext &Ctx, bool ErrorOnInvalidMessage)
bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range)
CheckSpecifiedExceptionType - Check if the given type is valid in an exception specification.
ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation, SourceLocation ConvLocation, CXXConversionDecl *Conv, Expr *Src)
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:12643
Decl * ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS, MultiTemplateParamsArg TemplateParams, SourceLocation UsingLoc, UnqualifiedId &Name, const ParsedAttributesView &AttrList, TypeResult Type, Decl *DeclFromDeclSpec)
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location.
NamedDecl * ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope)
Definition: SemaDecl.cpp:9816
void DiagnoseAbstractType(const CXXRecordDecl *RD)
void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow)
Hides a using shadow declaration.
bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R=nullptr, const UsingDecl *UD=nullptr)
Checks that the given nested-name qualifier used in a using decl in the current context is appropriat...
bool CheckExplicitObjectOverride(CXXMethodDecl *New, const CXXMethodDecl *Old)
llvm::SmallPtrSet< SpecialMemberDecl, 4 > SpecialMembersBeingDeclared
The C++ special members which we are currently in the process of declaring.
Definition: Sema.h:6074
void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc, SourceLocation ArgLoc)
ActOnParamUnparsedDefaultArgument - We've seen a default argument for a function parameter,...
DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD)
Determine the kind of defaulting that would be done for a given function.
ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, ActOnMemberAccessExtraArgs *ExtraArgs=nullptr)
bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false) const
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...
Definition: SemaDecl.cpp:1561
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs=true)
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp=false)
Definition: SemaExpr.cpp:15498
void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath)
void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old)
Merge the exception specifications of two variable declarations.
CXXSpecialMemberKind getSpecialMember(const CXXMethodDecl *MD)
Definition: Sema.h:5835
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
Definition: Sema.h:8990
@ LookupUsingDeclName
Look up all declarations in a scope with the given name, including resolved using declarations.
Definition: Sema.h:9017
@ LookupLocalFriendName
Look up a friend of a local class.
Definition: Sema.h:9025
@ LookupNamespaceName
Look up a namespace name within a C++ using directive or namespace alias definition,...
Definition: Sema.h:9013
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:8998
void DiagnoseSentinelCalls(const NamedDecl *D, SourceLocation Loc, ArrayRef< Expr * > Args)
DiagnoseSentinelCalls - This routine checks whether a call or message-send is to a declaration with t...
Definition: SemaExpr.cpp:412
void DiagnoseFunctionSpecifiers(const DeclSpec &DS)
Diagnose function specifiers on a declaration of an identifier that does not identify a function.
Definition: SemaDecl.cpp:6652
Decl * ActOnUsingEnumDeclaration(Scope *CurScope, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation EnumLoc, SourceRange TyLoc, const IdentifierInfo &II, ParsedType Ty, CXXScopeSpec *SS=nullptr)
VariadicCallType
Definition: Sema.h:2315
@ VariadicDoesNotApply
Definition: Sema.h:2320
@ VariadicConstructor
Definition: Sema.h:2319
Decl * BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *AssertMessageExpr, SourceLocation RParenLoc, bool Failed)
void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD)
Evaluate the implicit exception specification for a defaulted special member function.
ExplicitSpecifier ActOnExplicitBoolSpecifier(Expr *E)
ActOnExplicitBoolSpecifier - Build an ExplicitSpecifier from an expression found in an explicit(bool)...
bool DiagRedefinedPlaceholderFieldDecl(SourceLocation Loc, RecordDecl *ClassDecl, const IdentifierInfo *Name)
void ActOnFinishCXXNonNestedClass()
MemInitResult BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo, Expr *Init, CXXRecordDecl *ClassDecl, SourceLocation EllipsisLoc)
void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class)
Force the declaration of any implicitly-declared members of this class.
void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc, Expr *DefaultArg)
ActOnParamDefaultArgumentError - Parsing or semantic analysis of the default argument for the paramet...
bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, DeclarationName Name, SourceLocation Loc, TemplateIdAnnotation *TemplateId, bool IsMemberSpecialization)
Diagnose a declaration whose declarator-id has the given nested-name-specifier.
Definition: SemaDecl.cpp:6129
void DiagnoseStaticAssertDetails(const Expr *E)
Try to print more useful information about a failed static_assert with expression \E.
void DefineImplicitMoveAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared move assignment operator.
void ActOnFinishDelayedMemberInitializers(Decl *Record)
void PrintContextStack()
Definition: Sema.h:13220
NamedDecl * ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef< BindingDecl * > Bindings={})
Definition: SemaDecl.cpp:7470
SemaOpenMP & OpenMP()
Definition: Sema.h:1126
void CheckDelegatingCtorCycles()
SmallVector< CXXMethodDecl *, 4 > DelayedDllExportMemberFunctions
Definition: Sema.h:5810
void CheckExplicitObjectMemberFunction(Declarator &D, DeclarationName Name, QualType R, bool IsLambda, DeclContext *DC=nullptr)
bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info)
DiagnoseClassNameShadow - Implement C++ [class.mem]p13: If T is the name of a class,...
Definition: SemaDecl.cpp:6114
AccessResult CheckFriendAccess(NamedDecl *D)
Checks access to the target of a friend declaration.
void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc, CXXRecordDecl *Record)
MarkBaseAndMemberDestructorsReferenced - Given a record decl, mark all the non-trivial destructors of...
const TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition: Sema.h:867
DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D)
ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a C++ if/switch/while/for statem...
void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet, OverloadedOperatorKind Op, const UnresolvedSetImpl &Fns, ArrayRef< Expr * > Args, bool RequiresADL=true)
Perform lookup for an overloaded binary operator.
DelegatingCtorDeclsType DelegatingCtorDecls
All the delegating constructors seen so far in the file, used for cycle detection at the end of the T...
Definition: Sema.h:6051
bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc, SourceLocation ColonLoc, const ParsedAttributesView &Attrs)
ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
Definition: Sema.h:6032
void AddPragmaAttributes(Scope *S, Decl *D)
Adds the attributes that have been specified using the '#pragma clang attribute push' directives to t...
Definition: SemaAttr.cpp:1190
SemaCUDA & CUDA()
Definition: Sema.h:1071
TemplateDecl * AdjustDeclIfTemplate(Decl *&Decl)
AdjustDeclIfTemplate - If the given decl happens to be a template, reset the parameter D to reference...
bool isImplicitlyDeleted(FunctionDecl *FD)
Determine whether the given function is an implicitly-deleted special member function.
void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD)
Check a completed declaration of an implicit special member.
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
Definition: SemaExpr.cpp:17394
bool CompleteConstructorCall(CXXConstructorDecl *Constructor, QualType DeclInitType, MultiExprArg ArgsPtr, SourceLocation Loc, SmallVectorImpl< Expr * > &ConvertedArgs, bool AllowExplicit=false, bool IsListInitialization=false)
Given a constructor and the set of arguments provided for the constructor, convert the arguments and ...
@ Boolean
A boolean condition, from 'if', 'while', 'for', or 'do'.
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
bool TemplateParameterListsAreEqual(const TemplateCompareNewDeclInfo &NewInstFrom, TemplateParameterList *New, const NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
Decl * ActOnNamespaceAliasDef(Scope *CurScope, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident)
void CheckOverrideControl(NamedDecl *D)
CheckOverrideControl - Check C++11 override control semantics.
bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, InheritedConstructorInfo *ICI=nullptr, bool Diagnose=false)
Determine if a special member function should have a deleted definition when it is defaulted.
@ AR_dependent
Definition: Sema.h:1270
@ AR_accessible
Definition: Sema.h:1268
@ AR_inaccessible
Definition: Sema.h:1269
@ AR_delayed
Definition: Sema.h:1271
PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())
Pop a function (or block or lambda or captured region) scope from the stack.
Definition: Sema.cpp:2292
DeclResult ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc, unsigned TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, SourceLocation EllipsisLoc, const ParsedAttributesView &Attr, MultiTemplateParamsArg TempParamLists)
Handle a friend tag declaration where the scope specifier was templated.
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
Definition: Sema.cpp:2161
CXXConstructorDecl * DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit move constructor for the given class.
bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl, const ParsedAttributesView &AttrList)
Annotation attributes are the only attributes allowed after an access specifier.
FunctionDecl * InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD, const TemplateArgumentList *Args, SourceLocation Loc, CodeSynthesisContext::SynthesisKind CSC=CodeSynthesisContext::ExplicitTemplateArgumentSubstitution)
Instantiate (or find existing instantiation of) a function template with a given set of template argu...
void SetFunctionBodyKind(Decl *D, SourceLocation Loc, FnBodyKind BodyKind, StringLiteral *DeletedMessage=nullptr)
void referenceDLLExportedClassMethods()
void CheckCompleteDestructorVariant(SourceLocation CurrentLocation, CXXDestructorDecl *Dtor)
Do semantic checks to allow the complete destructor variant to be emitted when the destructor is defi...
NamedDecl * ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, Expr *BitfieldWidth, const VirtSpecifiers &VS, InClassInitStyle InitStyle)
ActOnCXXMemberDeclarator - This is invoked when a C++ class member declarator is parsed.
bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member function overrides a virtual...
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
Definition: SemaDecl.cpp:6257
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
Definition: SemaExpr.cpp:17152
bool CheckOverridingFunctionAttributes(CXXMethodDecl *New, const CXXMethodDecl *Old)
TemplateParameterList * MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, ArrayRef< TemplateParameterList * > ParamLists, bool IsFriend, bool &IsMemberSpecialization, bool &Invalid, bool SuppressDiagnostic=false)
Match the given template parameter lists to the given scope specifier, returning the template paramet...
void handleTagNumbering(const TagDecl *Tag, Scope *TagScope)
Definition: SemaDecl.cpp:4844
void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl)
AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared special functions,...
bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec)
tryResolveExplicitSpecifier - Attempt to resolve the explict specifier.
Decl * ActOnConversionDeclarator(CXXConversionDecl *Conversion)
ActOnConversionDeclarator - Called by ActOnDeclarator to complete the declaration of the given C++ co...
@ Other
C++26 [dcl.fct.def.general]p1 function-body: ctor-initializer[opt] compound-statement function-try-bl...
@ Delete
deleted-function-body
QualType BuildStdInitializerList(QualType Element, SourceLocation Loc)
Looks for the std::initializer_list template and instantiates it with Element, or emits an error if i...
MemInitResult BuildMemberInitializer(ValueDecl *Member, Expr *Init, SourceLocation IdLoc)
StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue=true)
Definition: SemaStmt.cpp:49
FieldDecl * HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS)
HandleField - Analyze a field of a C struct or a C++ data member.
Definition: SemaDecl.cpp:18402
FPOptionsOverride CurFPFeatureOverrides()
Definition: Sema.h:1665
void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD)
Diagnose methods which overload virtual methods in a base class without overriding any.
UsingShadowDecl * BuildUsingShadowDecl(Scope *S, BaseUsingDecl *BUD, NamedDecl *Target, UsingShadowDecl *PrevDecl)
Builds a shadow declaration corresponding to a 'using' declaration.
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallToMemberFunction - Build a call to a member function.
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)
Look up a name, looking for a single declaration.
bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, DeclAccessPair Found, QualType ObjectType, SourceLocation Loc, const PartialDiagnostic &Diag)
Is the given member accessible for the purposes of deciding whether to define a special member functi...
BaseResult ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange, const ParsedAttributesView &Attrs, bool Virtual, AccessSpecifier Access, ParsedType basetype, SourceLocation BaseLoc, SourceLocation EllipsisLoc)
ActOnBaseSpecifier - Parsed a base specifier.
void ActOnFinishFunctionDeclarationDeclarator(Declarator &D)
Called after parsing a function declarator belonging to a function declaration.
void ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc, Expr *defarg)
ActOnParamDefaultArgument - Check whether the default argument provided for a function parameter is w...
void CheckConversionDeclarator(Declarator &D, QualType &R, StorageClass &SC)
CheckConversionDeclarator - Called by ActOnDeclarator to check the well-formednes of the conversion f...
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
ASTContext & Context
Definition: Sema.h:909
void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnFinishDelayedCXXMethodDeclaration - We have finished processing the delayed method declaration f...
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
Definition: SemaDecl.cpp:5821
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:529
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
SemaObjC & ObjC()
Definition: Sema.h:1111
void propagateDLLAttrToBaseClassTemplate(CXXRecordDecl *Class, Attr *ClassAttr, ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc)
Perform propagation of DLL attributes from a derived class to a templated base class for MS compatibi...
NamedDecl * ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams)
void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, TypedefNameDecl *NewTD)
Definition: SemaDecl.cpp:4954
void CheckDelayedMemberExceptionSpecs()
void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param)
This is used to implement the constant expression evaluation part of the attribute enable_if extensio...
AllowFoldKind
Definition: Sema.h:7243
@ AllowFold
Definition: Sema.h:7245
@ NoFold
Definition: Sema.h:7244
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
Definition: SemaDecl.cpp:1499
ASTContext & getASTContext() const
Definition: Sema.h:532
ClassTemplateDecl * StdInitializerList
The C++ "std::initializer_list" template, which is defined in <initializer_list>.
Definition: Sema.h:6058
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
void CheckExplicitlyDefaultedFunction(Scope *S, FunctionDecl *MD)
bool isCurrentClassName(const IdentifierInfo &II, Scope *S, const CXXScopeSpec *SS=nullptr)
isCurrentClassName - Determine whether the identifier II is the name of the class type currently bein...
void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var)
Mark a variable referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
Definition: SemaExpr.cpp:19915
void checkExceptionSpecification(bool IsTopLevel, ExceptionSpecificationType EST, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr, SmallVectorImpl< QualType > &Exceptions, FunctionProtoType::ExceptionSpecInfo &ESI)
Check the given exception-specification and update the exception specification information with the r...
SmallVector< std::pair< FunctionDecl *, FunctionDecl * >, 2 > DelayedEquivalentExceptionSpecChecks
All the function redeclarations seen during a class definition that had their exception spec checks d...
Definition: Sema.h:6136
bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method)
Check whether 'this' shows up in the type of a static member function after the (naturally empty) cv-...
void PopExpressionEvaluationContext()
Definition: SemaExpr.cpp:17827
NamespaceDecl * getOrCreateStdNamespace()
Retrieve the special "std" namespace, which may require us to implicitly define the namespace.
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool RequiresADL=true, bool AllowRewrittenCandidates=true, FunctionDecl *DefaultedFn=nullptr)
Create a binary operation that may resolve to an overloaded operator.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
Definition: Sema.cpp:692
bool isInitListConstructor(const FunctionDecl *Ctor)
Determine whether Ctor is an initializer-list constructor, as defined in [dcl.init....
void ActOnStartFunctionDeclarationDeclarator(Declarator &D, unsigned TemplateParameterDepth)
Called before parsing a function declarator belonging to a function declaration.
std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths)
Builds a string representing ambiguous paths from a specific derived class to different subobjects of...
DefaultedComparisonKind
Kinds of defaulted comparison operator functions.
Definition: Sema.h:5606
@ Relational
This is an <, <=, >, or >= that should be implemented as a rewrite in terms of a <=> comparison.
@ NotEqual
This is an operator!= that should be implemented as a rewrite in terms of a == comparison.
@ ThreeWay
This is an operator<=> that should be implemented as a series of subobject comparisons.
@ None
This is not a defaultable comparison operator.
@ Equal
This is an operator== that should be implemented as a series of subobject comparisons.
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
Definition: SemaType.cpp:9486
llvm::PointerIntPair< CXXRecordDecl *, 3, CXXSpecialMemberKind > SpecialMemberDecl
Definition: Sema.h:6069
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
ValueDecl * tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl, CXXScopeSpec &SS, ParsedType TemplateTypeTy, IdentifierInfo *MemberOrBase)
NamedDecl * BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation, bool IsUsingIfExists)
Builds a using declaration.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:817
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
Definition: SemaExpr.cpp:2204
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
void DefineImplicitMoveConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitMoveConstructor - Checks for feasibility of defining this constructor as the move const...
@ TPL_TemplateMatch
We are matching the template parameter lists of two templates that might be redeclarations.
Definition: Sema.h:11789
EnumDecl * getStdAlignValT() const
void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record)
LangAS getDefaultCXXMethodAddrSpace() const
Returns default addr space for method qualifiers.
Definition: Sema.cpp:1589
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
Definition: Sema.h:7962
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
Definition: SemaType.cpp:1581
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:2180
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
void DefineImplicitCopyConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitCopyConstructor - Checks for feasibility of defining this constructor as the copy const...
FPOptions & getCurFPFeatures()
Definition: Sema.h:527
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK, bool MissingOK=false)
Definition: SemaExpr.cpp:20418
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:82
@ UPPC_RequiresClause
Definition: Sema.h:13966
@ UPPC_UsingDeclaration
A using declaration.
Definition: Sema.h:13921
@ UPPC_ExceptionType
The type of an exception.
Definition: Sema.h:13939
@ UPPC_Initializer
An initializer.
Definition: Sema.h:13930
@ UPPC_BaseType
The base type of a class type.
Definition: Sema.h:13900
@ UPPC_FriendDeclaration
A friend declaration.
Definition: Sema.h:13924
@ UPPC_DefaultArgument
A default argument.
Definition: Sema.h:13933
@ UPPC_DeclarationType
The type of an arbitrary declaration.
Definition: Sema.h:13903
@ UPPC_DataMemberType
The type of a data member.
Definition: Sema.h:13906
@ UPPC_StaticAssertExpression
The expression in a static assertion.
Definition: Sema.h:13912
Decl * ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc, SourceLocation NamespaceLoc, SourceLocation IdentLoc, IdentifierInfo *Ident, SourceLocation LBrace, const ParsedAttributesView &AttrList, UsingDirectiveDecl *&UsingDecl, bool IsNested)
ActOnStartNamespaceDef - This is called at the start of a namespace definition.
const LangOptions & getLangOpts() const
Definition: Sema.h:525
void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl, bool SupportedForCompatibility=false)
DiagnoseTemplateParameterShadow - Produce a diagnostic complaining that the template parameter 'PrevD...
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
QualType CheckComparisonCategoryType(ComparisonCategoryType Kind, SourceLocation Loc, ComparisonCategoryUsage Usage)
Lookup the specified comparison category types in the standard library, an check the VarDecls possibl...
void DiagnoseAbsenceOfOverrideControl(NamedDecl *D, bool Inconsistent)
DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was not used in the declaration of ...
SmallVector< VTableUse, 16 > VTableUses
The list of vtables that are required but have not yet been materialized.
Definition: Sema.h:5396
AccessResult CheckStructuredBindingMemberAccess(SourceLocation UseLoc, CXXRecordDecl *DecomposedClass, DeclAccessPair Field)
Checks implicit access to a member in a structured binding.
void EnterTemplatedContext(Scope *S, DeclContext *DC)
Enter a template parameter scope, after it's been associated with a particular DeclContext.
Definition: SemaDecl.cpp:1390
void ActOnBaseSpecifiers(Decl *ClassDecl, MutableArrayRef< CXXBaseSpecifier * > Bases)
ActOnBaseSpecifiers - Attach the given base specifiers to the class, after checking whether there are...
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD, DefaultedComparisonKind DCK)
bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A, const NamedDecl *B)
Determine if A and B are equivalent internal linkage declarations from different modules,...
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, QualType ObjectType, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
Preprocessor & PP
Definition: Sema.h:908
bool CheckConstexprFunctionDefinition(const FunctionDecl *FD, CheckConstexprKind Kind)
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:6475
AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, QualType Derived, const CXXBasePath &Path, unsigned DiagID, bool ForceCheck=false, bool ForceUnprivileged=false)
Checks access for a hierarchy conversion.
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument.
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
NamedDecl * getShadowedDeclaration(const TypedefNameDecl *D, const LookupResult &R)
Return the declaration shadowed by the given typedef D, or null if it doesn't shadow any declaration ...
Definition: SemaDecl.cpp:8279
void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet)
AddBuiltinOperatorCandidates - Add the appropriate built-in operator overloads to the candidate set (...
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD)
void checkClassLevelDLLAttribute(CXXRecordDecl *Class)
Check class-level dllimport/dllexport attribute.
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
Definition: Sema.h:14375
const LangOptions & LangOpts
Definition: Sema.h:907
std::pair< Expr *, std::string > findFailedBooleanCondition(Expr *Cond)
Find the failed Boolean condition within a given Boolean constant expression, and describe it with a ...
void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock)
void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD, bool ConstexprOnly=false)
MarkVirtualMembersReferenced - Will mark all members of the given CXXRecordDecl referenced.
ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl)
Wrap the expression in a ConstantExpr if it is a potential immediate invocation.
Definition: SemaExpr.cpp:17511
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
Definition: SemaInit.cpp:7600
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:6036
SemaHLSL & HLSL()
Definition: Sema.h:1076
void DefineInheritingConstructor(SourceLocation UseLoc, CXXConstructorDecl *Constructor)
Define the specified inheriting constructor.
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn)
Perform semantic checking of a new function declaration.
Definition: SemaDecl.cpp:11953
CXXRecordDecl * getStdBadAlloc() const
QualType CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckDestructorDeclarator - Called by ActOnDeclarator to check the well-formednes of the destructor d...
bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange)
Mark the given method pure.
void SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
void NoteHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl< CXXMethodDecl * > &OverloadedMethods)
CXXMethodDecl * DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl)
Declare the implicit move assignment operator for the given class.
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
llvm::DenseMap< CXXRecordDecl *, bool > VTablesUsed
The set of classes whose vtables have been used within this translation unit, and a bit that will be ...
Definition: Sema.h:5402
void CheckCXXDefaultArguments(FunctionDecl *FD)
Helpers for dealing with blocks and functions.
ComparisonCategoryUsage
Definition: Sema.h:4792
@ DefaultedOperator
A defaulted 'operator<=>' needed the comparison category.
SmallVector< InventedTemplateParameterInfo, 4 > InventedParameterInfos
Stack containing information needed when in C++2a an 'auto' is encountered in a function declaration ...
Definition: Sema.h:6029
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
Definition: SemaExpr.cpp:20066
void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AttrList, const ProcessDeclAttributeOptions &Options=ProcessDeclAttributeOptions())
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
NamedDecl * BuildUsingEnumDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation EnumLoc, SourceLocation NameLoc, TypeSourceInfo *EnumType, EnumDecl *ED)
TypeLoc getReturnTypeLoc(FunctionDecl *FD) const
Definition: SemaStmt.cpp:3710
SmallVector< std::pair< const CXXMethodDecl *, const CXXMethodDecl * >, 2 > DelayedOverridingExceptionSpecChecks
All the overriding functions seen during a class definition that had their exception spec checks dela...
Definition: Sema.h:6128
llvm::DenseMap< ParmVarDecl *, SourceLocation > UnparsedDefaultArgLocs
Definition: Sema.h:6062
void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc, const CXXRecordDecl *RD)
Mark the exception specifications of all virtual member functions in the given class as needed.
ExprResult BuildConvertedConstantExpression(Expr *From, QualType T, CCEKind CCE, NamedDecl *Dest=nullptr)
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
Definition: SemaType.cpp:9582
bool RequireCompleteEnumDecl(EnumDecl *D, SourceLocation L, CXXScopeSpec *SS=nullptr)
Require that the EnumDecl is completed with its enumerators defined or instantiated.
OverloadKind CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &OldDecls, NamedDecl *&OldDecl, bool UseMemberUsingDeclRules)
Determine whether the given New declaration is an overload of the declarations in Old.
bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl)
CheckOverloadedOperatorDeclaration - Check whether the declaration of this overloaded operator is wel...
void ExitDeclaratorContext(Scope *S)
Definition: SemaDecl.cpp:1377
void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir)
void CheckConstructor(CXXConstructorDecl *Constructor)
CheckConstructor - Checks a fully-formed constructor for well-formedness, issuing any diagnostics req...
void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a block pointer.
void DefineImplicitDestructor(SourceLocation CurrentLocation, CXXDestructorDecl *Destructor)
DefineImplicitDestructor - Checks for feasibility of defining this destructor as the default destruct...
void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMemberKind CSM)
Diagnose why the specified class does not have a trivial special member of the given kind.
CXXRecordDecl * getCurrentClass(Scope *S, const CXXScopeSpec *SS)
Get the class that is directly named by the current context.
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
Definition: SemaType.cpp:1857
ExprResult ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr)
bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method)
Check whether 'this' shows up in the attributes of the given static member function.
CXXBaseSpecifier * CheckBaseSpecifier(CXXRecordDecl *Class, SourceRange SpecifierRange, bool Virtual, AccessSpecifier Access, TypeSourceInfo *TInfo, SourceLocation EllipsisLoc)
Check the validity of a C++ base class specifier.
DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations
A mapping from parameters with unparsed default arguments to the set of instantiations of each parame...
Definition: Sema.h:12655
void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitDefaultConstructor - Checks for feasibility of defining this constructor as the default...
std::pair< CXXRecordDecl *, SourceLocation > VTableUse
The list of classes whose vtables have been used within this translation unit, and the source locatio...
Definition: Sema.h:5392
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:640
bool CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Target, const LookupResult &PreviousDecls, UsingShadowDecl *&PrevShadow)
Determines whether to create a using shadow decl for a particular decl, given the set of decls existi...
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
Definition: SemaExpr.cpp:3189
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
Definition: Sema.h:14990
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
Module * getCurrentModule() const
Get the module unit whose scope we are currently within.
Definition: Sema.h:9588
bool CheckDeductionGuideDeclarator(Declarator &D, QualType &R, StorageClass &SC)
Check the validity of a declarator that we parsed for a deduction-guide.
void DiagPlaceholderVariableDefinition(SourceLocation Loc)
void CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition=nullptr, SkipBodyInfo *SkipBody=nullptr)
Definition: SemaDecl.cpp:15449
bool DiagnoseUseOfOverloadedDecl(NamedDecl *D, SourceLocation Loc)
Definition: Sema.h:6492
std::unique_ptr< RecordDeclSetTy > PureVirtualClassDiagSet
PureVirtualClassDiagSet - a set of class declarations which we have emitted a list of pure virtual fu...
Definition: Sema.h:6043
void ActOnFinishInlineFunctionDef(FunctionDecl *D)
Definition: SemaDecl.cpp:15373
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:1044
bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, bool Diagnose=true, bool WantSize=false, bool WantAligned=false)
VarDecl * BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id)
Perform semantic analysis for the variable declaration that occurs within a C++ catch clause,...
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
Definition: SemaDecl.cpp:14940
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
Definition: SemaDecl.cpp:5826
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams, SourceLocation EllipsisLoc)
Handle a friend type declaration.
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
void DefineImplicitCopyAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared copy assignment operator.
bool SetDelegatingInitializer(CXXConstructorDecl *Constructor, CXXCtorInitializer *Initializer)
TrivialABIHandling
Definition: Sema.h:5875
@ TAH_IgnoreTrivialABI
The triviality of a method unaffected by "trivial_abi".
Definition: Sema.h:5877
@ TAH_ConsiderTrivialABI
The triviality of a method affected by "trivial_abi".
Definition: Sema.h:5880
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
Definition: Sema.h:7777
bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl)
CheckLiteralOperatorDeclaration - Check whether the declaration of this literal operator function is ...
bool DefineUsedVTables()
Define all of the vtables that have been used in this translation unit and reference any virtual memb...
CXXMethodDecl * DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl)
Declare the implicit copy assignment operator for the given class.
void MarkVirtualBaseDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl, llvm::SmallPtrSetImpl< const RecordType * > *DirectVirtualBases=nullptr)
Mark destructors of virtual bases of this class referenced.
void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD)
Check that the C++ class annoated with "trivial_abi" satisfies all the conditions that are needed for...
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
Definition: SemaExpr.cpp:20015
StmtResult ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, ConditionResult Second, FullExprArg Third, SourceLocation RParenLoc, Stmt *Body)
Definition: SemaStmt.cpp:2255
unsigned ActOnReenterTemplateScope(Decl *Template, llvm::function_ref< Scope *()> EnterScope)
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl, CXXConstructorDecl *Constructor, MultiExprArg Exprs, bool HadMultipleCandidates, bool IsListInitialization, bool IsStdInitListInitialization, bool RequiresZeroInit, CXXConstructionKind ConstructKind, SourceRange ParenRange)
BuildCXXConstructExpr - Creates a complete call to a constructor, including handling of its default a...
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:13490
SourceManager & getSourceManager() const
Definition: Sema.h:530
FunctionDecl * SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD, FunctionDecl *Spaceship)
Substitute the name and return type of a defaulted 'operator<=>' to form an implicit 'operator=='.
NamedDecl * ActOnDecompositionDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists)
ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, FieldDecl *Field, DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo)
void diagnoseFunctionEffectMergeConflicts(const FunctionEffectSet::Conflicts &Errs, SourceLocation NewLoc, SourceLocation OldLoc)
void EnterDeclaratorContext(Scope *S, DeclContext *DC)
EnterDeclaratorContext - Used when we must lookup names in the context of a declarator's nested name ...
Definition: SemaDecl.cpp:1342
bool CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *MD, DefaultedComparisonKind DCK)
bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method)
Whether this' shows up in the exception specification of a static member function.
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, ExprResult Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member,...
llvm::FoldingSet< SpecialMemberOverloadResultEntry > SpecialMemberCache
A cache of special member function overload resolution results for C++ records.
Definition: Sema.h:8970
QualType BuildPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc, bool FullySubstituted=false, ArrayRef< QualType > Expansions={})
Definition: SemaType.cpp:9736
Decl * ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc, Expr *LangStr, SourceLocation LBraceLoc)
ActOnStartLinkageSpecification - Parsed the beginning of a C++ linkage specification,...
void FilterUsingLookup(Scope *S, LookupResult &lookup)
Remove decls we can't actually see from a lookup being used to declare shadow using decls.
Decl * ActOnExceptionDeclarator(Scope *S, Declarator &D)
ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch handler.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr, SourceLocation Loc)
PushNamespaceVisibilityAttr - Note that we've entered a namespace with a visibility attribute.
Definition: SemaAttr.cpp:1471
void ActOnDefaultCtorInitializers(Decl *CDtorDecl)
void ActOnMemInitializers(Decl *ConstructorDecl, SourceLocation ColonLoc, ArrayRef< CXXCtorInitializer * > MemInits, bool AnyErrors)
ActOnMemInitializers - Handle the member initializers for a constructor.
bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams)
Check whether a template can be declared within this scope.
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an initializer for the declaration ...
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
Definition: SemaExpr.cpp:216
void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc, Decl *TagDecl, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R)
Diagnose variable or built-in function shadowing.
Definition: SemaDecl.cpp:8302
void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don't have one.
Decl * ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *AssertMessageExpr, SourceLocation RParenLoc)
StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, bool AllowRecovery=false)
Definition: SemaStmt.cpp:3883
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
Definition: Sema.h:14945
bool CheckImmediateEscalatingFunctionDefinition(FunctionDecl *FD, const sema::FunctionScopeInfo *FSI)
void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor)
In the MS ABI, we need to instantiate default arguments of dllexported default constructors along wit...
@ CTK_ErrorRecovery
Definition: Sema.h:9384
void CheckCompleteVariableDeclaration(VarDecl *VD)
Definition: SemaDecl.cpp:14304
ExprResult ActOnRequiresClause(ExprResult ConstraintExpr)
void checkClassLevelCodeSegAttribute(CXXRecordDecl *Class)
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL,...
RedeclarationKind forRedeclarationInCurContext() const
LazyDeclPtr StdNamespace
The C++ "std" namespace, where the standard library resides.
Definition: Sema.h:6054
bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Previous)
Checks that the given using declaration is not an invalid redeclaration.
@ CCEK_StaticAssertMessageSize
Call to size() in a static assert message.
Definition: Sema.h:10005
@ CCEK_ExplicitBool
Condition in an explicit(bool) specifier.
Definition: Sema.h:10003
@ CCEK_StaticAssertMessageData
Call to data() in a static assert message.
Definition: Sema.h:10007
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
Definition: SemaDecl.cpp:3095
ASTConsumer & Consumer
Definition: Sema.h:910
void ActOnFinishCXXMemberDecls()
Perform any semantic analysis which needs to be delayed until all pending class member declarations h...
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
Definition: Sema.h:4227
@ Ovl_NonFunction
This is not an overload because the lookup results contain a non-function.
Definition: Sema.h:9787
@ Ovl_Overload
This is a legitimate overload: the existing declarations are functions or function templates with dif...
Definition: Sema.h:9779
@ Ovl_Match
This is not an overload because the signature exactly matches an existing declaration.
Definition: Sema.h:9783
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
Definition: SemaExpr.cpp:121
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Definition: SemaExpr.cpp:5120
Decl * ActOnFinishLinkageSpecification(Scope *S, Decl *LinkageSpec, SourceLocation RBraceLoc)
ActOnFinishLinkageSpecification - Complete the definition of the C++ linkage specification LinkageSpe...
bool CheckInheritingConstructorUsingDecl(UsingDecl *UD)
Additional checks for a using declaration referring to a constructor name.
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
QualType BuildDecltypeType(Expr *E, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
Definition: SemaType.cpp:9704
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
Definition: SemaType.cpp:5704
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
DeclResult ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, OffsetOfKind OOK, SkipBodyInfo *SkipBody=nullptr)
This is invoked when we see 'struct foo' or 'struct {'.
Definition: SemaDecl.cpp:17145
void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace)
ActOnFinishNamespaceDef - This callback is called after a namespace is exited.
MemInitResult BuildMemInitializer(Decl *ConstructorD, Scope *S, CXXScopeSpec &SS, IdentifierInfo *MemberOrBase, ParsedType TemplateTypeTy, const DeclSpec &DS, SourceLocation IdLoc, Expr *Init, SourceLocation EllipsisLoc)
Handle a C++ member initializer.
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:9119
void actOnDelayedExceptionSpecification(Decl *D, ExceptionSpecificationType EST, SourceRange SpecificationRange, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr)
Add an exception-specification to the given member or friend function (or function template).
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:872
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
Definition: SemaDecl.cpp:19003
void CheckExplicitObjectLambda(Declarator &D)
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD)
void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc)
PopPragmaVisibility - Pop the top element of the visibility stack; used for '#pragma GCC visibility' ...
Definition: SemaAttr.cpp:1480
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init)
Check that the lifetime of the initializer (and its subobjects) is sufficient for initializing the en...
Definition: SemaInit.cpp:7456
void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record)
Perform semantic checks on a class definition that has been completing, introducing implicitly-declar...
void DiscardCleanupsInEvaluationContext()
Definition: SemaExpr.cpp:17904
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:7917
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
Definition: SemaDecl.cpp:1310
bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
SourceManager & SourceMgr
Definition: Sema.h:912
bool CheckDestructor(CXXDestructorDecl *Destructor)
CheckDestructor - Checks a fully-formed destructor definition for well-formedness,...
NamedDecl * BuildUsingPackDecl(NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl * > Expansions)
MemInitResult ActOnMemInitializer(Decl *ConstructorD, Scope *S, CXXScopeSpec &SS, IdentifierInfo *MemberOrBase, ParsedType TemplateTypeTy, const DeclSpec &DS, SourceLocation IdLoc, SourceLocation LParenLoc, ArrayRef< Expr * > Args, SourceLocation RParenLoc, SourceLocation EllipsisLoc)
Handle a C++ member initializer using parentheses syntax.
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc, StringLiteral *Message=nullptr)
void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnStartDelayedCXXMethodDeclaration - We have completed parsing a top-level (non-nested) C++ class,...
DiagnosticsEngine & Diags
Definition: Sema.h:911
FullExprArg MakeFullDiscardedValueExpr(Expr *Arg)
Definition: Sema.h:7301
CXXConstructorDecl * DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit copy constructor for the given class.
NamespaceDecl * getStdNamespace() const
void DeclareImplicitEqualityComparison(CXXRecordDecl *RD, FunctionDecl *Spaceship)
bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier * > Bases)
Performs the actual work of attaching the given base class specifiers to a C++ class.
void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an initializer for the declaratio...
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Adjust the DeclContext for a function or variable that might be a function-local external declaration...
Definition: SemaDecl.cpp:7293
@ TPC_TypeAliasTemplate
Definition: Sema.h:11285
SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D, CXXSpecialMemberKind SM, bool ConstArg, bool VolatileArg, bool RValueThis, bool ConstThis, bool VolatileThis)
NamedDecl * ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *D, LookupResult &Previous, bool &Redeclaration)
ActOnTypedefNameDecl - Perform semantic checking for a declaration which declares a typedef-name,...
Definition: SemaDecl.cpp:6753
ExprResult ActOnIntegerConstant(SourceLocation Loc, int64_t Val)
Definition: SemaExpr.cpp:3598
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
Definition: SemaExpr.cpp:5581
Decl * ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList, SourceLocation SemiLoc)
Handle a C++11 empty-declaration and attribute-declaration.
void PopDeclContext()
Definition: SemaDecl.cpp:1317
void diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals, SourceLocation FallbackLoc, SourceLocation ConstQualLoc=SourceLocation(), SourceLocation VolatileQualLoc=SourceLocation(), SourceLocation RestrictQualLoc=SourceLocation(), SourceLocation AtomicQualLoc=SourceLocation(), SourceLocation UnalignedQualLoc=SourceLocation())
Definition: SemaType.cpp:2871
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
Definition: Sema.h:6066
QualType CheckConstructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckConstructorDeclarator - Called by ActOnDeclarator to check the well-formedness of the constructo...
ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in it, apply them to D.
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope.
Definition: SemaDecl.cpp:1581
FunctionDecl * FindDeallocationFunctionForDestructor(SourceLocation StartLoc, CXXRecordDecl *RD)
ExprResult ConvertMemberDefaultInitExpression(FieldDecl *FD, Expr *InitExpr, SourceLocation InitLoc)
bool IsInvalidSMECallConversion(QualType FromType, QualType ToType)
Definition: SemaExpr.cpp:8879
void checkIncorrectVTablePointerAuthenticationAttribute(CXXRecordDecl &RD)
Check that VTable Pointer authentication is only being set on the first first instantiation of the vt...
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope.
Definition: SemaDecl.cpp:1566
@ OOK_Outside
Definition: Sema.h:3868
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
Definition: SemaDecl.cpp:13377
bool isUsualDeallocationFunction(const CXXMethodDecl *FD)
void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD)
Produce notes explaining why a defaulted function was defined as deleted.
ExprResult BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, TypeSourceInfo *Ty, Expr *E, SourceRange AngleBrackets, SourceRange Parens)
Definition: SemaCast.cpp:296
bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionExceptionSpec - Checks whether the exception spec is a subset of base spec.
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
Definition: Sema.h:5809
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
Definition: SemaExpr.cpp:18085
bool CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams, TemplateParamListContext TPC, SkipBodyInfo *SkipBody=nullptr)
Checks the validity of a template parameter list, possibly considering the template parameter list fr...
bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionReturnType - Checks whether the return types are covariant,...
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr * > Args, SmallVectorImpl< Expr * > &AllArgs, VariadicCallType CallType=VariadicDoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
GatherArgumentsForCall - Collector argument expressions for various form of call prototypes.
Definition: SemaExpr.cpp:5953
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
Definition: SemaExpr.cpp:21168
Decl * ActOnDeclarator(Scope *S, Declarator &D)
Definition: SemaDecl.cpp:6088
AbstractDiagSelID
Definition: Sema.h:5755
@ AbstractVariableType
Definition: Sema.h:5759
@ AbstractReturnType
Definition: Sema.h:5757
@ AbstractNone
Definition: Sema.h:5756
@ AbstractFieldType
Definition: Sema.h:5760
@ AbstractArrayType
Definition: Sema.h:5763
@ AbstractParamType
Definition: Sema.h:5758
StmtResult ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal)
Definition: SemaStmt.cpp:962
MSPropertyDecl * HandleMSProperty(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS, const ParsedAttr &MSPropertyAttr)
HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
void ProcessAPINotes(Decl *D)
Map any API notes provided for this declaration to attributes on the declaration.
bool CheckRedeclarationInModule(NamedDecl *New, NamedDecl *Old)
A wrapper function for checking the semantic restrictions of a redeclaration within a module.
Definition: SemaDecl.cpp:1705
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
Definition: Sema.h:7966
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
CreateBuiltinBinOp - Creates a new built-in binary operation with operator Opc at location TokLoc.
Definition: SemaExpr.cpp:14768
void DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, bool First=true)
Emit diagnostics explaining why a constraint expression was deemed unsatisfied.
void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc)
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
CheckConstexprKind
Definition: Sema.h:5951
@ CheckValid
Identify whether this function satisfies the formal rules for constexpr functions in the current lanu...
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
void LoadExternalVTableUses()
Load any externally-stored vtable uses.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2751
Decl * ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc, SourceLocation NamespcLoc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *NamespcName, const ParsedAttributesView &AttrList)
StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R, ArrayRef< Stmt * > Elts, bool isStmtExpr)
Definition: SemaStmt.cpp:451
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
HandleFunctionTypeMismatch - Gives diagnostic information for differeing function types.
void ActOnStartTrailingRequiresClause(Scope *S, Declarator &D)
void FindHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl< CXXMethodDecl * > &OverloadedMethods)
Check if a method overloads virtual methods in a base class without overriding any.
IdentifierResolver IdResolver
Definition: Sema.h:3003
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record)
bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, TrivialABIHandling TAH=TAH_IgnoreTrivialABI, bool Diagnose=false)
Determine whether a defaulted or deleted special member function is trivial, as specified in C++11 [c...
ExprResult ActOnCXXThis(SourceLocation Loc)
bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc, UnexpandedParameterPackContext UPPC, ArrayRef< UnexpandedParameterPack > Unexpanded)
Diagnose unexpanded parameter packs.
CXXConstructorDecl * findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor, ConstructorUsingShadowDecl *DerivedShadow)
Given a derived-class using shadow declaration for a constructor and the correspnding base class cons...
void warnOnReservedIdentifier(const NamedDecl *D)
Definition: SemaDecl.cpp:6075
bool CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, SourceLocation DefaultLoc)
bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS)
Determine whether the identifier II is a typo for the name of the class type currently being defined.
Decl * ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList)
void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param)
ActOnDelayedCXXMethodParameter - We've already started a delayed C++ method declaration.
bool isAbstractType(SourceLocation Loc, QualType T)
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr, bool SkipImmediateInvocations=true)
Instantiate or parse a C++ default argument expression as necessary.
Definition: SemaExpr.cpp:5332
ValueDecl * tryLookupUnambiguousFieldDecl(RecordDecl *ClassDecl, const IdentifierInfo *MemberOrBase)
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:590
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, ArrayRef< CXXCtorInitializer * > Initializers={})
void DiagnoseImmediateEscalatingReason(FunctionDecl *FD)
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
Definition: Sema.h:8268
void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
CXXDestructorDecl * DeclareImplicitDestructor(CXXRecordDecl *ClassDecl)
Declare the implicit destructor for the given class.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID.
A trivial tuple used to represent a source range.
void setBegin(SourceLocation b)
bool isInvalid() const
SourceLocation getEnd() const
SourceLocation getBegin() const
bool isValid() const
void setEnd(SourceLocation e)
static StaticAssertDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *Message, SourceLocation RParenLoc, bool Failed)
Definition: DeclCXX.cpp:3438
Stmt - This represents one statement.
Definition: Stmt.h:84
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:357
child_range children()
Definition: Stmt.cpp:294
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:333
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:345
static bool isValidUDSuffix(const LangOptions &LangOpts, StringRef Suffix)
Determine whether a suffix is a valid ud-suffix.
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1778
bool isUnevaluated() const
Definition: Expr.h:1907
StringRef getString() const
Definition: Expr.h:1855
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3578
bool isBeingDefined() const
Return true if this decl is currently being defined.
Definition: Decl.h:3701
StringRef getKindName() const
Definition: Decl.h:3769
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3681
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:4751
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4745
bool isUnion() const
Definition: Decl.h:3784
TagKind getTagKind() const
Definition: Decl.h:3773
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition: Decl.h:3732
bool areArgsDestroyedLeftToRightInCallee() const
Are arguments to a call destroyed left to right in the callee? This is a fundamental language change,...
Definition: TargetCXXABI.h:188
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:136
bool hasKeyFunctions() const
Does this ABI use key functions? If so, class data such as the vtable is emitted with strong linkage ...
Definition: TargetCXXABI.h:206
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1262
virtual CallingConvKind getCallingConvKind(bool ClangABICompat4) const
Definition: TargetInfo.cpp:611
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1333
virtual bool shouldDLLImportComdatSymbols() const
Does this target aim for semantic compatibility with Microsoft C++ code using dllimport/export attrib...
Definition: TargetInfo.h:1300
A convenient class for passing around template argument information.
Definition: TemplateBase.h:632
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:667
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:659
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:524
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:574
TypeSourceInfo * getTypeSourceInfo() const
Definition: TemplateBase.h:578
Represents a template argument.
Definition: TemplateBase.h:61
@ Type
The template argument is a type.
Definition: TemplateBase.h:70
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:295
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:418
Represents a C++ template name within the type system.
Definition: TemplateName.h:220
TemplateDecl * getAsTemplateDecl(bool IgnoreDeduced=false) const
Retrieve the underlying template declaration that this template name refers to, if known.
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:73
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:147
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclTemplate.h:209
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization.
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
Definition: DeclTemplate.h:183
SourceLocation getRAngleLoc() const
Definition: DeclTemplate.h:207
SourceLocation getLAngleLoc() const
Definition: DeclTemplate.h:206
static bool shouldIncludeTypeForArgument(const PrintingPolicy &Policy, const TemplateParameterList *TPL, unsigned Idx)
SourceLocation getTemplateLoc() const
Definition: DeclTemplate.h:205
TemplateArgumentLoc getArgLoc(unsigned i) const
Definition: TypeLoc.h:1726
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:6666
ArrayRef< TemplateArgument > template_arguments() const
Definition: Type.h:6734
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:6732
Declaration of a template type parameter.
unsigned getIndex() const
Retrieve the index of the template parameter.
unsigned getDepth() const
Retrieve the depth of the template parameter.
unsigned getIndex() const
Definition: Type.h:6348
unsigned getDepth() const
Definition: Type.h:6347
The top declaration context.
Definition: Decl.h:84
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3549
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:5580
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Definition: Decl.h:3568
Declaration of an alias template.
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Represents a declaration of a type.
Definition: Decl.h:3384
const Type * getTypeForDecl() const
Definition: Decl.h:3409
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:59
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:133
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
Definition: TypeLoc.h:170
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:89
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1256
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
Definition: TypeLoc.h:78
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:153
SourceRange getLocalSourceRange() const
Get the local source range.
Definition: TypeLoc.h:159
TypeLocClass getTypeLocClass() const
Definition: TypeLoc.h:116
bool isNull() const
Definition: TypeLoc.h:121
SourceLocation getEndLoc() const
Get the end source location.
Definition: TypeLoc.cpp:235
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:2715
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:192
A container of type source information.
Definition: Type.h:7907
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:256
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:7918
A reasonable base class for TypeLocs that correspond to types that are written as a type-specifier.
Definition: TypeLoc.h:528
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
Definition: Type.cpp:3196
static StringRef getTagTypeKindName(TagTypeKind Kind)
Definition: Type.h:6929
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition: Type.cpp:3178
The base class of the type hierarchy.
Definition: Type.h:1828
bool isSizelessType() const
As an extension, we classify types as one of "sized" or "sizeless"; every type is one or the other.
Definition: Type.cpp:2511
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1916
bool isVoidType() const
Definition: Type.h:8515
bool isBooleanType() const
Definition: Type.h:8643
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition: Type.cpp:2937
bool isIncompleteArrayType() const
Definition: Type.h:8271
bool isUndeducedAutoType() const
Definition: Type.h:8350
bool isRValueReferenceType() const
Definition: Type.h:8217
bool isArrayType() const
Definition: Type.h:8263
bool isPointerType() const
Definition: Type.h:8191
CanQualType getCanonicalTypeUnqualified() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:8555
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:8805
bool isReferenceType() const
Definition: Type.h:8209
bool isEnumeralType() const
Definition: Type.h:8295
bool isElaboratedTypeSpecifier() const
Determine wither this type is a C++ elaborated-type-specifier.
Definition: Type.cpp:3303
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:738
bool isLValueReferenceType() const
Definition: Type.h:8213
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:8484
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2706
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:2361
QualType getCanonicalTypeInternal() const
Definition: Type.h:2989
bool containsErrors() const
Whether this type is an error type.
Definition: Type.h:2700
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:8686
bool isFunctionProtoType() const
Definition: Type.h:2535
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
Definition: Type.h:8656
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:2724
bool isObjCObjectType() const
Definition: Type.h:8337
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Definition: Type.h:8649
bool isFunctionType() const
Definition: Type.h:8187
bool isObjCObjectPointerType() const
Definition: Type.h:8333
bool isStructureOrClassType() const
Definition: Type.cpp:690
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:2300
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:8736
bool isRecordType() const
Definition: Type.h:8291
bool isUnionType() const
Definition: Type.cpp:704
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
Definition: Type.cpp:1924
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Definition: Type.cpp:1920
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3427
QualType getUnderlyingType() const
Definition: Decl.h:3482
Simple class containing the result of Sema::CorrectTypo.
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
SourceRange getCorrectionRange() const
void WillReplaceSpecifier(bool ForceReplacement)
DeclClass * getCorrectionDeclAs() const
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition: Expr.h:2232
static UnaryOperator * Create(const ASTContext &C, Expr *input, Opcode opc, QualType type, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, bool CanOverflow, FPOptionsOverride FPFeatures)
Definition: Expr.cpp:4959
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:1028
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent, bool KnownInstantiationDependent)
Definition: ExprCXX.cpp:419
A set of unresolved declarations.
Definition: UnresolvedSet.h:62
ArrayRef< DeclAccessPair > pairs() const
Definition: UnresolvedSet.h:90
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:35
A set of unresolved declarations.
This node is generated when a using-declaration that was annotated with attribute((using_if_exists)) ...
Definition: DeclCXX.h:4063
static UnresolvedUsingIfExistsDecl * Create(ASTContext &Ctx, DeclContext *DC, SourceLocation Loc, DeclarationName Name)
Definition: DeclCXX.cpp:3417
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3982
static UnresolvedUsingTypenameDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation TypenameLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TargetNameLoc, DeclarationName TargetName, SourceLocation EllipsisLoc)
Definition: DeclCXX.cpp:3396
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3885
static UnresolvedUsingValueDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, SourceLocation EllipsisLoc)
Definition: DeclCXX.cpp:3368
Represents a C++ using-declaration.
Definition: DeclCXX.h:3535
bool hasTypename() const
Return true if the using declaration has 'typename'.
Definition: DeclCXX.h:3584
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:3576
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
Definition: DeclCXX.cpp:3303
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name.
Definition: DeclCXX.h:3572
SourceLocation getUsingLoc() const
Return the source location of the 'using' keyword.
Definition: DeclCXX.h:3562
Represents C++ using-directive.
Definition: DeclCXX.h:3038
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Definition: DeclCXX.cpp:3090
Represents a C++ using-enum-declaration.
Definition: DeclCXX.h:3736
static UsingEnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, SourceLocation EnumL, SourceLocation NameL, TypeSourceInfo *EnumType)
Definition: DeclCXX.cpp:3324
static UsingPackDecl * Create(ASTContext &C, DeclContext *DC, NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl * > UsingDecls)
Definition: DeclCXX.cpp:3347
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Definition: DeclCXX.h:3343
static UsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, DeclarationName Name, BaseUsingDecl *Introducer, NamedDecl *Target)
Definition: DeclCXX.h:3379
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Definition: DeclCXX.h:3407
BaseUsingDecl * getIntroducer() const
Gets the (written or instantiated) using declaration that introduced this declaration.
Definition: DeclCXX.cpp:3243
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:671
void setType(QualType newType)
Definition: Decl.h:683
QualType getType() const
Definition: Decl.h:682
Represents a variable declaration or definition.
Definition: Decl.h:882
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition: Decl.cpp:2786
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:2140
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1513
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
Definition: Decl.cpp:2249
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2179
bool isNoDestroy(const ASTContext &) const
Is destruction of this variable entirely suppressed? If so, the variable need not have a usable destr...
Definition: Decl.cpp:2812
void setCXXCondDecl()
Definition: Decl.h:1563
bool isInlineSpecified() const
Definition: Decl.h:1498
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2547
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1234
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:1177
bool hasConstantInitialization() const
Determine whether this variable has constant initialization.
Definition: Decl.cpp:2620
bool evaluateDestruction(SmallVectorImpl< PartialDiagnosticAt > &Notes) const
Evaluate the destruction of this variable to determine if it constitutes constant destruction.
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1159
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
Definition: Decl.cpp:2827
ThreadStorageClassSpecifier getTSCSpec() const
Definition: Decl.h:1128
const Expr * getInit() const
Definition: Decl.h:1319
@ TLS_Dynamic
TLS with a dynamic initializer.
Definition: Decl.h:908
void setInit(Expr *I)
Definition: Decl.cpp:2449
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1119
bool isUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
Definition: Decl.cpp:2500
void setExceptionVariable(bool EV)
Definition: Decl.h:1441
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
Definition: Decl.cpp:2662
Declaration of a variable template.
Represents a GCC generic vector type.
Definition: Type.h:4034
unsigned getNumElements() const
Definition: Type.h:4049
QualType getElementType() const
Definition: Type.h:4048
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2783
SourceLocation getOverrideLoc() const
Definition: DeclSpec.h:2803
SourceLocation getLastLocation() const
Definition: DeclSpec.h:2815
bool isOverrideSpecified() const
Definition: DeclSpec.h:2802
SourceLocation getFinalLoc() const
Definition: DeclSpec.h:2807
bool isFinalSpecified() const
Definition: DeclSpec.h:2805
bool isFinalSpelledSealed() const
Definition: DeclSpec.h:2806
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:104
bool FoundImmediateEscalatingExpression
Whether we found an immediate-escalating expression.
Definition: ScopeInfo.h:179
Defines the clang::TargetInfo interface.
#define UINT_MAX
Definition: limits.h:64
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
bool Inc(InterpState &S, CodePtr OpPC)
1) Pops a pointer from the stack 2) Load the value from the pointer 3) Writes the value increased by ...
Definition: Interp.h:824
bool Zero(InterpState &S, CodePtr OpPC)
Definition: Interp.h:2353
bool Comp(InterpState &S, CodePtr OpPC)
1) Pops the value from the stack.
Definition: Interp.h:925
Stencil access(llvm::StringRef BaseId, Stencil Member)
Constructs a MemberExpr that accesses the named member (Member) of the object bound to BaseId.
The JSON file list parser is used to communicate input to InstallAPI.
bool FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI)
Definition: SemaInternal.h:32
TypeSpecifierType
Specifies the kind of type.
Definition: Specifiers.h:55
@ TST_decltype
Definition: Specifiers.h:89
@ TST_typename_pack_indexing
Definition: Specifiers.h:97
@ TST_decltype_auto
Definition: Specifiers.h:93
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:21
@ OO_None
Not an overloaded operator.
Definition: OperatorKinds.h:22
@ NUM_OVERLOADED_OPERATORS
Definition: OperatorKinds.h:26
bool isa(CodeGen::Address addr)
Definition: Address.h:328
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:212
@ CPlusPlus23
Definition: LangStandard.h:60
@ CPlusPlus20
Definition: LangStandard.h:59
@ CPlusPlus
Definition: LangStandard.h:55
@ CPlusPlus11
Definition: LangStandard.h:56
@ CPlusPlus14
Definition: LangStandard.h:57
@ CPlusPlus26
Definition: LangStandard.h:61
@ CPlusPlus17
Definition: LangStandard.h:58
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
@ OR_Deleted
Succeeded, but refers to a deleted function.
Definition: Overload.h:61
@ OR_Success
Overload resolution succeeded.
Definition: Overload.h:52
@ OR_Ambiguous
Ambiguous candidates found.
Definition: Overload.h:58
@ OR_No_Viable_Function
No viable function found.
Definition: Overload.h:55
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
LinkageSpecLanguageIDs
Represents the language in a linkage specification.
Definition: DeclCXX.h:2949
InClassInitStyle
In-class initialization styles for non-static data members.
Definition: Specifiers.h:271
@ ICIS_ListInit
Direct list-initialization.
Definition: Specifiers.h:274
@ ICIS_NoInit
No in-class initializer.
Definition: Specifiers.h:272
@ RQ_None
No ref-qualifier was provided.
Definition: Type.h:1768
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1774
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
Definition: Overload.h:73
@ OCD_AllCandidates
Requests that all candidates be shown.
Definition: Overload.h:67
CXXConstructionKind
Definition: ExprCXX.h:1538
@ OK_Ordinary
An ordinary object is located at an address in memory.
Definition: Specifiers.h:151
BinaryOperatorKind
@ If
'if' clause, allowed on all the Compute Constructs, Data Constructs, Executable Constructs,...
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
@ IK_DeductionGuideName
A deduction-guide name (a template-name)
@ IK_ImplicitSelfParam
An implicit 'self' parameter.
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_ConstructorTemplateId
A constructor named via a template-id.
@ IK_ConstructorName
A constructor name.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
@ IK_DestructorName
A destructor name.
@ IK_OperatorFunctionId
An overloaded operator name, e.g., operator+.
@ IK_ConversionFunctionId
A conversion function name, e.g., operator int.
std::optional< ComparisonCategoryType > getComparisonCategoryForBuiltinCmp(QualType T)
Get the comparison category that should be used when comparing values of type T.
StorageClass
Storage classes.
Definition: Specifiers.h:248
@ SC_Static
Definition: Specifiers.h:252
@ SC_None
Definition: Specifiers.h:250
ThreadStorageClassSpecifier
Thread storage-class-specifier.
Definition: Specifiers.h:235
ComparisonCategoryType commonComparisonType(ComparisonCategoryType A, ComparisonCategoryType B)
Determine the common comparison type, as defined in C++2a [class.spaceship]p4.
ComparisonCategoryResult
An enumeration representing the possible results of a three-way comparison.
Language
The language for the input, used to select and validate the language standard and possible actions.
Definition: LangStandard.h:23
StmtResult StmtError()
Definition: Ownership.h:265
@ Result
The result type of a method or function.
std::pair< unsigned, unsigned > getDepthAndIndex(const NamedDecl *ND)
Retrieve the depth and index of a template parameter.
Definition: SemaInternal.h:61
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
Definition: SemaInternal.h:50
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
void EscapeStringForDiagnostic(StringRef Str, SmallVectorImpl< char > &OutStr)
EscapeStringForDiagnostic - Append Str to the diagnostic buffer, escaping non-printable characters an...
Definition: Diagnostic.cpp:985
ReservedLiteralSuffixIdStatus
ActionResult< Expr * > ExprResult
Definition: Ownership.h:248
TagTypeKind
The kind of a tag type.
Definition: Type.h:6876
@ Interface
The "__interface" keyword.
@ Struct
The "struct" keyword.
@ Class
The "class" keyword.
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
Definition: Ownership.h:262
ExprResult ExprError()
Definition: Ownership.h:264
LangAS
Defines the address space values used by the address space qualifier of QualType.
Definition: AddressSpaces.h:25
@ CanPassInRegs
The argument of this type can be passed directly in registers.
@ CanNeverPassInRegs
The argument of this type cannot be passed directly in registers.
@ CannotPassInRegs
The argument of this type cannot be passed directly in registers.
@ TU_Prefix
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:1102
ComparisonCategoryType
An enumeration representing the different comparison categories types.
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:249
CXXSpecialMemberKind
Kinds of C++ special members.
Definition: Sema.h:423
OverloadedOperatorKind getRewrittenOverloadedOperator(OverloadedOperatorKind Kind)
Get the other overloaded operator that the given operator can be rewritten into, if any such operator...
Definition: OperatorKinds.h:36
@ TNK_Concept_template
The name refers to a concept.
Definition: TemplateKinds.h:52
ActionResult< ParsedType > TypeResult
Definition: Ownership.h:250
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:132
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:135
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
Definition: Specifiers.h:144
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:139
const FunctionProtoType * T
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1274
std::pair< llvm::PointerUnion< const TemplateTypeParmType *, NamedDecl * >, SourceLocation > UnexpandedParameterPack
Definition: Sema.h:236
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
@ Incomplete
Template argument deduction did not deduce a value for every template parameter.
@ Inconsistent
Template argument deduction produced inconsistent deduced values for the given template parameter.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:188
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:206
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:202
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
Definition: Specifiers.h:198
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:194
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
Definition: Specifiers.h:191
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:278
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:6851
@ None
No keyword precedes the qualified type name.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
bool isExternallyVisible(Linkage L)
Definition: Linkage.h:90
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
@ EST_DependentNoexcept
noexcept(expression), value-dependent
@ EST_DynamicNone
throw()
@ EST_Uninstantiated
not instantiated yet
@ EST_Unparsed
not parsed yet
@ EST_NoThrow
Microsoft __declspec(nothrow) extension.
@ EST_None
no exception specification
@ EST_MSAny
Microsoft throw(...) extension.
@ EST_BasicNoexcept
noexcept
@ EST_NoexceptFalse
noexcept(expression), evals to 'false'
@ EST_Unevaluated
not evaluated yet, for special member function
@ EST_NoexceptTrue
noexcept(expression), evals to 'true'
@ EST_Dynamic
throw(T1, T2)
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:123
@ AS_public
Definition: Specifiers.h:124
@ AS_protected
Definition: Specifiers.h:125
@ AS_none
Definition: Specifiers.h:127
@ AS_private
Definition: Specifiers.h:126
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:258
@ NOUR_Unevaluated
This name appears in an unevaluated operand.
Definition: Specifiers.h:177
#define true
Definition: stdbool.h:25
#define false
Definition: stdbool.h:26
bool hasValidIntValue() const
True iff we've successfully evaluated the variable as a constant expression and extracted its integer...
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setNamedTypeInfo(TypeSourceInfo *TInfo)
setNamedTypeInfo - Sets the source type info associated to the name.
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
SourceRange getSourceRange() const LLVM_READONLY
getSourceRange - The range of the declaration name.
SourceLocation getEndLoc() const LLVM_READONLY
bool containsUnexpandedParameterPack() const
Determine whether this name contains an unexpanded parameter pack.
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with ',...)',...
Definition: DeclSpec.h:1368
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
Definition: DeclSpec.h:1428
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
Definition: DeclSpec.h:1377
DeclSpec * MethodQualifiers
DeclSpec for the function with the qualifier related info.
Definition: DeclSpec.h:1431
SourceLocation getRefQualifierLoc() const
Retrieve the location of the ref-qualifier, if any.
Definition: DeclSpec.h:1529
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1403
bool hasMutableQualifier() const
Determine whether this lambda-declarator contains a 'mutable' qualifier.
Definition: DeclSpec.h:1558
bool hasMethodTypeQualifiers() const
Determine whether this method has qualifiers.
Definition: DeclSpec.h:1561
void freeParams()
Reset the parameter list to having zero parameters.
Definition: DeclSpec.h:1467
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
Definition: DeclSpec.h:1554
std::unique_ptr< CachedTokens > DefaultArgTokens
DefaultArgTokens - When the parameter's default argument cannot be parsed immediately (because it occ...
Definition: DeclSpec.h:1343
One instance of this struct is used for each type in a declarator that is parsed.
Definition: DeclSpec.h:1251
SourceRange getSourceRange() const
Definition: DeclSpec.h:1263
enum clang::DeclaratorChunk::@225 Kind
FunctionTypeInfo Fun
Definition: DeclSpec.h:1642
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:642
Holds information about the various types of exception specification.
Definition: Type.h:5164
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:5176
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:5166
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:5169
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Definition: Type.h:5172
Extra information about a function prototype.
Definition: Type.h:5192
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:5199
FunctionEffectsRef FunctionEffects
Definition: Type.h:5202
FunctionType::ExtInfo ExtInfo
Definition: Type.h:5193
T * get(ExternalASTSource *Source) const
Retrieve the pointer to the AST node that this lazy pointer points to.
Information about operator rewrites to consider when adding operator functions to a candidate set.
Definition: Overload.h:1038
Describes how types, statements, expressions, and declarations should be printed.
Definition: PrettyPrinter.h:57
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
Definition: Sema.h:12660
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
Definition: Sema.h:12777
@ MarkingClassDllexported
We are marking a class as __dllexport.
Definition: Sema.h:12754
@ InitializingStructuredBinding
We are initializing a structured binding.
Definition: Sema.h:12751
@ ExceptionSpecEvaluation
We are computing the exception specification for a defaulted special member function.
Definition: Sema.h:12704
@ DeclaringSpecialMember
We are declaring an implicit special member function.
Definition: Sema.h:12718
@ DeclaringImplicitEqualityComparison
We are declaring an implicit 'operator==' for a defaulted 'operator<=>'.
Definition: Sema.h:12722
Decl * Entity
The entity that is being synthesized.
Definition: Sema.h:12780
CXXSpecialMemberKind SpecialMember
The special member being declared or defined.
Definition: Sema.h:12806
Abstract class used to diagnose incomplete types.
Definition: Sema.h:7858
virtual void diagnose(Sema &S, SourceLocation Loc, QualType T)=0
Information about a template-id annotation token.
TemplateNameKind Kind
The kind of template that Template refers to.
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.